From c738c9ed779b8cc61b9721175b7b081cabdec911 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Gonz=C3=A1lez?= Date: Mon, 18 Jul 2016 08:39:15 +0200 Subject: [PATCH] Code for deepening on expectations (#511) * Add new module for mocks comparison. * Add sources for testing. * Changes on testCase. * Enter some tests for mockito. * More tests for Mockito. * Even more tests. * Add the rest of the mocking libraries. * Javadoc on test. * Test bare bones for EasyMock. * Fist kind of test and setup. * Add tests using EasyMock with a change on LoginService. * Create LoginControllerTest.java * Test setup * [JMockit] No method called test. * [JMockit] Two methods called test. * [JMockit] One method called test. * [JMockit] Exception mock test * [JMockit] Mocked object to pass around test. * [JMockit] Custom matcher test. * [JMockit] Partial mocking test. * [JMockit] Fix with IDE. * Not stubs. Mocks. MOCKS!!! * Remove unnecesary import. * Use correct encoding. Was having problems with buildings. * Remove failing module. * Create new module mocks and move mock-comparisons there. * Add jmockit module. * Add model class. * Add collaborator class. * Add performer class. * Add performer test. * Fix * Add interface for tests. * Test for any. * Test for with. * Test for null. * Test for times. * Test for arg that. * Test for result and returns. * Test for delegate. --- .../jmockit/ExpectationsCollaborator.java | 16 ++ .../org/baeldung/mocks/jmockit/Model.java | 6 +- .../mocks/jmockit/ExpectationsTest.java | 157 ++++++++++++++++++ 3 files changed, 176 insertions(+), 3 deletions(-) create mode 100644 mocks/jmockit/src/main/java/org/baeldung/mocks/jmockit/ExpectationsCollaborator.java create mode 100644 mocks/jmockit/src/test/java/org/baeldung/mocks/jmockit/ExpectationsTest.java diff --git a/mocks/jmockit/src/main/java/org/baeldung/mocks/jmockit/ExpectationsCollaborator.java b/mocks/jmockit/src/main/java/org/baeldung/mocks/jmockit/ExpectationsCollaborator.java new file mode 100644 index 0000000000..510ce222c0 --- /dev/null +++ b/mocks/jmockit/src/main/java/org/baeldung/mocks/jmockit/ExpectationsCollaborator.java @@ -0,0 +1,16 @@ +package org.baeldung.mocks.jmockit; + +import java.util.List; + +public interface ExpectationsCollaborator { + void methodForAny(String s, int i, Boolean b, List l); + void methodForWith(String s, int i, Boolean b, List l); + void methodForNulls(String s, List l, List m); + void methodForTimes1(); + void methodForTimes2(); + void methodForTimes3(); + void methodForArgThat(Object o); + String methodReturnsString(); + int methodReturnsInt(); + Object methodForDelegate(int i); +} diff --git a/mocks/jmockit/src/main/java/org/baeldung/mocks/jmockit/Model.java b/mocks/jmockit/src/main/java/org/baeldung/mocks/jmockit/Model.java index 54249dcd1d..c3b63d11b4 100644 --- a/mocks/jmockit/src/main/java/org/baeldung/mocks/jmockit/Model.java +++ b/mocks/jmockit/src/main/java/org/baeldung/mocks/jmockit/Model.java @@ -1,7 +1,7 @@ package org.baeldung.mocks.jmockit; public class Model { - public String getInfo(){ - return "info"; - } + public String getInfo(){ + return "info"; + } } diff --git a/mocks/jmockit/src/test/java/org/baeldung/mocks/jmockit/ExpectationsTest.java b/mocks/jmockit/src/test/java/org/baeldung/mocks/jmockit/ExpectationsTest.java new file mode 100644 index 0000000000..5d0af157d1 --- /dev/null +++ b/mocks/jmockit/src/test/java/org/baeldung/mocks/jmockit/ExpectationsTest.java @@ -0,0 +1,157 @@ +package org.baeldung.mocks.jmockit; + +import static org.junit.Assert.*; + +import java.util.ArrayList; +import java.util.List; + +import org.hamcrest.BaseMatcher; +import org.hamcrest.Description; +import org.junit.Test; +import org.junit.runner.RunWith; + +import mockit.Delegate; +import mockit.Expectations; +import mockit.Mocked; +import mockit.StrictExpectations; +import mockit.integration.junit4.JMockit; + +@RunWith(JMockit.class) +@SuppressWarnings("unchecked") +public class ExpectationsTest { + + @Test + public void testForAny(@Mocked ExpectationsCollaborator mock) throws Exception { + new Expectations() { + { + mock.methodForAny(anyString, anyInt, anyBoolean, (List) any); + } + }; + mock.methodForAny("barfooxyz", 0, Boolean.FALSE, new ArrayList<>()); + } + + @Test + public void testForWith(@Mocked ExpectationsCollaborator mock) throws Exception { + new Expectations() { + { + mock.methodForWith(withSubstring("foo"), withNotEqual(1), withNotNull(), withInstanceOf(List.class)); + } + }; + mock.methodForWith("barfooxyz", 2, Boolean.TRUE, new ArrayList<>()); + } + + @Test + public void testWithNulls(@Mocked ExpectationsCollaborator mock) { + // more config + new Expectations() { + { + mock.methodForNulls(anyString, null, (List) withNull()); + } + }; + mock.methodForNulls("blablabla", new ArrayList(), null); + } + + @Test + public void testWithTimes(@Mocked ExpectationsCollaborator mock) { + // more config + new Expectations() { + { + // exactly 2 invocations to foo() are expected + mock.methodForTimes1(); + times = 2; + // we expect from 1 to 3 invocations to bar() + mock.methodForTimes2(); + minTimes = 1; + maxTimes = 3; + mock.methodForTimes3(); // "minTimes = 1" is implied + } + }; + mock.methodForTimes1(); + mock.methodForTimes1(); + mock.methodForTimes2(); + mock.methodForTimes2(); + mock.methodForTimes2(); + mock.methodForTimes3(); + } + + @Test + public void testCustomArgumentMatching(@Mocked ExpectationsCollaborator mock) { + new Expectations() { + { + mock.methodForArgThat(withArgThat(new BaseMatcher() { + @Override + public boolean matches(Object item) { + return item instanceof Model && "info".equals(((Model) item).getInfo()); + } + + @Override + public void describeTo(Description description) { + // NOOP + } + })); + } + }; + mock.methodForArgThat(new Model()); + } + + @Test + public void testResultAndReturns(@Mocked ExpectationsCollaborator mock) { + new StrictExpectations() { + { + // return "foo", an exception and lastly "bar" + mock.methodReturnsString(); + result = "foo"; + result = new Exception(); + result = "bar"; + // return 1, 2, 3 + mock.methodReturnsInt(); + result = new int[] { 1, 2, 3 }; + // return "foo" and "bar" + mock.methodReturnsString(); + returns("foo", "bar"); + // return only 1 + mock.methodReturnsInt(); + result = 1; + } + }; + assertEquals("Should return foo", "foo", mock.methodReturnsString()); + try { + mock.methodReturnsString(); + } catch (Exception e) { + // NOOP + } + assertEquals("Should return bar", "bar", mock.methodReturnsString()); + assertEquals("Should return 1", 1, mock.methodReturnsInt()); + assertEquals("Should return 2", 2, mock.methodReturnsInt()); + assertEquals("Should return 3", 3, mock.methodReturnsInt()); + assertEquals("Should return foo", "foo", mock.methodReturnsString()); + assertEquals("Should return bar", "bar", mock.methodReturnsString()); + assertEquals("Should return 1", 1, mock.methodReturnsInt()); + } + + @Test + public void testDelegate(@Mocked ExpectationsCollaborator mock) { + new StrictExpectations() { + { + // return "foo", an exception and lastly "bar" + mock.methodForDelegate(anyInt); + times = 2; + result = new Delegate() { + public int delegate(int i) throws Exception { + if (i < 3) { + return 5; + } else { + throw new Exception(); + } + } + }; + } + }; + assertEquals("Should return 5", 5, mock.methodForDelegate(1)); + try { + mock.methodForDelegate(3); + } catch (Exception e) { + // NOOP + } + } +}