TestMu Conference is Back! Future of Testing + AI LambdaTest G2 Announcement

How to use ProductionCode class of org.mockitousage.strictness package

Best Mockito code snippet using org.mockitousage.strictness.ProductionCode

Source:StrictJUnitRuleTest.java

...19import org.mockito.exceptions.misusing.UnnecessaryStubbingException;20import org.mockito.junit.MockitoJUnit;21import org.mockito.quality.Strictness;22import org.mockitousage.IMethods;23import org.mockitousage.strictness.ProductionCode;24import org.mockitoutil.SafeJUnitRule;25public class StrictJUnitRuleTest {26    @Rule27    public SafeJUnitRule rule =28            new SafeJUnitRule(MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS));29    @Mock IMethods mock;30    @Mock IMethods mock2;31    @Test32    public void ok_when_no_stubbings() throws Throwable {33        mock.simpleMethod();34        verify(mock).simpleMethod();35    }36    @Test37    public void ok_when_all_stubbings_used() throws Throwable {38        given(mock.simpleMethod(10)).willReturn("foo");39        mock.simpleMethod(10);40    }41    @Test42    public void ok_when_used_and_mismatched_argument() throws Throwable {43        given(mock.simpleMethod(10)).willReturn("foo");44        mock.simpleMethod(10);45        mock.simpleMethod(15);46    }47    @Test48    public void fails_when_unused_stubbings() throws Throwable {49        // expect50        rule.expectFailure(UnnecessaryStubbingException.class);51        // when52        given(mock.simpleMethod(10)).willReturn("foo");53        mock2.simpleMethod(10);54    }55    @Test56    public void test_failure_trumps_unused_stubbings() throws Throwable {57        // expect58        rule.expectFailure(AssertionError.class, "x");59        // when60        given(mock.simpleMethod(10)).willReturn("foo");61        mock.otherMethod();62        throw new AssertionError("x");63    }64    @Test65    public void why_do_return_syntax_is_useful() throws Throwable {66        // Trade-off of Mockito strictness documented in test67        // expect68        rule.expectFailure(PotentialStubbingProblem.class);69        // when70        when(mock.simpleMethod(10)).thenReturn("10");71        ProductionCode.simpleMethod(mock, 20);72    }73    @Test74    public void fails_fast_when_stubbing_invoked_with_different_argument() throws Throwable {75        // expect76        rule.expectFailure(77                new SafeJUnitRule.FailureAssert() {78                    public void doAssert(Throwable t) {79                        Assertions.assertThat(t).isInstanceOf(PotentialStubbingProblem.class);80                        assertEquals(81                                filterLineNo(82                                        "\n"83                                                + "Strict stubbing argument mismatch. Please check:\n"84                                                + " - this invocation of 'simpleMethod' method:\n"85                                                + "    mock.simpleMethod(15);\n"86                                                + "    -> at org.mockitousage.strictness.ProductionCode.simpleMethod(ProductionCode.java:0)\n"87                                                + " - has following stubbing(s) with different arguments:\n"88                                                + "    1. mock.simpleMethod(20);\n"89                                                + "      -> at org.mockitousage.junitrule.StrictJUnitRuleTest.fails_fast_when_stubbing_invoked_with_different_argument(StrictJUnitRuleTest.java:0)\n"90                                                + "    2. mock.simpleMethod(30);\n"91                                                + "      -> at org.mockitousage.junitrule.StrictJUnitRuleTest.fails_fast_when_stubbing_invoked_with_different_argument(StrictJUnitRuleTest.java:0)\n"92                                                + "Typically, stubbing argument mismatch indicates user mistake when writing tests.\n"93                                                + "Mockito fails early so that you can debug potential problem easily.\n"94                                                + "However, there are legit scenarios when this exception generates false negative signal:\n"95                                                + "  - stubbing the same method multiple times using 'given().will()' or 'when().then()' API\n"96                                                + "    Please use 'will().given()' or 'doReturn().when()' API for stubbing.\n"97                                                + "  - stubbed method is intentionally invoked with different arguments by code under test\n"98                                                + "    Please use default or 'silent' JUnit Rule (equivalent of Strictness.LENIENT).\n"99                                                + "For more information see javadoc for PotentialStubbingProblem class."),100                                filterLineNo(t.getMessage()));101                    }102                });103        // when stubbings in the test code:104        willReturn("10").given(mock).simpleMethod(10); // used105        willReturn("20").given(mock).simpleMethod(20); // unused106        willReturn("30").given(mock).simpleMethod(30); // unused107        // then108        mock.otherMethod(); // ok, different method109        mock.simpleMethod(10); // ok, stubbed with this argument110        // invocation in the code under test uses different argument and should fail immediately111        // this helps with debugging and is essential for Mockito strictness112        ProductionCode.simpleMethod(mock, 15);113    }114    @Test115    public void verify_no_more_interactions_ignores_stubs() throws Throwable {116        // when stubbing in test:117        given(mock.simpleMethod(10)).willReturn("foo");118        // and code under test does:119        mock.simpleMethod(10); // implicitly verifies the stubbing120        mock.otherMethod();121        // and in test we:122        verify(mock).otherMethod();123        verifyNoMoreInteractions(mock);124    }125    @Test126    public void unused_stubs_with_multiple_mocks() throws Throwable {...

Source:StrictStubbingTest.java

...12import org.mockito.exceptions.misusing.UnnecessaryStubbingException;13import org.mockito.exceptions.verification.NoInteractionsWanted;14import org.mockito.quality.Strictness;15import org.mockitousage.IMethods;16import org.mockitousage.strictness.ProductionCode;17import org.mockitoutil.ThrowableAssert;18public class StrictStubbingTest {19    @Mock20    IMethods mock;21    MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();22    @Test23    public void no_interactions() throws Throwable {24        // expect no exception25        mockito.finishMocking();26    }27    @Test28    public void few_interactions() throws Throwable {29        mock.simpleMethod(100);30        mock.otherMethod();31    }32    @Test33    public void few_verified_interactions() throws Throwable {34        // when35        mock.simpleMethod(100);36        mock.otherMethod();37        // and38        Mockito.verify(mock).simpleMethod(100);39        Mockito.verify(mock).otherMethod();40        Mockito.verifyNoMoreInteractions(mock);41    }42    @Test43    public void stubbed_method_is_implicitly_verified() throws Throwable {44        // when45        BDDMockito.given(mock.simpleMethod(100)).willReturn("100");46        mock.simpleMethod(100);47        // no exceptions:48        Mockito.verifyNoMoreInteractions(mock);49    }50    @Test51    public void unused_stubbed_is_not_implicitly_verified() throws Throwable {52        // when53        BDDMockito.given(mock.simpleMethod(100)).willReturn("100");54        mock.simpleMethod(100);// <- implicitly verified55        mock.simpleMethod(200);// <- unverified56        // expect57        ThrowableAssert.assertThat(new Runnable() {58            public void run() {59                Mockito.verifyNoMoreInteractions(mock);60            }61        }).throwsException(NoInteractionsWanted.class);62    }63    @Test64    public void stubbing_argument_mismatch() throws Throwable {65        // when66        BDDMockito.given(mock.simpleMethod(100)).willReturn("100");67        // stubbing argument mismatch is detected68        ThrowableAssert.assertThat(new Runnable() {69            public void run() {70                ProductionCode.simpleMethod(mock, 200);71            }72        }).throwsException(PotentialStubbingProblem.class);73    }74    @Test75    public void unused_stubbing() throws Throwable {76        // when77        BDDMockito.given(mock.simpleMethod(100)).willReturn("100");78        // unused stubbing is reported79        ThrowableAssert.assertThat(new Runnable() {80            public void run() {81                mockito.finishMocking();82            }83        }).throwsException(UnnecessaryStubbingException.class);84    }...

Source:StrictnessWhenRuleStrictnessIsUpdatedTest.java

...28        when(mock.simpleMethod(1)).thenReturn("1");29        assertThatThrownBy(30                        new ThrowableAssert.ThrowingCallable() {31                            public void call() {32                                ProductionCode.simpleMethod(mock, 2);33                            }34                        })35                .isInstanceOf(PotentialStubbingProblem.class);36        // but the new mock is lenient, even though the rule is not:37        final IMethods lenientMock = mock(IMethods.class, withSettings().lenient());38        when(lenientMock.simpleMethod(1)).thenReturn("1");39        lenientMock.simpleMethod(100);40    }41    @Test42    public void strictness_per_stubbing() {43        // when44        rule.strictness(Strictness.STRICT_STUBS);45        // then previous mock is strict:46        when(mock.simpleMethod(1)).thenReturn("1");47        assertThatThrownBy(48                        new ThrowableAssert.ThrowingCallable() {49                            public void call() {50                                ProductionCode.simpleMethod(mock, 2);51                            }52                        })53                .isInstanceOf(PotentialStubbingProblem.class);54        // but the new mock is lenient, even though the rule is not:55        lenient().when(mock.simpleMethod(1)).thenReturn("1");56        mock.simpleMethod(100);57    }58}...

Source:LenientMockAnnotationTest.java

...23    public void mock_is_lenient() {24        when(lenientMock.simpleMethod("1")).thenReturn("1");25        when(regularMock.simpleMethod("2")).thenReturn("2");26        // then lenient mock does not throw:27        ProductionCode.simpleMethod(lenientMock, "3");28        // but regular mock throws:29        Assertions.assertThatThrownBy(30                        new ThrowableAssert.ThrowingCallable() {31                            public void call() {32                                ProductionCode.simpleMethod(regularMock, "4");33                            }34                        })35                .isInstanceOf(PotentialStubbingProblem.class);36    }37}...

ProductionCode

Using AI Code Generation

1package org.mockitousage.strictness;2import static org.mockito.Mockito.*;3import org.junit.Test;4import org.junit.runner.RunWith;5import org.mockito.Mock;6import org.mockito.runners.MockitoJUnitRunner;7@RunWith(MockitoJUnitRunner.class)8public class ProductionCodeTest {9ProductionCode productionCode;10public void testProductionCode() {11}12}131. -> at org.mockitousage.strictness.ProductionCodeTest.testProductionCode(ProductionCodeTest.java:17)142. -> at org.mockitousage.strictness.ProductionCodeTest.testProductionCode(ProductionCodeTest.java:17)15    when(mock.isOk()).thenReturn(true);16    when(mock.isOk()).thenThrow(exception);17    doThrow(exception).when(mock).someVoidMethod();18    doAnswer(...).when(mock).someMethod();19    verify(mock).someMethod();20    verify(mock, times(10)).someMethod();21    verify(mock, atLeastOnce()).someMethod();22    verifyNoMoreInteractions(mock);23    InOrder inOrder = inOrder(mock1, mock2);24    inOrder.verify(mock1).someMethod();25    inOrder.verify(mock2).someOtherMethod();26    verifyZeroInteractions(mock1, mock2);27	at org.mockito.internal.verification.StrictlyNumberOfInvocations.verify(StrictlyNumberOfInvocations.java:44)28	at org.mockito.internal.verification.StrictlyNumberOfInvocations.verify(StrictlyNumberOfInvocations.java:26)29	at org.mockito.internal.verification.StrictlyOrderingContext.verify(StrictlyOrderingContext.java:41)30	at org.mockito.internal.verification.StrictlyOrderingContext.verify(StrictlyOrderingContext.java:28)31	at org.mockito.internal.StrictlyOrdered.verify(StrictlyOrdered.java:36)32	at org.mockito.internal.StrictlyOrdered.verify(StrictlyOrdered.java:30)33	at org.mockitousage.strictness.ProductionCodeTest.testProductionCode(ProductionCodeTest.java:17)

ProductionCode

Using AI Code Generation

1package org.mockitousage.strictness;2import org.junit.Test;3import org.mockito.Mock;4import org.mockito.Mockito;5import org.mockito.exceptions.misusing.UnfinishedVerificationException;6import org.mockitousage.IMethods;7import org.mockitoutil.TestBase;8public class StrictnessTest extends TestBase {9    private IMethods mock;10    public void shouldNotAllowUnverifiedInteractions() {11        mock.simpleMethod(1);12        try {13            Mockito.validateMockitoUsage();14            fail();15        } catch (UnfinishedVerificationException e) {16            assertContains(e.getMessage(), "1. Unfinished verification");17        }18    }19}

ProductionCode

Using AI Code Generation

1package org.mockitousage.strictness;2import org.junit.Test;3import org.mockito.Mock;4import org.mockito.Mockito;5import org.mockito.exceptions.misusing.PotentialStubbingProblem;6import org.mockito.junit.MockitoJUnitRunner;7import org.mockito.junit.StrictJUnit;8import org.mockito.junit.VerificationCollector;9import org.mockito.junit.Verifier;10import org.mockito.quality.Strictness;11import org.mockitousage.IMethods;12import org.mockitoutil.TestBase;13import static org.junit.Assert.assertEquals;14import static org.junit.Assert.fail;15import static org.mockito.Mockito.verify;16public class VerificationInOrderStrictRunnerTest extends TestBase {17    public void shouldFailOnUnverifiedStub() {18        ProductionCode productionCode = new ProductionCode();19        try {20            productionCode.doSomething();21            fail();22        } catch (PotentialStubbingProblem e) {23            assertEquals("Strict stubbing argument mismatch. Please check:" +24- this invocation of 'doSomething()' method:" +25    productionCode.doSomething();",26                    e.getMessage());27        }28    }29    public void shouldFailOnUnverifiedStubWithVerificationCollector() {30        ProductionCode productionCode = new ProductionCode();31        try {32            productionCode.doSomething();33            fail();34        } catch (PotentialStubbingProblem e) {35            assertEquals("Strict stubbing argument mismatch. Please check:" +36- this invocation of 'doSomething()' method:" +37    productionCode.doSomething();",38                    e.getMessage());39        }40    }41    public void shouldFailOnUnverifiedStubWithVerifier() {42        ProductionCode productionCode = new ProductionCode();43        try {44            productionCode.doSomething();45            fail();46        } catch (PotentialStubbingProblem e) {47            assertEquals("Strict stubbing argument mismatch. Please check:" +48- this invocation of 'doSomething()' method:" +49    productionCode.doSomething();",50                    e.getMessage());51        }52    }53    public void shouldFailOnUnverifiedStubWithMockitoJUnitRunner() {54        ProductionCode productionCode = new ProductionCode();55        try {56            productionCode.doSomething();57            fail();58        } catch (PotentialStubbingProblem e)

ProductionCode

Using AI Code Generation

1package org.mockitousage.strictness;2import static org.mockito.Mockito.*;3import java.util.List;4import org.junit.Test;5import org.mockito.Mock;6import org.mockito.Mockito;7import org.mockito.exceptions.verification.NoInteractionsWanted;8import org.mockito.exceptions.verification.WantedButNotInvoked;9import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;10import org.mockito.internal.Strictness;11import org.mockitousage.IMethods;12import org.mockitoutil.TestBase;13public class StrictnessTest extends TestBase {14    @Mock private List mock;15    public void shouldNotAllowUnstubbedInvocations() {16        try {17            mock.clear();18            fail();19        } catch (WantedButNotInvoked e) {}20    }21    public void shouldAllowUnstubbedInvocationsWhenUsingLenient() {22        Mockito.lenient().when(mock.clear()).thenReturn(null);23        mock.clear();24    }25    public void shouldAllowUnstubbedInvocationsWhenUsingStrict() {26        Mockito.withSettings().strictness(Strictness.STRICT_STUBS).create(List.class);27        mock.clear();28    }29    public void shouldAllowUnstubbedInvocationsWhenUsingStrictForPartialMocking() {30        Mockito.withSettings().strictness(Strictness.STRICT_STUBS).create(List.class);31        mock.clear();32    }33    public void shouldAllowUnstubbedInvocationsWhenUsingStrictForPartialMockingAndUseRealMethods() {34        Mockito.withSettings().strictness(Strictness.STRICT_STUBS).useConstructor().create(List.class);35        mock.clear();36    }37    public void shouldAllowUnstubbedInvocationsWhenUsingStrictForPartialMockingAndUseRealMethodsAndSpies() {38        Mockito.withSettings().strictness(Strictness.STRICT_STUBS).useConstructor().create(List.class);39        mock.clear();40    }41    public void shouldAllowUnstubbedInvocationsWhenUsingStrictForPartialMockingAndUseRealMethodsAndSpiesAndSpies() {42        Mockito.withSettings().strictness(Strictness.STRICT_STUBS).useConstructor().create(List.class);43        mock.clear();44    }45    public void shouldAllowUnstubbedInvocationsWhenUsingStrictForPartialMockingAndUseRealMethodsAndSpiesAndSpiesAndSpies() {

ProductionCode

Using AI Code Generation

1import org.mockitousage.strictness.ProductionCode;2import org.junit.Test;3import org.junit.runner.RunWith;4import org.mockito.runners.MockitoJUnitRunner;5import static org.mockito.Mockito.*;6@RunWith(MockitoJUnitRunner.class)7public class ExampleTest {8    public void test() {9        ProductionCode productionCode = mock(ProductionCode.class);10        productionCode.doSomething("something");11        verify(productionCode).doSomething("something");12    }13}14import org.mockitousage.strictness.ProductionCode;15import org.junit.Test;16import org.junit.runner.RunWith;17import org.mockito.runners.MockitoJUnitRunner;18import static org.mockito.Mockito.*;19@RunWith(MockitoJUnitRunner.class)20public class ExampleTest {21    public void test() {22        ProductionCode productionCode = mock(ProductionCode.class);23        productionCode.doSomething("something");24        verify(productionCode).doSomething("something");25    }26}27import org.mockitousage.strictness.ProductionCode;28import org.junit.Test;29import org.junit.runner.RunWith;30import org.mockito.runners.MockitoJUnitRunner;31import static org.mockito.Mockito.*;32@RunWith(MockitoJUnitRunner.class)33public class ExampleTest {34    public void test() {35        ProductionCode productionCode = mock(ProductionCode.class);36        productionCode.doSomething("something");37        verify(productionCode).doSomething("something");38    }39}40import org.mockitousage.strictness.ProductionCode;41import org.junit.Test;42import org.junit.runner.RunWith;43import org.mockito.runners.MockitoJUnitRunner;44import static org.mockito.Mockito.*;45@RunWith(MockitoJUnitRunner.class)46public class ExampleTest {47    public void test() {48        ProductionCode productionCode = mock(ProductionCode.class);49        productionCode.doSomething("something");50        verify(productionCode).doSomething("something");51    }52}53import org.mockitousage.strictness.ProductionCode;54import org.junit.Test;55import org.junit.runner.RunWith;56import org.mockito.runners.MockitoJUnitRunner;57import static org.mockito.Mockito.*;58@RunWith(Mock

ProductionCode

Using AI Code Generation

1package org.mockitousage.strictness;2import static org.mockito.Mockito.*;3import static org.mockito.BDDMockito.*;4import static org.junit.Assert.*;5import static org.junit.Assert.fail;6import org.junit.*;7import org.mockito.*;8import org.mockito.exceptions.base.MockitoException;9import org.mockito.exceptions.misusing.UnfinishedVerificationException;10import org.mockito.exceptions.verification.NoInteractionsWanted;11import org.mockito.exceptions.verification.WantedButNotInvoked;12import org.mockitousage.IMethods;13import org.mockitoutil.TestBase;14public class StrictStubsTest extends TestBase {15    private IMethods mock;16    public void setup() {17        mock = mock(IMethods.class, withSettings().strictness(Strictness.STRICT_STUBS));18    }19    public void shouldNotAllowUnstubbedMethodToBeCalled() {20        try {21            mock.simpleMethod(100);22            fail();23        } catch (WantedButNotInvoked e) {24            assertEquals("IMethods.simpleMethod(100)", e.getMessage());25        }26    }27    public void shouldAllowStubbedMethodToBeCalled() {28        when(mock.simpleMethod(100)).thenReturn("100");29        assertEquals("100", mock.simpleMethod(100));30    }31    public void shouldAllowStubbedVoidMethodToBeCalled() {32        doNothing().when(mock).voidMethod();33        mock.voidMethod();34    }35    public void shouldAllowStubbedMethodToBeCalledWithAnyArgs() {36        when(mock.simpleMethod(anyInt())).thenReturn("100");37        assertEquals("100", mock.simpleMethod(100));38    }39    public void shouldAllowStubbedMethodToBeCalledWithAnyArgsAndMatchers() {40        when(mock.simpleMethod(anyInt(), anyString())).thenReturn("100");41        assertEquals("100", mock.simpleMethod(100, "foo"));42    }43    public void shouldAllowStubbedMethodToBeCalledWithAnyArgsAndMatchers2() {44        when(mock.simpleMethod(anyInt(), startsWith("foo"))).thenReturn("100");45        assertEquals("100", mock.simpleMethod(100, "foobar"));46    }47    public void shouldAllowStubbedMethodToBeCalledWithAnyArgsAndMatchers3() {48        when(mock.simpleMethod(anyInt(), startsWith("foo"))).thenReturn("100");49        assertEquals("100

ProductionCode

Using AI Code Generation

1package org.mockitousage.strictness;2import org.junit.*;3import org.mockito.*;4import org.mockito.exceptions.base.*;5import org.mockito.quality.Strictness;6import org.mockitousage.IMethods;7import org.mockitoutil.TestBase;8import static org.junit.Assert.*;9import static org.mockito.Mockito.*;10public class ProductionCodeTest extends TestBase {11    private IMethods mock;12    public void setup() {13        mock = mock(IMethods.class, withSettings().strictness(Strictness.STRICT_STUBS));14    }15    public void should_allow_stubbing() {16        when(mock.simpleMethod()).thenReturn("foo");17    }18    @Test(expected = StrictStubbingException.class)19    public void should_not_allow_unstubbed_invocation() {20        mock.simpleMethod();21    }22    public void should_allow_stubbing_with_void_method() {23        doNothing().when(mock).voidMethod();24    }25    @Test(expected = StrictStubbingException.class)26    public void should_not_allow_unstubbed_void_method_invocation() {27        mock.voidMethod();28    }29    public void should_allow_stubbing_with_void_method_using_doAnswer() {30        doAnswer(new ThrowsException("foo")).when(mock).voidMethod();31    }32    public void should_allow_stubbing_with_void_method_using_doThrow() {33        doThrow(new RuntimeException("foo")).when(mock).voidMethod();34    }35    public void should_allow_stubbing_with_void_method_using_doReturn() {36        doReturn("foo").when(mock).simpleMethod();37    }38    public void should_allow_stubbing_with_void_method_using_doNothing() {39        doNothing().when(mock).voidMethod();40    }41    public void should_allow_stubbing_with_void_method_using_doCallRealMethod() {42        doCallRealMethod().when(mock).voidMethod();43    }44    public void should_allow_stubbing_with_void_method_using_doAnswer() {45        doAnswer(new ThrowsException("foo")).when(mock).voidMethod();46    }47    public void should_allow_stubbing_with_void_method_using_doThrow() {48        doThrow(new RuntimeException("foo")).when(mock).voidMethod();49    }50    public void should_allow_stubbing_with_void_method_using_doReturn() {

ProductionCode

Using AI Code Generation

1package org.mockitousage.strictness;2import org.junit.Test;3import org.junit.runner.RunWith;4import org.mockito.Mock;5import org.mockito.exceptions.misusing.MissingMethodInvocationException;6import org.mockito.runners.MockitoJUnitRunner;7@RunWith(MockitoJUnitRunner.StrictStubs.class)8public class StrictStubsTest {9    private ProductionCode productionCode;10    @Test(expected = MissingMethodInvocationException.class)11    public void shouldFailWhenMethodIsNotStubbed() {12        productionCode.simpleMethod();13    }14}15package org.mockitousage.strictness;16public class ProductionCode {17    public void simpleMethod() {18    }19}20package org.mockitousage.strictness;21public class ProductionCode {22    public void simpleMethod() {23    }24}25package org.mockitousage.strictness;26public class ProductionCode {27    public void simpleMethod() {28    }29}30package org.mockitousage.strictness;31public class ProductionCode {32    public void simpleMethod() {33    }34}35package org.mockitousage.strictness;36public class ProductionCode {37    public void simpleMethod() {38    }39}40package org.mockitousage.strictness;41public class ProductionCode {42    public void simpleMethod() {43    }44}45package org.mockitousage.strictness;46public class ProductionCode {47    public void simpleMethod() {48    }49}50package org.mockitousage.strictness;51public class ProductionCode {52    public void simpleMethod() {53    }54}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.