geb.content.TemplateDerivedPageContent.groovy Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of geb-core Show documentation
Geb (pronounced "jeb") is a browser automation solution. It brings together the power of WebDriver, the elegance of jQuery content selection, the robustness of Page Object modelling and the expressiveness of the Groovy language.
There is a newer version: 7.0
Show newest version
/* Copyright 2009 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package geb.content

import geb.Browser
import geb.Module
import geb.error.RequiredPageContentNotPresent
import geb.navigator.Navigator
import org.openqa.selenium.By
import org.openqa.selenium.WebDriver

@SuppressWarnings("FieldName")
@SuppressWarnings("EqualsAndHashCode")
class TemplateDerivedPageContent implements Navigator {

    private PageContentTemplate _template
    private Object[] _args
    private Browser _browser
    private StringRepresentationProvider _stringRepresentationProvider

    @Delegate
    protected Navigator _navigator

    TemplateDerivedPageContent(Browser browser, PageContentTemplate template, Navigator navigator, Object[] args) {
        this._browser = browser
        this._template = template
        this._navigator = navigator
        this._args = args
        this._stringRepresentationProvider = new TemplateDerivedContentStringRepresentationProvider(template, args, navigator)
    }

    String toString() {
        _stringRepresentationProvider.stringRepresentation
    }

    Browser getBrowser() {
        _browser
    }

    WebDriver getDriver() {
        getBrowser().driver
    }

    boolean isPresent() {
        !_navigator.empty
    }

    void require() {
        if (!isPresent()) {
            throw new RequiredPageContentNotPresent(this)
        }
        this
    }

    Navigator click() {
        def to = templateParams.toSingle ?: templateParams.toList
        if (to) {
            def toWait = _template.config.getWaitForParam(templateParams.toWait)
            _navigator.click(to, toWait)
        } else {
            _navigator.click()
        }
    }

    PageContentTemplateParams getTemplateParams() {
        _template.params
    }

    boolean asBoolean() {
        _navigator.asBoolean()
    }

    def methodMissing(String name, args) {
        _navigator."$name"(*args)
    }

    def propertyMissing(String name) {
        _navigator[name]
    }

    def propertyMissing(String name, val) {
        _navigator[name] = val
    }

    @Override
    Navigator $(Map predicates) {
        _navigator.$(predicates)
    }

    @Override
    Navigator $(Map predicates, int index) {
        _navigator.$(predicates, index)
    }

    @Override
    Navigator $(Map predicates, Range range) {
        _navigator.$(predicates, range)
    }

    @Override
    Navigator $(Map predicates, String selector) {
        _navigator.$(predicates, selector)
    }

    @Override
    Navigator $(Map predicates, String selector, int index) {
        _navigator.$(predicates, selector, index)
    }

    @Override
    Navigator $(Map predicates, String selector, Range range) {
        _navigator.$(predicates, selector, range)
    }

    @Override
    Navigator $(String selector) {
        _navigator.$(selector)
    }

    @Override
    Navigator $(String selector, int index) {
        _navigator.$(selector, index)
    }

    @Override
    Navigator $(String selector, Range range) {
        _navigator.$(selector, range)
    }

    @Override
    Navigator $(Map predicates, By bySelector) {
        _navigator.$(predicates, bySelector)
    }

    @Override
    Navigator $(Map predicates, By bySelector, int index) {
        _navigator.$(predicates, bySelector, index)
    }

    @Override
    Navigator $(Map predicates, By bySelector, Range range) {
        _navigator.$(predicates, bySelector, range)
    }

    @Override
    Navigator $(By bySelector) {
        _navigator.$(bySelector)
    }

    @Override
    Navigator $(By bySelector, int index) {
        _navigator.$(bySelector, index)
    }

    @Override
    Navigator $(By bySelector, Range range) {
        _navigator.$(bySelector, range)
    }

    @Override
    //necessary because @Delegate generates wrong method signature for this method
     T module(Class moduleClass) {
        _navigator.module(moduleClass)
    }

    @Override
    //necessary because @Delegate generates wrong method signature for this method
     T module(T module) {
        _navigator.module(module)
    }

    @Override
    //necessary because @Delegate generates wrong method signature for this method
     List moduleList(Class moduleClass) {
        _navigator.moduleList(moduleClass)
    }

    @Override
    //necessary because @Delegate generates wrong method signature for this method
     List moduleList(Closure moduleFactory) {
        _navigator.moduleList(moduleFactory)
    }

    @Override
    boolean isFocused() {
        _navigator.focused
    }

    @Override
    boolean equals(Object o) {
        if (o instanceof TemplateDerivedPageContent) {
            _navigator == o._navigator
        } else {
            def values = iterator()*.value().findAll { it != null }
            def value
            switch (values.size()) {
                case 0:
                    value = null
                    break
                case 1:
                    value = values.first()
                    break
                default:
                    value = values
            }
            value == o
        }
    }
}