diff --git a/CHANGELOG.md b/CHANGELOG.md index 043294c..df6c1d3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,12 @@ and this project adheres to [Semantic Versioning](http://semver.org/). ## [Unreleased] +## [9.6.1] - 2025-05-16 + +### Fixed: +- We fixed an issue that caused unit test microflows with auto-committed objects to fail with an unhandled exception (#244962, #246277, #246384). +- We fixed reporting issue for ThrowAssetionFailed action. Now a failed unnamed assertion step will be reported. + ## [9.6.0] - 2025-03-20 ### Added: diff --git a/dist/UnitTesting_9.6.1.mpk b/dist/UnitTesting_9.6.1.mpk new file mode 100644 index 0000000..e4545e8 Binary files /dev/null and b/dist/UnitTesting_9.6.1.mpk differ diff --git a/pom.xml b/pom.xml index 9d868e0..657b334 100644 --- a/pom.xml +++ b/pom.xml @@ -6,7 +6,7 @@ com.mendix.UnitTesting UnitTesting - 9.6.0 + 9.6.1 diff --git a/src/UnitTesting.mpr b/src/UnitTesting.mpr index 681817d..c8f744d 100644 Binary files a/src/UnitTesting.mpr and b/src/UnitTesting.mpr differ diff --git a/src/javasource/testjavaimplementation/TestExecutionContextTest.java b/src/javasource/testjavaimplementation/TestExecutionContextTest.java index a777de2..ed1e747 100644 --- a/src/javasource/testjavaimplementation/TestExecutionContextTest.java +++ b/src/javasource/testjavaimplementation/TestExecutionContextTest.java @@ -1,55 +1,64 @@ package testjavaimplementation; import com.mendix.core.Core; -import com.mendix.systemwideinterfaces.core.IContext; import org.junit.After; import org.junit.Before; import org.junit.Test; import unittesting.TestExecutionContext; +import unittesting.activities.AssertActivity; import static org.junit.Assert.*; public class TestExecutionContextTest { - private final IContext context = Core.createSystemContext(); + private static final String FAILURE_MESSAGE = "This is a failure message"; private TestExecutionContext testExecutionContext; @Before public void setup() { - this.testExecutionContext = new TestExecutionContext(context, "ExampleMicroflow"); + this.testExecutionContext = new TestExecutionContext(); } @After public void tearDown() { - this.testExecutionContext.delete(); this.testExecutionContext = null; } - @Test - public void testExecutionContextShouldInitializeUnitTestContext() { - assertNotNull(this.testExecutionContext.getUnitTestContext()); - } - @Test public void hasFailedAssertionShouldBeFalseByDefault() { - assertFalse(this.testExecutionContext.hasFailedAssertion(context)); + assertFalse(this.testExecutionContext.hasFailedAssertion()); } @Test public void hasFailedAssertionShouldBeFalseWhenAllAssertionsPassed() { - this.testExecutionContext.collectAssertion(context, "Passed 1", true, null); - this.testExecutionContext.collectAssertion(context, "Passed 2", true, null); + this.testExecutionContext.collectAssertion("Passed 1", true, null); + this.testExecutionContext.collectAssertion("Passed 2", true, null); - assertFalse(this.testExecutionContext.hasFailedAssertion(context)); + assertFalse(this.testExecutionContext.hasFailedAssertion()); } @Test public void hasFailedAssertionShouldBeTrueWhenCollectingFailedAssertion() { - this.testExecutionContext.collectAssertion(context, "Passed", true, null); - this.testExecutionContext.collectAssertion(context, "Failed", false, null); + this.testExecutionContext.collectAssertion("Passed", true, null); + this.testExecutionContext.collectAssertion("Failed", false, null); + + assertTrue(this.testExecutionContext.hasFailedAssertion()); + } + + @Test + public void assertActivityShouldContainFailureMessageWhenCollectingFailedAssertion() { + AssertActivity assertion = this.testExecutionContext.collectAssertion("Failed", false, FAILURE_MESSAGE); + + assertEquals(FAILURE_MESSAGE, assertion.getMessage()); + } - assertTrue(this.testExecutionContext.hasFailedAssertion(context)); + @Test + public void assertActivityShouldNotContainFailureMessageWhenCollectingPassedAssertion() { + AssertActivity assertion = this.testExecutionContext.collectAssertion("Passed", true, FAILURE_MESSAGE); + + assertNull(assertion.getMessage()); } + @Test public void getLastStepShouldBeNullByDefault() { assertNull(this.testExecutionContext.getLastStep()); @@ -65,67 +74,67 @@ public void getLastStepShouldReturnLastCollectedStep() { @Test public void getFailureReasonsShouldBeNullByDefault() { - assertEquals(0, this.testExecutionContext.getFailureReasons(context).size()); + assertEquals(0, this.testExecutionContext.getFailureReasons().size()); } @Test public void getFailureReasonsShouldBeNullIfTestPassed() { this.testExecutionContext.collectStart(true, null); - this.testExecutionContext.collectAssertion(context, "Passed 1", true, null); - this.testExecutionContext.collectAssertion(context, "Passed 2", true, null); + this.testExecutionContext.collectAssertion("Passed 1", true, null); + this.testExecutionContext.collectAssertion("Passed 2", true, null); this.testExecutionContext.collectEnd(true, null); - assertEquals(0, this.testExecutionContext.getFailureReasons(context).size()); + assertEquals(0, this.testExecutionContext.getFailureReasons().size()); } @Test public void getFailureReasonsShouldIncludeFailedStart() { this.testExecutionContext.collectStart(false, "Start failed"); - assertEquals(1, this.testExecutionContext.getFailureReasons(context).size()); + assertEquals(1, this.testExecutionContext.getFailureReasons().size()); } @Test public void getFailureReasonsShouldIncludeFailedEnd() { this.testExecutionContext.collectEnd(false, "End failed"); - assertEquals(1, this.testExecutionContext.getFailureReasons(context).size()); + assertEquals(1, this.testExecutionContext.getFailureReasons().size()); } @Test public void getFailureReasonsShouldIncludeFailedAssertion() { - this.testExecutionContext.collectAssertion(context, "Passed", true, null); - this.testExecutionContext.collectAssertion(context, "Failed 1", false, null); - this.testExecutionContext.collectAssertion(context, "Failed 2", false, null); + this.testExecutionContext.collectAssertion("Passed", true, null); + this.testExecutionContext.collectAssertion("Failed 1", false, null); + this.testExecutionContext.collectAssertion("Failed 2", false, null); - assertEquals(1, this.testExecutionContext.getFailureReasons(context).size()); + assertEquals(1, this.testExecutionContext.getFailureReasons().size()); } @Test public void getFailureReasonsShouldIncludeUncaughtException() { this.testExecutionContext.collectException(new Exception("Example Exception")); - assertEquals(1, this.testExecutionContext.getFailureReasons(context).size()); + assertEquals(1, this.testExecutionContext.getFailureReasons().size()); } @Test public void getFailureReasonsShouldIncludeAllUniqueFailureReasons() { this.testExecutionContext.collectStart(false, "Start failed"); - this.testExecutionContext.collectAssertion(context, "Failed 1", false, null); - this.testExecutionContext.collectAssertion(context, "Failed 2", false, null); + this.testExecutionContext.collectAssertion("Failed 1", false, null); + this.testExecutionContext.collectAssertion("Failed 2", false, null); this.testExecutionContext.collectException(new Exception("Test Exception")); this.testExecutionContext.collectEnd(false, "End failed"); - assertEquals(4, this.testExecutionContext.getFailureReasons(context).size()); + assertEquals(4, this.testExecutionContext.getFailureReasons().size()); } @Test public void createTestActivitiesShouldContainAllCollectedTestActivities() { this.testExecutionContext.collectStart(true, "Started test"); - this.testExecutionContext.collectAssertion(context, "Passed", true, null); - this.testExecutionContext.collectAssertion(context, "Failed 1", false, null); - this.testExecutionContext.collectAssertion(context, "Failed 2", false, null); + this.testExecutionContext.collectAssertion("Passed", true, null); + this.testExecutionContext.collectAssertion("Failed 1", false, null); + this.testExecutionContext.collectAssertion("Failed 2", false, null); this.testExecutionContext.collectStep("Step 1"); this.testExecutionContext.collectStep("Step 2"); @@ -134,6 +143,6 @@ public void createTestActivitiesShouldContainAllCollectedTestActivities() { this.testExecutionContext.collectEnd(true, "Test ended successfully"); - assertEquals(8, this.testExecutionContext.createTestActivities(context, null).size()); + assertEquals(8, this.testExecutionContext.createTestActivities(Core.createSystemContext(), null).size()); } } diff --git a/src/javasource/unittesting/TestExecutionContext.java b/src/javasource/unittesting/TestExecutionContext.java index f742324..ecaa980 100644 --- a/src/javasource/unittesting/TestExecutionContext.java +++ b/src/javasource/unittesting/TestExecutionContext.java @@ -11,6 +11,7 @@ import com.mendix.systemwideinterfaces.core.IContext; import com.mendix.systemwideinterfaces.core.IMendixObject; +import unittesting.activities.AssertActivity; import unittesting.activities.StartEndExecutionActivity; import unittesting.activities.StepExecutionActivity; import unittesting.activities.ExceptionExecutionActivity; @@ -18,9 +19,10 @@ import unittesting.proxies.*; public class TestExecutionContext { - private final UnitTestContext unitTestContext; + private final ArrayList assertions = new ArrayList<>(); private final ArrayList steps = new ArrayList<>(); + private UnitTestContext unitTestContext; private StartEndExecutionActivity startActivity; private StartEndExecutionActivity endActivity; private ExceptionExecutionActivity exceptionActivity; @@ -28,26 +30,14 @@ public class TestExecutionContext { private static final ILogNode LOG = ConfigurationManager.LOG; - public TestExecutionContext(IContext context, String mf) { - UnitTestContext testContext = new UnitTestContext(context); - testContext.setTestName(mf); - - LOG.trace("Created unit test context for " + mf); - this.unitTestContext = testContext; + public void setUnitTestContext(UnitTestContext unitTestContext) { + this.unitTestContext = unitTestContext; } public UnitTestContext getUnitTestContext() { return this.unitTestContext; } - public void delete() { - if (this.unitTestContext == null) - return; - - this.unitTestContext.delete(); - LOG.trace("Deleted unit test context"); - } - public void collectStart(boolean result, String message) { this.startActivity = new StartEndExecutionActivity(getNextSequence(), result, message); } @@ -60,17 +50,9 @@ public void collectException(Exception exception) { this.exceptionActivity = new ExceptionExecutionActivity(getNextSequence(), exception); } - public Assertion collectAssertion(IContext context, String name, boolean result, String failureMessage) { - ENUM_UnitTestResult testResult = result ? ENUM_UnitTestResult._3_Success : ENUM_UnitTestResult._2_Failed; - - Assertion assertion = new Assertion(context); - assertion.setAssertion_UnitTestContext(this.unitTestContext); - assertion.setSequence(getNextSequence()); - assertion.setName(name); - assertion.setResult(testResult); - - if (testResult.equals(ENUM_UnitTestResult._2_Failed)) - assertion.setMessage(failureMessage); + public AssertActivity collectAssertion(String name, boolean result, String failureMessage) { + AssertActivity assertion = new AssertActivity(getNextSequence(), name, result, failureMessage); + this.assertions.add(assertion); return assertion; } @@ -84,24 +66,17 @@ public StepExecutionActivity getLastStep() { return !this.steps.isEmpty() ? this.steps.get(this.steps.size() - 1) : null; } - public boolean hasFailedAssertion(IContext context) { - List assertionList = Core.retrieveByPath(context, this.unitTestContext.getMendixObject(), - Assertion.MemberNames.Assertion_UnitTestContext.toString()); - - return assertionList.stream().anyMatch(obj -> isFailedAssertion(context, obj)); + public boolean hasFailedAssertion() { + return this.assertions.stream().anyMatch(AssertActivity::isFailed); } - private boolean isFailedAssertion(IContext context, IMendixObject object) { - return ENUM_UnitTestResult._2_Failed.equals(Assertion.initialize(context, object).getResult()); - } - - public ArrayList getFailureReasons(IContext context) { + public ArrayList getFailureReasons() { ArrayList failures = new ArrayList<>(); if (this.startActivity != null && !this.startActivity.getResult()) failures.add("Failed to start test"); - if (this.hasFailedAssertion(context)) + if (this.hasFailedAssertion()) failures.add("One or more assertions failed"); if (this.endActivity != null && !this.endActivity.getResult()) @@ -113,8 +88,8 @@ public ArrayList getFailureReasons(IContext context) { return failures; } - public String getResultSummary(IContext context) { - ArrayList failureReasons = this.getFailureReasons(context); + public String getResultSummary() { + ArrayList failureReasons = this.getFailureReasons(); if (failureReasons.isEmpty()) { return "Microflow completed successfully"; @@ -130,49 +105,51 @@ public String getResultSummary(IContext context) { } } - public void persistTestActivities(IContext context, UnitTest test) { - List activities = this.createTestActivities(context, test); - Core.commit(Core.createSystemContext(), activities); + public void persistTestActivities(UnitTest test) { + IContext systemContext = Core.createSystemContext(); + systemContext.startTransaction(); + + List activities = this.createTestActivities(systemContext, test); + Core.commit(systemContext, activities); + + systemContext.endTransaction(); } public List createTestActivities(IContext context, UnitTest test) { List activities = new ArrayList<>(); if (this.startActivity != null) - activities.add(createStartActivity(test)); + activities.add(createStartActivity(context, test)); activities.addAll(createAssertionActivities(context, test)); - activities.addAll(createStepActivities(test)); + activities.addAll(createStepActivities(context, test)); if (this.endActivity != null) - activities.add(createEndActivity(test)); + activities.add(createEndActivity(context, test)); if (this.exceptionActivity != null) - activities.add(createExceptionActivity(test)); + activities.add(createExceptionActivity(context, test)); return activities; } private List createAssertionActivities(IContext context, UnitTest test) { - List assertionList = Core.retrieveByPath(context, this.unitTestContext.getMendixObject(), - Assertion.MemberNames.Assertion_UnitTestContext.toString()); - - return assertionList.stream() - .map(assertion -> createAssertionActivity(test, assertion)) + return this.assertions.stream() + .map(assertion -> createAssertionActivity(context, test, assertion)) .collect(Collectors.toList()); } - private List createStepActivities(UnitTest test) { + private List createStepActivities(IContext context, UnitTest test) { return this.steps.stream() - .map(step -> createStepActivity(test, step)) + .map(step -> createStepActivity(context, test, step)) .collect(Collectors.toList()); } - private IMendixObject createStartActivity(UnitTest test) { + private IMendixObject createStartActivity(IContext context, UnitTest test) { if (this.startActivity == null) throw new IllegalStateException("No start activity collected"); - StartActivity startActivity = new StartActivity(Core.createSystemContext()); + StartActivity startActivity = new StartActivity(context); startActivity.setTestActivity_UnitTest(test); startActivity.setSequence(this.startActivity.getSequence()); startActivity.setResult(this.startActivity.getResultEnum()); @@ -181,11 +158,11 @@ private IMendixObject createStartActivity(UnitTest test) { return startActivity.getMendixObject(); } - private IMendixObject createEndActivity(UnitTest test) { + private IMendixObject createEndActivity(IContext context, UnitTest test) { if (this.endActivity == null) throw new IllegalStateException("No end activity collected"); - EndActivity endActivity = new EndActivity(Core.createSystemContext()); + EndActivity endActivity = new EndActivity(context); endActivity.setTestActivity_UnitTest(test); endActivity.setSequence(this.endActivity.getSequence()); endActivity.setResult(this.endActivity.getResultEnum()); @@ -194,14 +171,14 @@ private IMendixObject createEndActivity(UnitTest test) { return endActivity.getMendixObject(); } - private IMendixObject createExceptionActivity(UnitTest test) { + private IMendixObject createExceptionActivity(IContext context, UnitTest test) { if (this.exceptionActivity == null) throw new IllegalStateException("No exception collected"); Exception exception = this.exceptionActivity.getException(); Throwable cause = ExceptionUtils.getRootCause(exception); - ExceptionActivity exceptionActivity = new ExceptionActivity(Core.createSystemContext()); + ExceptionActivity exceptionActivity = new ExceptionActivity(context); exceptionActivity.setTestActivity_UnitTest(test); exceptionActivity.setSequence(this.exceptionActivity.getSequence()); exceptionActivity.setMessage(cause.getMessage()); @@ -210,22 +187,19 @@ private IMendixObject createExceptionActivity(UnitTest test) { return exceptionActivity.getMendixObject(); } - private IMendixObject createAssertionActivity(UnitTest test, IMendixObject assertionObj) { - IContext systemContext = Core.createSystemContext(); - Assertion assertion = Assertion.initialize(systemContext, assertionObj); - - AssertionActivity assertionActivity = new AssertionActivity(systemContext); + private IMendixObject createAssertionActivity(IContext context, UnitTest test, AssertActivity assertion) { + AssertionActivity assertionActivity = new AssertionActivity(context); assertionActivity.setTestActivity_UnitTest(test); assertionActivity.setSequence(assertion.getSequence()); assertionActivity.setName(assertion.getName()); - assertionActivity.setResult(assertion.getResult()); + assertionActivity.setResult(assertion.getResultEnum()); assertionActivity.setMessage(assertion.getMessage()); return assertionActivity.getMendixObject(); } - private IMendixObject createStepActivity(UnitTest test, StepExecutionActivity step) { - StepActivity stepActivity = new StepActivity(Core.createSystemContext()); + private IMendixObject createStepActivity(IContext context, UnitTest test, StepExecutionActivity step) { + StepActivity stepActivity = new StepActivity(context); stepActivity.setTestActivity_UnitTest(test); stepActivity.setSequence(step.getSequence()); stepActivity.setMessage(step.getMessage()); diff --git a/src/javasource/unittesting/TestManager.java b/src/javasource/unittesting/TestManager.java index 128403d..70e3b96 100644 --- a/src/javasource/unittesting/TestManager.java +++ b/src/javasource/unittesting/TestManager.java @@ -24,6 +24,7 @@ import unittesting.proxies.ENUM_UnitTestResult; import unittesting.proxies.TestSuite; import unittesting.proxies.UnitTest; +import unittesting.proxies.UnitTestContext; /** * @author mwe @@ -112,16 +113,13 @@ private void runMfSetup(TestSuite testSuite) { if (hasMfSetup(testSuite)) { try { LOG.info("Running Setup microflow.."); - if (testSuite.getAutoRollbackMFs()) { - setupContext = Core.createSystemContext(); - setupContext.startTransaction(); - LOG.trace("Start transaction for setup"); - Core.microflowCall(testSuite.getModule() + ".Setup").execute(setupContext); - } else { - Core.microflowCall(testSuite.getModule() + ".Setup").execute(Core.createSystemContext()); - } + + setupContext = Core.createSystemContext(); + setupContext.startTransaction(); + LOG.trace("Start transaction for setup"); + Core.microflowCall(testSuite.getModule() + ".Setup").execute(setupContext); } catch (Exception e) { - LOG.error("Exception during SetUp microflow: " + e.getMessage(), e); + LOG.error("Exception during Setup microflow: " + e.getMessage(), e); throw new RuntimeException(e); } } @@ -129,16 +127,15 @@ private void runMfSetup(TestSuite testSuite) { private void runMfTearDown(TestSuite testSuite) { IContext tearDownContext = setupContext; + if (hasMfTearDown(testSuite)) { try { LOG.info("Running TearDown microflow.."); + if (tearDownContext == null) { tearDownContext = Core.createSystemContext(); - - if (testSuite.getAutoRollbackMFs()) { - tearDownContext.startTransaction(); - LOG.trace("Start transaction for teardown"); - } + tearDownContext.startTransaction(); + LOG.trace("Start transaction for teardown"); } Core.microflowCall(testSuite.getModule() + ".TearDown").execute(tearDownContext); @@ -150,9 +147,14 @@ private void runMfTearDown(TestSuite testSuite) { } // Rollback teardown and/or setup transaction - if (testSuite.getAutoRollbackMFs() && tearDownContext != null) { - LOG.trace("Rollback transaction for setup and/or teardown"); - tearDownContext.rollbackTransaction(); + if (tearDownContext != null && tearDownContext.isInTransaction()) { + if (testSuite.getAutoRollbackMFs()) { + LOG.trace("Rollback transaction for setup and/or teardown"); + tearDownContext.rollbackTransaction(); + } else { + LOG.trace("End transaction for for setup and/or teardown"); + tearDownContext.endTransaction(); + } } // Make sure we clean setupContext after running this test/suite @@ -322,11 +324,11 @@ public boolean validateTestMicroflow(String mf) { return true; } - private MicroflowCallBuilder buildMicroflowCall(String mf) { + private MicroflowCallBuilder buildMicroflowCall(String mf, UnitTestContext unitTestContext) { MicroflowCallBuilder builder = Core.microflowCall(mf); if (hasTestContextInputParameter(mf)) - builder = builder.withParam(TEST_CONTEXT_PARAM_NAME, executionContext().getUnitTestContext().getMendixObject()); + builder = builder.withParam(TEST_CONTEXT_PARAM_NAME, unitTestContext.getMendixObject()); return builder; } @@ -350,21 +352,12 @@ private boolean runMicroflowTest(String mf, UnitTest test, TestSuite testSuite) test.setResultMessage(""); test.setLastRun(new Date()); - IContext mfContext = null; - - if (testSuite.getAutoRollbackMFs()) { - if (Core.getMicroflowNames().contains(testSuite.getModule() + ".Setup")) - mfContext = setupContext.createClone(); - else - mfContext = Core.createSystemContext(); + IContext mfContext = getMicroflowTestContext(testSuite); - mfContext.startTransaction(); - LOG.trace("Start transaction for unit test"); - } else { - mfContext = Core.createSystemContext(); - } + mfContext.startTransaction(); + LOG.trace("Start transaction for unit test"); - executionContext = new TestExecutionContext(mfContext, mf); + executionContext = new TestExecutionContext(); executionContext().clearTestActivities(test); long duration = 0L; @@ -383,7 +376,10 @@ private boolean runMicroflowTest(String mf, UnitTest test, TestSuite testSuite) test.setResult(ENUM_UnitTestResult._1_Running); commitSilent(test); - Object mfReturnValue = buildMicroflowCall(mf).execute(mfContext); + UnitTestContext unitTestContext = UnitTestContextManager.createUnitTestContext(mfContext, mf); + executionContext().setUnitTestContext(unitTestContext); + + Object mfReturnValue = buildMicroflowCall(mf, unitTestContext).execute(mfContext); duration = System.currentTimeMillis() - startTimestamp; boolean returnValueResult = mfReturnValue == null || Boolean.TRUE.equals(mfReturnValue) || "".equals(mfReturnValue); @@ -396,9 +392,19 @@ private boolean runMicroflowTest(String mf, UnitTest test, TestSuite testSuite) executionContext().collectEnd(false, "Microflow returned false"); } - boolean testResult = returnValueResult && !executionContext().hasFailedAssertion(mfContext); + boolean testResult = returnValueResult && !executionContext().hasFailedAssertion(); test.setResult(testResult ? ENUM_UnitTestResult._3_Success : ENUM_UnitTestResult._2_Failed); + if (mfContext.isInTransaction()) { + if (testSuite.getAutoRollbackMFs()) { + LOG.trace("Rollback transaction for unit test"); + mfContext.rollbackTransaction(); + } else { + LOG.trace("End transaction for unit test"); + mfContext.endTransaction(); + } + } + return testResult; } catch (Exception e) { duration = System.currentTimeMillis() - startTimestamp; @@ -412,26 +418,27 @@ private boolean runMicroflowTest(String mf, UnitTest test, TestSuite testSuite) return false; } finally { - executionContext().persistTestActivities(mfContext, test); - - if (testSuite.getAutoRollbackMFs() && mfContext.isInTransaction()) { - LOG.trace("Rollback transaction for unit test"); - mfContext.rollbackTransaction(); - } + executionContext().persistTestActivities(test); - test.setResultMessage(executionContext().getResultSummary(mfContext)); + test.setResultMessage(executionContext().getResultSummary()); test.setReadableTime(formatAsReadableTime(duration)); if (executionContext().getLastStep() != null) test.setLastStep(executionContext().getLastStep().getMessage()); commitSilent(test); - executionContext().delete(); - LOG.info("Finished unit test " + mf + ": " + test.getResult()); } } + private IContext getMicroflowTestContext(TestSuite testSuite) { + if (Core.getMicroflowNames().contains(testSuite.getModule() + ".Setup")) { + return setupContext.createClone(); + } else { + return Core.createSystemContext(); + } + } + public static String formatAsReadableTime(long ms) { return (ms > 10000 ? Math.round(ms / 1000) + " seconds" : (ms == 0 ? "<1" : ms) + " milliseconds"); diff --git a/src/javasource/unittesting/UnitTestContextManager.java b/src/javasource/unittesting/UnitTestContextManager.java new file mode 100644 index 0000000..9ea63c5 --- /dev/null +++ b/src/javasource/unittesting/UnitTestContextManager.java @@ -0,0 +1,31 @@ +package unittesting; + +import com.mendix.logging.ILogNode; +import com.mendix.systemwideinterfaces.core.IContext; +import unittesting.activities.AssertActivity; +import unittesting.proxies.Assertion; +import unittesting.proxies.UnitTestContext; + +public class UnitTestContextManager { + private static final ILogNode LOG = ConfigurationManager.LOG; + + public static UnitTestContext createUnitTestContext(IContext context, String microflowName) { + UnitTestContext unitTestContext = new UnitTestContext(context); + unitTestContext.setTestName(microflowName); + + LOG.trace("Created unit test context for " + microflowName); + + return unitTestContext; + } + + public static Assertion addAssertion(IContext context, UnitTestContext unitTestContext, AssertActivity assertActivity) { + Assertion assertion = new Assertion(context); + assertion.setAssertion_UnitTestContext(unitTestContext); + assertion.setSequence(assertActivity.getSequence()); + assertion.setName(assertActivity.getName()); + assertion.setResult(assertActivity.getResultEnum()); + assertion.setMessage(assertActivity.getMessage()); + + return assertion; + } +} diff --git a/src/javasource/unittesting/actions/AssertUsingExpression.java b/src/javasource/unittesting/actions/AssertUsingExpression.java index 7473758..6bcaacf 100644 --- a/src/javasource/unittesting/actions/AssertUsingExpression.java +++ b/src/javasource/unittesting/actions/AssertUsingExpression.java @@ -14,8 +14,10 @@ import com.mendix.webui.CustomJavaAction; import unittesting.TestExecutionContext; import unittesting.TestManager; +import unittesting.UnitTestContextManager; +import unittesting.activities.AssertActivity; import unittesting.proxies.Assertion; -import unittesting.proxies.ENUM_UnitTestResult; +import unittesting.proxies.UnitTestContext; public class AssertUsingExpression extends CustomJavaAction { @@ -38,12 +40,15 @@ public IMendixObject executeAction() throws Exception { // BEGIN USER CODE TestExecutionContext executionContext = TestManager.instance().executionContext(); - Assertion result = executionContext.collectAssertion(getContext(), name, expression, failureMessage); + AssertActivity assertActivity = executionContext.collectAssertion(name, expression, failureMessage); - if (ENUM_UnitTestResult._2_Failed.equals(result.getResult()) && stopOnFailure) + UnitTestContext unitTestContext = executionContext.getUnitTestContext(); + Assertion assertion = UnitTestContextManager.addAssertion(getContext(), unitTestContext, assertActivity); + + if (assertActivity.isFailed() && stopOnFailure) throw new TestManager.AssertionException(failureMessage); - return result.getMendixObject(); + return assertion.getMendixObject(); // END USER CODE } diff --git a/src/javasource/unittesting/actions/ThrowAssertionFailed.java b/src/javasource/unittesting/actions/ThrowAssertionFailed.java index 654dd87..eb09452 100644 --- a/src/javasource/unittesting/actions/ThrowAssertionFailed.java +++ b/src/javasource/unittesting/actions/ThrowAssertionFailed.java @@ -9,6 +9,7 @@ package unittesting.actions; +import unittesting.TestExecutionContext; import unittesting.TestManager; import com.mendix.systemwideinterfaces.core.IContext; import com.mendix.webui.CustomJavaAction; @@ -27,6 +28,9 @@ public ThrowAssertionFailed(IContext context, java.lang.String message) public java.lang.Boolean executeAction() throws Exception { // BEGIN USER CODE + TestExecutionContext executionContext = TestManager.instance().executionContext(); + executionContext.collectAssertion(null, false, message); + throw new TestManager.AssertionException(message); // END USER CODE } diff --git a/src/javasource/unittesting/activities/AssertActivity.java b/src/javasource/unittesting/activities/AssertActivity.java new file mode 100644 index 0000000..155daf4 --- /dev/null +++ b/src/javasource/unittesting/activities/AssertActivity.java @@ -0,0 +1,36 @@ +package unittesting.activities; + +import unittesting.proxies.ENUM_UnitTestResult; + +public class AssertActivity extends ExecutionActivity { + private final String name; + private final boolean result; + private final String message; + + public AssertActivity(int sequence, String name, boolean result, String failureMessage) { + super(sequence); + this.name = name; + this.result = result; + this.message = result ? null : failureMessage; + } + + public String getName() { + return this.name; + } + + public boolean isSuccess() { + return this.result; + } + + public boolean isFailed() { + return !this.result; + } + + public ENUM_UnitTestResult getResultEnum() { + return this.result ? ENUM_UnitTestResult._3_Success : ENUM_UnitTestResult._2_Failed; + } + + public String getMessage() { + return this.message; + } +} diff --git a/src/project-settings.user.json b/src/project-settings.user.json deleted file mode 100644 index 51a462a..0000000 --- a/src/project-settings.user.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "serializationVersion": 2, - "settingsParts": [ - { - "suppressions": [], - "suppressAppStoreWarnings": false, - "showSuppressionInfo": true, - "type": "Mendix.Modeler.Suppressions.SuppressionRules, Mendix.Modeler.Core, Version=9.24.0.0, Culture=neutral, PublicKeyToken=null" - }, - { - "suppressions": [], - "disabledBestPractices": [], - "readRecommendations": [], - "suppressedRecommendations": [], - "hasShownRecommendationsNotificationForThisApp": true, - "type": "Mendix.Modeler.MxAssist.PerformanceBot.Serialization.Configuration.PerformanceBotConfiguration, Mendix.Modeler.MxAssist.PerformanceBot.Serialization, Version=9.24.0.0, Culture=neutral, PublicKeyToken=null" - } - ] -} \ No newline at end of file