-
Notifications
You must be signed in to change notification settings - Fork 12
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
1 parent
d6f1bb8
commit 474e8ee
Showing
30 changed files
with
852 additions
and
104 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,77 @@ | ||
|
|
||
| import com.atiurin.ultron.annotations.ExperimentalUltronApi | ||
| import com.atiurin.ultron.core.test.UltronTest | ||
| import com.atiurin.ultron.log.UltronLog | ||
| import kotlin.test.Test | ||
| import kotlin.test.assertTrue | ||
|
|
||
| class UltronTestFlowTest : UltronTest() { | ||
| companion object { | ||
| var order = 0 | ||
| var beforeAllTestCounter = -1 | ||
| var commonBeforeOrder = -1 | ||
| var commonAfterOrder = -1 | ||
| var afterOrder = -1 | ||
|
|
||
| } | ||
|
|
||
| @OptIn(ExperimentalUltronApi::class) | ||
| override val beforeFirstTest = { | ||
| beforeAllTestCounter = order | ||
| UltronLog.info("Before Class") | ||
| } | ||
|
|
||
| override val beforeTest = { | ||
| commonBeforeOrder = order | ||
| order++ | ||
| UltronLog.info("Before test common") | ||
| } | ||
| override val afterTest = { | ||
| commonAfterOrder = order | ||
| order++ | ||
| assertTrue(afterOrder < commonAfterOrder, message = "CommonAfter block should run after 'after' test block") | ||
| UltronLog.info("After test common") | ||
| } | ||
|
|
||
| @Test | ||
| fun someTest1() = test { | ||
| var beforeOrder = -1 | ||
| var goOrder = -1 | ||
| order++ | ||
| before { | ||
| beforeOrder = order | ||
| order++ | ||
| UltronLog.info("Before TestMethod 1") | ||
| }.go { | ||
| goOrder = order | ||
| order++ | ||
| UltronLog.info("Run TestMethod 1") | ||
| }.after { | ||
| afterOrder = order | ||
| order++ | ||
| assertTrue(beforeAllTestCounter == 0, message = "beforeAllTests block should run before all test") | ||
| assertTrue(beforeAllTestCounter < commonBeforeOrder, message = "beforeAllTests block should run before commonBefore block") | ||
| assertTrue(commonBeforeOrder < beforeOrder, message = "beforeOrder block should run after commonBefore block") | ||
| assertTrue(beforeOrder < goOrder, message = "Before block should run before 'go'") | ||
| assertTrue(goOrder < afterOrder, message = "After block should run after 'go'") | ||
| } | ||
| } | ||
|
|
||
| @Test | ||
| fun someTest2() = test(suppressCommonBefore = true) { | ||
| before { | ||
| UltronLog.info("Before TestMethod 2") | ||
| }.after { | ||
| UltronLog.info("After TestMethod 2") | ||
| }.go { | ||
| assertTrue(beforeAllTestCounter == 0, message = "beforeAllTests block should run only once") | ||
| UltronLog.info("Run TestMethod 2") | ||
| } | ||
| } | ||
|
|
||
| @Test | ||
| fun simpleTest() = test { | ||
| assertTrue(beforeAllTestCounter == 0, message = "beforeAllTests block should run only once") | ||
| UltronLog.info("UltronTest simpleTest") | ||
| } | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,52 @@ | ||
| import com.atiurin.ultron.annotations.ExperimentalUltronApi | ||
| import com.atiurin.ultron.core.test.UltronTest | ||
| import com.atiurin.ultron.log.UltronLog | ||
| import kotlin.test.Test | ||
| import kotlin.test.assertTrue | ||
|
|
||
| class UltronTestFlowTest2 : UltronTest() { | ||
| var order = 0 | ||
| var beforeAllTestCounter = 0 | ||
|
|
||
| @OptIn(ExperimentalUltronApi::class) | ||
| override val beforeFirstTest = { | ||
| beforeAllTestCounter = order | ||
| order++ | ||
| UltronLog.info("Before Class") | ||
| } | ||
|
|
||
| @Test | ||
| fun someTest1() = test { | ||
| var beforeOrder = -1 | ||
| var afterOrder = -1 | ||
| var goOrder = -1 | ||
| order++ | ||
| before { | ||
| beforeOrder = order | ||
| order++ | ||
| UltronLog.info("Before TestMethod 1") | ||
| }.go { | ||
| goOrder = order | ||
| order++ | ||
| UltronLog.info("Run TestMethod 1") | ||
| }.after { | ||
| afterOrder = order | ||
| assertTrue(beforeAllTestCounter == 0, message = "beforeAllTests block should run before all test") | ||
| assertTrue(beforeOrder > beforeAllTestCounter, message = "Before block should run after 'Before All'") | ||
| assertTrue(beforeOrder < goOrder, message = "Before block should run before 'go'") | ||
| assertTrue(goOrder < afterOrder, message = "After block should run after 'go'") | ||
| } | ||
| } | ||
|
|
||
| @Test | ||
| fun someTest2() = test(suppressCommonBefore = true) { | ||
| before { | ||
| UltronLog.info("Before TestMethod 2") | ||
| }.after { | ||
| UltronLog.info("After TestMethod 2") | ||
| }.go { | ||
| assertTrue(beforeAllTestCounter == 0, message = "beforeAllTests block should run only once") | ||
| UltronLog.info("Run TestMethod 2") | ||
| } | ||
| } | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,5 +1,5 @@ | ||
| --- | ||
| sidebar_position: 4 | ||
| sidebar_position: 5 | ||
| --- | ||
|
|
||
| # Boolean result | ||
|
|
||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,5 +1,5 @@ | ||
| --- | ||
| sidebar_position: 1 | ||
| sidebar_position: 3 | ||
| --- | ||
|
|
||
| # Ultron Extension | ||
|
|
||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,5 +1,5 @@ | ||
| --- | ||
| sidebar_position: 3 | ||
| sidebar_position: 4 | ||
| --- | ||
|
|
||
| # Listeners | ||
|
|
||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,5 +1,5 @@ | ||
| --- | ||
| sidebar_position: 5 | ||
| sidebar_position: 7 | ||
| --- | ||
|
|
||
| # Result handler | ||
|
|
||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,174 @@ | ||
| --- | ||
| sidebar_position: 2 | ||
| --- | ||
|
|
||
| # UltronTest | ||
|
|
||
| `UltronTest` is a powerful base class provided by the Ultron framework that enables the definition of common preconditions and postconditions for tests. By extending this class, you can streamline test setup and teardown, ensuring consistent execution across your test suite. | ||
|
|
||
| ## Features of `UltronTest` | ||
|
|
||
| - **Pre-Test Actions:** Define actions to be executed before each test. | ||
| - **Post-Test Actions:** Define actions to be executed after each test. | ||
| - **Lifecycle Management:** Execute code once before all tests in a class using `beforeFirstTest`. | ||
| - **Customizable Test Execution:** Suppress pre-test or post-test actions when needed. | ||
|
|
||
| ### Example | ||
|
|
||
| Here is an example of using `UltronTest`: | ||
|
|
||
| ```kotlin | ||
| class SampleUltronFlowTest : UltronTest() { | ||
|
|
||
| @OptIn(ExperimentalUltronApi::class) | ||
| override val beforeFirstTest = { | ||
| UltronLog.info("Before Class") | ||
| } | ||
|
|
||
| override val beforeTest = { | ||
| UltronLog.info("Before test common") | ||
| } | ||
|
|
||
| override val afterTest = { | ||
| UltronLog.info("After test common") | ||
| } | ||
|
|
||
| /** | ||
| * The order of method execution is as follows:: | ||
| * beforeFirstTest, beforeTest, before, go, after, afterTest | ||
| */ | ||
| @Test | ||
| fun someTest1() = test { | ||
| before { | ||
| UltronLog.info("Before TestMethod 1") | ||
| }.go { | ||
| UltronLog.info("Run TestMethod 1") | ||
| }.after { | ||
| UltronLog.info("After TestMethod 1") | ||
| } | ||
| } | ||
|
|
||
| /** | ||
| * An order of methods execution is follow: before, go, after | ||
| * `beforeFirstTest` - Not executed, as it is only run once and was already executed before `someTest1`. | ||
| * `beforeTest` - Not executed because it was suppressed using `suppressCommonBefore`. | ||
| * `afterTest` - Not executed because it was suppressed using `suppressCommonAfter`. | ||
| */ | ||
| @Test | ||
| fun someTest2() = test( | ||
| suppressCommonBefore = true, | ||
| suppressCommonAfter = true | ||
| ) { | ||
| before { | ||
| UltronLog.info("Before TestMethod 2") | ||
| }.go { | ||
| UltronLog.info("Run TestMethod 2") | ||
| }.after { | ||
| UltronLog.info("After TestMethod 2") | ||
| } | ||
| } | ||
|
|
||
| /** | ||
| * An order of methods execution is follow: beforeTest, test, afterTest | ||
| * `beforeFirstTest` - Not executed, since it was executed before `someTest1` | ||
| */ | ||
| @Test | ||
| fun someTest3() = test { | ||
| UltronLog.info("UltronTest simpleTest") | ||
| } | ||
| } | ||
| ``` | ||
|
|
||
| ### Key Methods | ||
|
|
||
| - **`beforeFirstTest`**: Code executed once before all tests in a class. | ||
| - **`beforeTest`**: Code executed before each test. | ||
| - **`afterTest`**: Code executed after each test. | ||
| - **`test`**: Executes a test with options to suppress pre-test or post-test actions. | ||
|
|
||
| ### Key Features of the `test` Method | ||
|
|
||
| - **Test Context Recreation:** | ||
| The `test` method automatically recreates the `UltronTestContext` for each test execution, ensuring a clean and isolated state for the test context. | ||
|
|
||
| - **Soft Assertion Reset:** | ||
| Any exceptions captured during `softAssertions` in the previous test are cleared at the start of each new `test` execution, maintaining a clean state. | ||
|
|
||
| - **Lifecycle Management:** | ||
| It invokes `beforeTest` and `afterTest` methods around your test logic unless explicitly suppressed. | ||
| --- | ||
|
|
||
| ### Purpose of `before`, `go`, and `after` | ||
| - **`before`:** Defines preconditions or setup actions that must be performed before the main test logic is executed. | ||
| These actions might include preparing data, navigating to a specific screen, or setting up the environment. | ||
| ```kotlin | ||
| before { | ||
| UltronLog.info("Setting up preconditions for TestMethod 2") | ||
| } | ||
| ``` | ||
|
|
||
| - **`go`:** Encapsulates the core logic or actions of the test. This is where the actual operations being tested are performed, such as interacting with UI elements or executing specific functionality. | ||
| ```kotlin | ||
| go { | ||
| UltronLog.info("Executing the main logic of TestMethod 2") | ||
| } | ||
| ``` | ||
|
|
||
| - **`after`:** Block is used for postconditions or cleanup actions that need to occur after the main test logic has executed. This might include verifying results, resetting the environment, or clearing resources. | ||
| ```kotlin | ||
| after { | ||
| UltronLog.info("Cleaning up after TestMethod 2") | ||
| } | ||
| ``` | ||
|
|
||
| These methods help clearly separate test phases, making tests easier to read and maintain. | ||
|
|
||
| ## Using `softAssertion` for Flexible Error Handling | ||
|
|
||
| The `softAssertion` mechanism in Ultron allows tests to catch and verify multiple exceptions during their execution without failing immediately. This feature is particularly useful for validating multiple conditions within a single test. | ||
| ### Example of `softAssertion` | ||
|
|
||
| ```kotlin | ||
| class SampleTest : UltronTest() { | ||
| @Test | ||
| fun softAssertionTest() { | ||
| softAssertion(failOnException = false) { | ||
| hasText("NotExistText").withTimeout(100).assertIsDisplayed() | ||
| hasTestTag("NotExistTestTag").withTimeout(100).assertHasClickAction() | ||
| } | ||
| verifySoftAssertions() | ||
| } | ||
| } | ||
| ``` | ||
|
|
||
| The `softAssertion` mechanism does not inherently depend on `UltronTest`. | ||
| You can use `softAssertion` independently of the `UltronTest` base class. However, in such cases, you must manually clear exceptions between tests to ensure they do not persist across test executions. | ||
| ```kotlin | ||
| class SampleTest { | ||
| @Test | ||
| fun softAssertionTest() { | ||
| UltronCommonConfig.testContext.softAnalyzer.clear() | ||
| softAssertion() { | ||
| //assert smth | ||
| } | ||
| } | ||
| } | ||
| ``` | ||
|
|
||
| ### Explanation | ||
|
|
||
| - **Fail on Exception:** By default (`failOnException = true`), `softAssertion` will throw an exception after completing all operations within its block if any failures occur. | ||
| - **Manual Verification:** If `failOnException` is set to `false`, you can explicitly verify all caught exceptions at the end of the test using `verifySoftAssertions()`. | ||
|
|
||
| This approach ensures granular control over how exceptions are handled and reported, making it easier to analyze and debug test failures. | ||
|
|
||
| --- | ||
|
|
||
| ## Benefits of `UltronTest` usage | ||
|
|
||
| - Simplifies test setup and teardown with consistent preconditions and postconditions. | ||
| - Enhances error handling by allowing multiple assertions within a single test. | ||
| - Improves test readability and maintainability. | ||
|
|
||
| By leveraging `UltronTest` and `softAssertion`, you can build robust and flexible UI tests for your applications. | ||
|
|
Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.
Oops, something went wrong.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
77 changes: 77 additions & 0 deletions
77
...-app/src/androidTest/java/com/atiurin/sampleapp/tests/testlifecycle/UltronTestFlowTest.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,77 @@ | ||
| package com.atiurin.sampleapp.tests.testlifecycle | ||
|
|
||
| import com.atiurin.sampleapp.tests.BaseTest | ||
| import com.atiurin.ultron.annotations.ExperimentalUltronApi | ||
| import com.atiurin.ultron.log.UltronLog | ||
| import org.junit.Test | ||
|
|
||
| class UltronTestFlowTest : BaseTest() { | ||
| companion object { | ||
| var order = 0 | ||
| var beforeAllTestCounter = -1 | ||
| var commonBeforeOrder = -1 | ||
| var commonAfterOrder = -1 | ||
| var afterOrder = -1 | ||
|
|
||
| } | ||
|
|
||
| @OptIn(ExperimentalUltronApi::class) | ||
| override val beforeFirstTest = { | ||
| beforeAllTestCounter = order | ||
| UltronLog.info("Before Class") | ||
| } | ||
|
|
||
| override val beforeTest = { | ||
| commonBeforeOrder = order | ||
| order++ | ||
| UltronLog.info("Before test common") | ||
| } | ||
| override val afterTest = { | ||
| commonAfterOrder = order | ||
| order++ | ||
| assert(afterOrder < commonAfterOrder, lazyMessage = { "CommonAfter block should run after 'after' test block" }) | ||
| UltronLog.info("After test common") | ||
| } | ||
|
|
||
| @Test | ||
| fun someTest1() = test { | ||
| var beforeOrder = -1 | ||
| var goOrder = -1 | ||
| order++ | ||
| before { | ||
| beforeOrder = order | ||
| order++ | ||
| UltronLog.info("Before TestMethod 1") | ||
| }.go { | ||
| goOrder = order | ||
| order++ | ||
| UltronLog.info("Run TestMethod 1") | ||
| }.after { | ||
| afterOrder = order | ||
| order++ | ||
| assert(beforeAllTestCounter == 0, lazyMessage = { "beforeAllTests block should run before all test" }) | ||
| assert(beforeAllTestCounter < commonBeforeOrder, lazyMessage = { "beforeAllTests block should run before commonBefore block" }) | ||
| assert(commonBeforeOrder < beforeOrder, lazyMessage = { "beforeOrder block should run after commonBefore block" }) | ||
| assert(beforeOrder < goOrder, lazyMessage = { "Before block should run before 'go'" }) | ||
| assert(goOrder < afterOrder, lazyMessage = { "After block should run after 'go'" }) | ||
| } | ||
| } | ||
|
|
||
| @Test | ||
| fun someTest2() = test(suppressCommonBefore = true) { | ||
| before { | ||
| UltronLog.info("Before TestMethod 2") | ||
| }.after { | ||
| UltronLog.info("After TestMethod 2") | ||
| }.go { | ||
| assert(beforeAllTestCounter == 0, lazyMessage = { "beforeAllTests block should run only once" }) | ||
| UltronLog.info("Run TestMethod 2") | ||
| } | ||
| } | ||
|
|
||
| @Test | ||
| fun simpleTest() = test { | ||
| assert(beforeAllTestCounter == 0, lazyMessage = { "beforeAllTests block should run only once" }) | ||
| UltronLog.info("UltronTest simpleTest") | ||
| } | ||
| } |
51 changes: 51 additions & 0 deletions
51
...app/src/androidTest/java/com/atiurin/sampleapp/tests/testlifecycle/UltronTestFlowTest2.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,51 @@ | ||
| package com.atiurin.sampleapp.tests.testlifecycle | ||
|
|
||
| import com.atiurin.sampleapp.tests.BaseTest | ||
| import com.atiurin.ultron.annotations.ExperimentalUltronApi | ||
| import com.atiurin.ultron.log.UltronLog | ||
| import org.junit.Test | ||
|
|
||
| class UltronTestFlowTest2 : BaseTest() { | ||
| var order = 0 | ||
| var beforeAllTestCounter = 0 | ||
| @OptIn(ExperimentalUltronApi::class) | ||
| override val beforeFirstTest = { | ||
| beforeAllTestCounter = order | ||
| order++ | ||
| UltronLog.info("Before Class") | ||
| } | ||
| @Test | ||
| fun someTest1() = test { | ||
| var beforeOrder = -1 | ||
| var afterOrder = -1 | ||
| var goOrder = -1 | ||
| order++ | ||
| before { | ||
| beforeOrder = order | ||
| order++ | ||
| UltronLog.info("Before TestMethod 1") | ||
| }.go { | ||
| goOrder = order | ||
| order++ | ||
| UltronLog.info("Run TestMethod 1") | ||
| }.after { | ||
| afterOrder = order | ||
| assert(beforeAllTestCounter == 0, lazyMessage = { "beforeAllTests block should run before all test" }) | ||
| assert(beforeOrder > beforeAllTestCounter, lazyMessage = { "Before block should run after 'Before All'" }) | ||
| assert(beforeOrder < goOrder, lazyMessage = { "Before block should run before 'go'" }) | ||
| assert(goOrder < afterOrder, lazyMessage = { "After block should run after 'go'" }) | ||
| } | ||
| } | ||
|
|
||
| @Test | ||
| fun someTest2() = test(suppressCommonBefore = true) { | ||
| before { | ||
| UltronLog.info("Before TestMethod 2") | ||
| }.after { | ||
| UltronLog.info("After TestMethod 2") | ||
| }.go { | ||
| assert(beforeAllTestCounter == 0, lazyMessage = { "beforeAllTests block should run only once" }) | ||
| UltronLog.info("Run TestMethod 2") | ||
| } | ||
| } | ||
| } |
11 changes: 11 additions & 0 deletions
11
sample-app/src/androidTest/java/com/atiurin/sampleapp/tests/testlifecycle/UltronTestPlan.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,11 @@ | ||
| package com.atiurin.sampleapp.tests.testlifecycle | ||
|
|
||
| import org.junit.runner.RunWith | ||
| import org.junit.runners.Suite | ||
|
|
||
| @RunWith(Suite::class) | ||
| @Suite.SuiteClasses( | ||
| UltronTestFlowTest::class, | ||
| UltronTestFlowTest2::class, | ||
| ) | ||
| class UltronTestPlan |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
31 changes: 31 additions & 0 deletions
31
ultron-common/src/commonMain/kotlin/com/atiurin/ultron/annotations/ExperimentalUltronApi.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,31 @@ | ||
| package com.atiurin.ultron.annotations | ||
|
|
||
| import kotlin.annotation.AnnotationTarget.ANNOTATION_CLASS | ||
| import kotlin.annotation.AnnotationTarget.CLASS | ||
| import kotlin.annotation.AnnotationTarget.CONSTRUCTOR | ||
| import kotlin.annotation.AnnotationTarget.FIELD | ||
| import kotlin.annotation.AnnotationTarget.FUNCTION | ||
| import kotlin.annotation.AnnotationTarget.LOCAL_VARIABLE | ||
| import kotlin.annotation.AnnotationTarget.PROPERTY | ||
| import kotlin.annotation.AnnotationTarget.PROPERTY_GETTER | ||
| import kotlin.annotation.AnnotationTarget.PROPERTY_SETTER | ||
| import kotlin.annotation.AnnotationTarget.TYPEALIAS | ||
| import kotlin.annotation.AnnotationTarget.VALUE_PARAMETER | ||
|
|
||
| @RequiresOptIn | ||
| @MustBeDocumented | ||
| @Target( | ||
| CLASS, | ||
| ANNOTATION_CLASS, | ||
| PROPERTY, | ||
| FIELD, | ||
| LOCAL_VARIABLE, | ||
| VALUE_PARAMETER, | ||
| CONSTRUCTOR, | ||
| FUNCTION, | ||
| PROPERTY_GETTER, | ||
| PROPERTY_SETTER, | ||
| TYPEALIAS | ||
| ) | ||
| @Retention(AnnotationRetention.BINARY) | ||
| public annotation class ExperimentalUltronApi |
21 changes: 21 additions & 0 deletions
21
...on-common/src/commonMain/kotlin/com/atiurin/ultron/core/common/assertion/SoftAssertion.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,21 @@ | ||
| package com.atiurin.ultron.core.common.assertion | ||
|
|
||
| import com.atiurin.ultron.core.config.UltronCommonConfig | ||
| import com.atiurin.ultron.log.UltronLog | ||
|
|
||
| fun softAssertion(failOnException: Boolean = true, block: () -> Unit){ | ||
| UltronLog.info("Start soft assertion context") | ||
| with(UltronCommonConfig.testContext){ | ||
| softAssertion = true | ||
| block() | ||
| softAssertion = false | ||
| if (failOnException){ | ||
| softAnalyzer.verify() | ||
| } | ||
| } | ||
| UltronLog.info("Finish soft assertion context") | ||
| } | ||
|
|
||
| fun verifySoftAssertions(){ | ||
| UltronCommonConfig.testContext.softAnalyzer.verify() | ||
| } |
5 changes: 4 additions & 1 deletion
5
...re/common/CheckOperationResultAnalyzer.kt → ...tanalyzer/CheckOperationResultAnalyzer.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
35 changes: 35 additions & 0 deletions
35
.../atiurin/ultron/core/common/resultanalyzer/DefaultSoftAssertionOperationResultAnalyzer.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,35 @@ | ||
| package com.atiurin.ultron.core.common.resultanalyzer | ||
|
|
||
| import com.atiurin.ultron.core.common.Operation | ||
| import com.atiurin.ultron.core.common.OperationResult | ||
| import com.atiurin.ultron.exceptions.UltronOperationException | ||
|
|
||
| class DefaultSoftAssertionOperationResultAnalyzer : SoftAssertionOperationResultAnalyzer { | ||
| private val caughtExceptions = mutableListOf<Throwable>() | ||
| lateinit var originalAnalyzer: OperationResultAnalyzer | ||
|
|
||
| override fun <Op : Operation, OpRes : OperationResult<Op>> analyze(operationResult: OpRes): Boolean { | ||
| return kotlin.runCatching { | ||
| originalAnalyzer.analyze(operationResult) | ||
| }.onFailure { ex -> | ||
| caughtExceptions.add(ex) | ||
| }.isSuccess | ||
| } | ||
|
|
||
| override fun clear(){ | ||
| caughtExceptions.clear() | ||
| } | ||
|
|
||
| override fun verify(){ | ||
| val message = StringBuilder() | ||
| if (caughtExceptions.isNotEmpty()){ | ||
| val delimiter = "========================================================================================" | ||
| caughtExceptions.forEach { ex -> | ||
| message.appendLine(ex.message) | ||
| message.appendLine(delimiter) | ||
| } | ||
| clear() | ||
| throw UltronOperationException("SOFT ASSERTION FAILED. Details:\n$message") | ||
| } | ||
| } | ||
| } |
5 changes: 4 additions & 1 deletion
5
...on/core/common/OperationResultAnalyzer.kt → ...resultanalyzer/OperationResultAnalyzer.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
19 changes: 19 additions & 0 deletions
19
...lin/com/atiurin/ultron/core/common/resultanalyzer/SoftAssertionOperationResultAnalyzer.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,19 @@ | ||
| package com.atiurin.ultron.core.common.resultanalyzer | ||
|
|
||
| interface SoftAssertionOperationResultAnalyzer : OperationResultAnalyzer { | ||
| /** | ||
| * Clears all previously caught exceptions, effectively resetting the internal state. | ||
| * Use this method when starting a new set of assertions to ensure | ||
| * that previous exceptions do not affect the current verification process. | ||
| */ | ||
| fun clear() | ||
|
|
||
| /** | ||
| * Verifies whether any exceptions were caught during previous operations. | ||
| * If there were caught exceptions, this method throws a general exception summarizing them. | ||
| * Use this method at the end of your test or operation to ensure that all assertions passed. | ||
| * | ||
| * @throws Exception if one or more exceptions were previously caught. | ||
| */ | ||
| fun verify() | ||
| } |
6 changes: 4 additions & 2 deletions
6
...n/UltronDefaultOperationResultAnalyzer.kt → ...r/UltronDefaultOperationResultAnalyzer.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
8 changes: 7 additions & 1 deletion
8
ultron-common/src/commonMain/kotlin/com/atiurin/ultron/core/config/UltronCommonConfig.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
32 changes: 32 additions & 0 deletions
32
ultron-common/src/commonMain/kotlin/com/atiurin/ultron/core/test/TestMethod.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,32 @@ | ||
| package com.atiurin.ultron.core.test | ||
|
|
||
| import com.atiurin.ultron.core.config.UltronCommonConfig | ||
| import com.atiurin.ultron.core.test.context.UltronTestContext | ||
|
|
||
| class TestMethod(testContext: UltronTestContext) { | ||
| init { | ||
| UltronCommonConfig.testContext = testContext | ||
| } | ||
|
|
||
| private var beforeTest: TestMethod.() -> Unit = {} | ||
| private var afterTest: TestMethod.() -> Unit = {} | ||
| private var test: TestMethod.() -> Unit = {} | ||
|
|
||
| internal fun attack() { | ||
| beforeTest() | ||
| test() | ||
| afterTest() | ||
| } | ||
|
|
||
| fun before(block: TestMethod.() -> Unit) = apply { | ||
| beforeTest = block | ||
| } | ||
|
|
||
| fun after(block: TestMethod.() -> Unit) = apply { | ||
| afterTest = block | ||
| } | ||
|
|
||
| fun go(block: TestMethod.() -> Unit) = apply { | ||
| test = block | ||
| } | ||
| } |
86 changes: 86 additions & 0 deletions
86
ultron-common/src/commonMain/kotlin/com/atiurin/ultron/core/test/UltronTest.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,86 @@ | ||
| package com.atiurin.ultron.core.test | ||
|
|
||
| import com.atiurin.ultron.annotations.ExperimentalUltronApi | ||
| import com.atiurin.ultron.core.test.context.DefaultUltronTestContextProvider | ||
| import com.atiurin.ultron.core.test.context.UltronTestContextProvider | ||
| import com.atiurin.ultron.exceptions.UltronException | ||
|
|
||
| /** | ||
| * Base class for tests in the Ultron framework. Provides mechanisms for managing test context, | ||
| * common pre-test and post-test actions, and handling test lifecycle events. | ||
| * | ||
| * @param testContextProvider Provides the context for the test. Defaults to [DefaultUltronTestContextProvider]. | ||
| */ | ||
| open class UltronTest( | ||
| private val testContextProvider: UltronTestContextProvider = DefaultUltronTestContextProvider() | ||
| ) { | ||
| companion object { | ||
| /** | ||
| * A map to track whether `beforeAllTests` has been executed for a given class name. | ||
| */ | ||
| private val beforeAllTestsExecutionMap: MutableMap<String, Boolean> = mutableMapOf() | ||
| } | ||
|
|
||
| /** | ||
| * The fully qualified name of the current test class. | ||
| * | ||
| * @throws UltronException if the test class is anonymous. | ||
| */ | ||
| private val className = this::class.qualifiedName | ||
| ?: throw UltronException("Don't use anonymous class for UltronTest") | ||
|
|
||
| /** | ||
| * Function to be executed once before all tests in the class. | ||
| * Can be overridden in subclasses. | ||
| */ | ||
| @ExperimentalUltronApi | ||
| open val beforeFirstTest: () -> Unit = {} | ||
|
|
||
| /** | ||
| * Function to be executed before each test. | ||
| * Can be overridden in subclasses. | ||
| */ | ||
| open val beforeTest: () -> Unit = {} | ||
|
|
||
| /** | ||
| * Function to be executed after each test. | ||
| * Can be overridden in subclasses. | ||
| */ | ||
| open val afterTest: () -> Unit = {} | ||
|
|
||
| /** | ||
| * Executes a test with the provided configuration. | ||
| * | ||
| * @param suppressCommonBefore If `true`, the `beforeTest` function will not be executed. Defaults to `false`. | ||
| * @param suppressCommonAfter If `true`, the `afterTest` function will not be executed. Defaults to `false`. | ||
| * @param configureTestBlock The block of test logic to execute. Implemented as an extension of [TestMethod]. | ||
| */ | ||
| @OptIn(ExperimentalUltronApi::class) | ||
| fun test( | ||
| suppressCommonBefore: Boolean = false, | ||
| suppressCommonAfter: Boolean = false, | ||
| configureTestBlock: TestMethod.() -> Unit | ||
| ) { | ||
| TestMethod(testContextProvider.provide()).apply { | ||
| // Ensure `beforeAllTests` is executed only once per class | ||
| if (beforeAllTestsExecutionMap[className] != true) { | ||
| beforeFirstTest() | ||
| beforeAllTestsExecutionMap[className] = true | ||
| } | ||
|
|
||
| // Execute common `beforeTest` logic if not suppressed | ||
| if (!suppressCommonBefore) { | ||
| beforeTest() | ||
| } | ||
|
|
||
| // Configure and execute the test block | ||
| configureTestBlock() | ||
| attack() | ||
|
|
||
| // Execute common `afterTest` logic if not suppressed | ||
| if (!suppressCommonAfter) { | ||
| afterTest() | ||
| } | ||
| } | ||
| } | ||
| } |
15 changes: 15 additions & 0 deletions
15
...on/src/commonMain/kotlin/com/atiurin/ultron/core/test/context/DefaultUltronTestContext.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,15 @@ | ||
| package com.atiurin.ultron.core.test.context | ||
|
|
||
| import com.atiurin.ultron.core.common.resultanalyzer.DefaultSoftAssertionOperationResultAnalyzer | ||
| import com.atiurin.ultron.core.common.resultanalyzer.OperationResultAnalyzer | ||
|
|
||
| open class DefaultUltronTestContext : UltronTestContext { | ||
| override var softAssertion: Boolean = false | ||
| override val softAnalyzer = DefaultSoftAssertionOperationResultAnalyzer() | ||
|
|
||
| override fun wrapAnalyzerIfSoftAssertion(analyzer: OperationResultAnalyzer): OperationResultAnalyzer { | ||
| return if (softAssertion) softAnalyzer.apply { | ||
| originalAnalyzer = analyzer | ||
| } else analyzer | ||
| } | ||
| } |
7 changes: 7 additions & 0 deletions
7
...ommonMain/kotlin/com/atiurin/ultron/core/test/context/DefaultUltronTestContextProvider.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,7 @@ | ||
| package com.atiurin.ultron.core.test.context | ||
|
|
||
| open class DefaultUltronTestContextProvider : UltronTestContextProvider { | ||
| override fun provide(): UltronTestContext { | ||
| return DefaultUltronTestContext() | ||
| } | ||
| } |
11 changes: 11 additions & 0 deletions
11
...on-common/src/commonMain/kotlin/com/atiurin/ultron/core/test/context/UltronTestContext.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,11 @@ | ||
| package com.atiurin.ultron.core.test.context | ||
|
|
||
| import com.atiurin.ultron.core.common.resultanalyzer.OperationResultAnalyzer | ||
| import com.atiurin.ultron.core.common.resultanalyzer.SoftAssertionOperationResultAnalyzer | ||
|
|
||
| interface UltronTestContext { | ||
| var softAssertion: Boolean | ||
| val softAnalyzer: SoftAssertionOperationResultAnalyzer | ||
|
|
||
| fun wrapAnalyzerIfSoftAssertion(analyzer: OperationResultAnalyzer): OperationResultAnalyzer | ||
| } |
5 changes: 5 additions & 0 deletions
5
...n/src/commonMain/kotlin/com/atiurin/ultron/core/test/context/UltronTestContextProvider.kt
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,5 @@ | ||
| package com.atiurin.ultron.core.test.context | ||
|
|
||
| interface UltronTestContextProvider { | ||
| fun provide(): UltronTestContext | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters