FluentLenium/FluentLenium

View on GitHub

Showing 142 of 1,951 total issues

FluentDriver has 39 methods (exceeds 20 allowed). Consider refactoring.
Open

@SuppressWarnings("PMD.GodClass")
public class FluentDriver extends AbstractFluentDriverSearchControl { // NOPMD GodClass

    private static final Logger LOGGER =
            LoggerFactory.getLogger(FluentDriver.class);

    File FluentListImplTest.java has 375 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    package io.fluentlenium.core.domain;
    
    import com.google.common.collect.Lists;
    import io.fluentlenium.adapter.FluentAdapter;
    import io.fluentlenium.core.FluentControl;

      EventsRegistry has 37 methods (exceeds 20 allowed). Consider refactoring.
      Open

      public class EventsRegistry implements WrapsDriver { // NOPMD TooManyFields
      
          private final EventFiringWebDriver eventDriver;
      
          private final EventsSupport support;

        File FluentListAssertTest.java has 368 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        package io.fluentlenium.assertj.custom;
        
        import com.google.common.collect.Lists;
        import io.fluentlenium.assertj.FluentLeniumAssertions;
        import io.fluentlenium.core.domain.FluentList;

          File FluentLeniumFunctionalWaitTest.java has 353 lines of code (exceeds 250 allowed). Consider refactoring.
          Open

          package io.fluentlenium.test.await;
          
          import io.fluentlenium.core.filter.FilterConstructor;
          import io.fluentlenium.core.filter.MatcherConstructor;
          import io.fluentlenium.test.IntegrationFluentTest;

            PropertiesBackendConfigurationTest has 33 methods (exceeds 20 allowed). Consider refactoring.
            Open

            @RunWith(MockitoJUnitRunner.class)
            public class PropertiesBackendConfigurationTest {
            
                private static final String DRIVER_LIFECYCLE = "driverLifecycle";
                @Mock

              File FluentWebElementTest.java has 334 lines of code (exceeds 250 allowed). Consider refactoring.
              Open

              package io.fluentlenium.core.domain;
              
              import io.fluentlenium.adapter.FluentAdapter;
              import io.fluentlenium.core.components.ComponentException;
              import io.fluentlenium.core.components.ComponentsManager;

                FluentWaitElementListTest has 32 methods (exceeds 20 allowed). Consider refactoring.
                Open

                @RunWith(MockitoJUnitRunner.class)
                public class FluentWaitElementListTest {
                    @Mock
                    private FluentWait fluentControlWait;
                
                

                  PropertiesBackendConfiguration has 32 methods (exceeds 20 allowed). Consider refactoring.
                  Open

                  @SuppressWarnings("PMD.GodClass")
                  public class PropertiesBackendConfiguration extends BaseConfiguration implements ConfigurationProperties {
                      /**
                       * Default properties prefix.
                       */

                    FluentList has 32 methods (exceeds 20 allowed). Consider refactoring.
                    Open

                    public interface FluentList<E extends FluentWebElement>
                            extends List<E>, FluentActions<FluentList<E>, E>, FluentProxyState<FluentList<E>>, SearchControl<E>,
                            HookControl<FluentList<E>>, FluentLabel<FluentList<E>> {
                    
                        /**

                      File FluentWaitEachElementMatcherTest.java has 333 lines of code (exceeds 250 allowed). Consider refactoring.
                      Open

                      package io.fluentlenium.core.wait;
                      
                      import io.fluentlenium.core.FluentDriver;
                      import io.fluentlenium.core.conditions.FluentListConditions;
                      import io.fluentlenium.core.conditions.WebElementConditions;

                        File FluentWaitElementListMatcherTest.java has 331 lines of code (exceeds 250 allowed). Consider refactoring.
                        Open

                        package io.fluentlenium.core.wait;
                        
                        import io.fluentlenium.core.FluentDriver;
                        import io.fluentlenium.core.conditions.FluentListConditions;
                        import io.fluentlenium.core.conditions.WebElementConditions;

                          AnnotationConfiguration has 31 methods (exceeds 20 allowed). Consider refactoring.
                          Open

                          public class AnnotationConfiguration extends BaseConfiguration implements ConfigurationProperties {
                              private final FluentConfiguration configuration;
                          
                              private final Map<String, String> customProperties = new HashMap<>();
                          
                          

                            FluentWaitElementTest has 31 methods (exceeds 20 allowed). Consider refactoring.
                            Open

                            @RunWith(MockitoJUnitRunner.class)
                            public class FluentWaitElementTest {
                                @Mock
                                private FluentWait fluentControlWait;
                            
                            

                              ProxiesTest has 31 methods (exceeds 20 allowed). Consider refactoring.
                              Open

                              @RunWith(MockitoJUnitRunner.class)
                              public class ProxiesTest {
                              
                                  @Mock
                                  private WebDriver driver;

                                AnnotationConfigurationTest has 30 methods (exceeds 20 allowed). Consider refactoring.
                                Open

                                public class AnnotationConfigurationTest {
                                    private static AnnotationConfiguration configuration;
                                    private static AnnotationConfiguration defaultConfiguration;
                                    private static AnnotationConfiguration noConfiguration;
                                    private static AnnotationConfiguration desiredCapabilitiesConfiguration;

                                  FluentWebElementAssert has 29 methods (exceeds 20 allowed). Consider refactoring.
                                  Open

                                  public class FluentWebElementAssert extends AbstractFluentAssert<FluentWebElementAssert, FluentWebElement>
                                          implements ElementStateAssert, ElementAttributeAssert {
                                  
                                      public FluentWebElementAssert(FluentWebElement actual) {
                                          super(actual, FluentWebElementAssert.class);

                                    FluentListImplTest has 29 methods (exceeds 20 allowed). Consider refactoring.
                                    Open

                                    @RunWith(MockitoJUnitRunner.class)
                                    @SuppressWarnings({"PMD.TooManyMethods", "PMD.ExcessivePublicCount"})
                                    public class FluentListImplTest {
                                        @Mock
                                        private FluentWebElement element1;

                                      AbstractFluentDriverComponentInstantiator has 29 methods (exceeds 20 allowed). Consider refactoring.
                                      Open

                                      abstract class AbstractFluentDriverComponentInstantiator extends FluentControlImpl {
                                      
                                          protected AbstractFluentDriverComponentInstantiator(FluentControl adapter) {
                                              super(adapter);
                                          }

                                        EventAdapter has 29 methods (exceeds 20 allowed). Consider refactoring.
                                        Open

                                        class EventAdapter implements WebDriverEventListener {
                                        
                                            private final EventListener listener;
                                            private final ComponentInstantiator instantiator;
                                        
                                        
                                          Severity
                                          Category
                                          Status
                                          Source
                                          Language