FluentLenium/FluentLenium

View on GitHub

Showing 142 of 1,951 total issues

File FluentLeniumWaitElementTest.java has 308 lines of code (exceeds 250 allowed). Consider refactoring.
Open

package io.fluentlenium.test.await;

import io.fluentlenium.core.FluentPage;
import io.fluentlenium.core.domain.FluentList;
import io.fluentlenium.core.domain.FluentWebElement;

    FluentWait has 28 methods (exceeds 20 allowed). Consider refactoring.
    Open

    public class FluentWait
            implements FluentWaitFunctional<FluentControl>, FluentWaitConditions<FluentWait>, FluentWaitConfiguration<FluentWait> {
    
        private final org.openqa.selenium.support.ui.FluentWait<FluentControl> wait;
        private final WebDriver driver;

      DefaultPerformanceTimingMetrics has 28 methods (exceeds 20 allowed). Consider refactoring.
      Open

      public class DefaultPerformanceTimingMetrics implements PerformanceTimingMetrics<DefaultPerformanceTimingMetrics> {
      
          /**
           * The values are stored as {@link Object}s because not all values have type {@code long}.
           */

        ComponentInstantiator has 28 methods (exceeds 20 allowed). Consider refactoring.
        Open

        public interface ComponentInstantiator {
        
            /**
             * Create and register a new {@code FluentWebElement} from the given {@code WebElement}.
             *

          Method testFluentWebElementClass has 83 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              @Test
              public void testFluentWebElementClass() { // NOPMD ExcessiveMethodLength
                  FluentWebElementClassContainer container = new FluentWebElementClassContainer();
          
                  WebElement element = mock(WebElement.class);

            Method fromAtLeastOneElementConditions has 81 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                @Test
                public void fromAtLeastOneElementConditions() { // NOPMD ExcessiveMethodLength
                    AtLeastOneElementConditions conditions = new AtLeastOneElementConditions(
                            Arrays.asList(fluentWebElement1, fluentWebElement2, fluentWebElement3));
            
            

              EventsSupport has 27 methods (exceeds 20 allowed). Consider refactoring.
              Open

              @SuppressWarnings("PMD.GodClass")
              public class EventsSupport implements EventListener {
              
                  private final EventsRegistry eventsRegistry;
              
              

                BaseHook has 27 methods (exceeds 20 allowed). Consider refactoring.
                Open

                public class BaseHook<T> extends DefaultFluentContainer implements FluentHook<T> {
                    private final ComponentInstantiator instantiator;
                
                    private final Supplier<ElementLocator> locatorSupplier;
                
                

                  UrlTemplateTest has 27 methods (exceeds 20 allowed). Consider refactoring.
                  Open

                  public class UrlTemplateTest {
                  
                      @Test
                      public void testOnlyParameter() {
                          UrlTemplate urlParametersTemplate = new UrlTemplate("{param1}");

                    EventListener has 27 methods (exceeds 20 allowed). Consider refactoring.
                    Open

                    public interface EventListener {
                    
                        /**
                         * Called before {@link org.openqa.selenium.WebDriver#get get(String url)},
                         * {@link org.openqa.selenium.WebDriver.Navigation#to navigate().to(String url)}.

                      File FluentDriver.java has 293 lines of code (exceeds 250 allowed). Consider refactoring.
                      Open

                      package io.fluentlenium.core;
                      
                      import io.appium.java_client.AppiumDriver;
                      import io.fluentlenium.configuration.Configuration;
                      import io.fluentlenium.core.action.KeyboardActions;

                        FluentSelectorTest has 26 methods (exceeds 20 allowed). Consider refactoring.
                        Open

                        class FluentSelectorTest extends IntegrationFluentTest {
                        
                            @Test
                            void checkWithNameCssSelector() {
                                goTo(DEFAULT_URL);

                          File ProxiesTest.java has 290 lines of code (exceeds 250 allowed). Consider refactoring.
                          Open

                          package io.fluentlenium.core.proxy;
                          
                          import io.fluentlenium.core.domain.WrapsElements;
                          import org.assertj.core.api.Assertions;
                          import org.junit.Before;

                            Method testNavigate has 71 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                @Test
                                public void testNavigate() { // NOPMD ExcessiveMethodLength
                                    EventsRegistry eventsRegistry = new EventsRegistry(fluentAdapter);
                            
                                    assertThat(eventsRegistry.getWrappedDriver()).isSameAs(driver);

                              FluentListAssert has 25 methods (exceeds 20 allowed). Consider refactoring.
                              Open

                              @SuppressWarnings("unchecked")
                              public class FluentListAssert extends AbstractFluentAssert<FluentListAssert, FluentList>
                                      implements ListStateAssert, ListAttributeAssert {
                              
                                  public FluentListAssert(FluentList<? extends FluentWebElement> actual) {

                                FluentWaitElementList has 25 methods (exceeds 20 allowed). Consider refactoring.
                                Open

                                public class FluentWaitElementList implements FluentWaitFunctional<FluentControl>, FluentWaitConditions<FluentWaitElementList>,
                                        FluentWaitConfiguration<FluentWaitElementList> {
                                    private final List<? extends FluentWebElement> elements;
                                
                                    private final FluentWait controlWait;

                                  Method fromEachElementConditions has 70 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                      @Test
                                      public void fromEachElementConditions() { // NOPMD ExcessiveMethodLength
                                          EachElementConditions conditions = new EachElementConditions(
                                                  Arrays.asList(fluentWebElement1, fluentWebElement2, fluentWebElement3));
                                  
                                  

                                    File FluentInjectorElementTest.java has 279 lines of code (exceeds 250 allowed). Consider refactoring.
                                    Open

                                    package io.fluentlenium.core.inject;
                                    
                                    import io.fluentlenium.adapter.FluentAdapter;
                                    import io.fluentlenium.core.FluentControl;
                                    import io.fluentlenium.core.components.ComponentInstantiator;

                                      AtLeastOneElementConditionsTest has 24 methods (exceeds 20 allowed). Consider refactoring.
                                      Open

                                      public class AtLeastOneElementConditionsTest extends AbstractFluentListConditionsTest {
                                          private AtLeastOneElementConditions conditions;
                                      
                                          @Before
                                          public void before() {

                                        FluentWaitElement has 24 methods (exceeds 20 allowed). Consider refactoring.
                                        Open

                                        public class FluentWaitElement implements FluentWaitFunctional<FluentControl>, FluentWaitConditions<FluentWaitElement>,
                                                FluentWaitConfiguration<FluentWaitElement> {
                                            private final FluentWebElement element;
                                        
                                            private final FluentWait controlWait;
                                          Severity
                                          Category
                                          Status
                                          Source
                                          Language