diff --git a/utbot-gradle/build.gradle b/utbot-gradle/build.gradle index b115420101..fcd781795e 100644 --- a/utbot-gradle/build.gradle +++ b/utbot-gradle/build.gradle @@ -87,7 +87,7 @@ pluginBundle { gradlePlugin { plugins { sarifReportPlugin { - version = '1.0.0-alpha-9' // last published version + version = '1.0.0-alpha' // last published version id = 'org.utbot.gradle.plugin' displayName = 'UnitTestBot gradle plugin' description = 'The gradle plugin for generating tests and creating SARIF reports based on UnitTestBot' diff --git a/utbot-gradle/docs/utbot-gradle.md b/utbot-gradle/docs/utbot-gradle.md index 819bb6f71a..9a66118212 100644 --- a/utbot-gradle/docs/utbot-gradle.md +++ b/utbot-gradle/docs/utbot-gradle.md @@ -69,6 +69,25 @@ __Kotlin DSL:__ } ``` +Also, you can configure the task using `-P=` syntax. + +For example, +```Kotlin +generateTestsAndSarifReport + -PtargetClasses='[com.abc.Main, com.qwerty.Util]' + -PprojectRoot='C:/.../SomeDirectory' + -PgeneratedTestsRelativeRoot='build/generated/test' + -PsarifReportsRelativeRoot='build/generated/sarif' + -PtestFramework=junit5 + -PmockFramework=mockito + -PgenerationTimeout=60000 + -PcodegenLanguage=java + -PmockStrategy='other-packages' + -PstaticsMocking='mock-statics' + -PforceStaticMocking=force + -PclassesToMockAlways='[org.slf4j.Logger, java.util.Random]' +``` + **Note:** All configuration fields have default values, so there is no need to configure the plugin if you don't want to. **Description of fields:** diff --git a/utbot-gradle/src/main/kotlin/org/utbot/gradle/plugin/GenerateTestsAndSarifReportTask.kt b/utbot-gradle/src/main/kotlin/org/utbot/gradle/plugin/GenerateTestsAndSarifReportTask.kt index 4d0259ed5f..44242d9606 100644 --- a/utbot-gradle/src/main/kotlin/org/utbot/gradle/plugin/GenerateTestsAndSarifReportTask.kt +++ b/utbot-gradle/src/main/kotlin/org/utbot/gradle/plugin/GenerateTestsAndSarifReportTask.kt @@ -34,6 +34,8 @@ open class GenerateTestsAndSarifReportTask @Inject constructor( */ @TaskAction fun generateTestsAndSarifReport() { + // the user specifies the parameters using "-Pname=value" + sarifProperties.taskParameters = project.gradle.startParameter.projectProperties val rootGradleProject = try { GradleProjectWrapper(project, sarifProperties) } catch (t: Throwable) { diff --git a/utbot-gradle/src/main/kotlin/org/utbot/gradle/plugin/extension/SarifGradleExtensionProvider.kt b/utbot-gradle/src/main/kotlin/org/utbot/gradle/plugin/extension/SarifGradleExtensionProvider.kt index 67c8e18d89..0784115db8 100644 --- a/utbot-gradle/src/main/kotlin/org/utbot/gradle/plugin/extension/SarifGradleExtensionProvider.kt +++ b/utbot-gradle/src/main/kotlin/org/utbot/gradle/plugin/extension/SarifGradleExtensionProvider.kt @@ -15,70 +15,106 @@ import java.io.File /** * Provides all [SarifGradleExtension] fields in a convenient form: * Defines default values and a transform function for these fields. + * Takes the fields from the [taskParameters] if they are available there, + * otherwise takes them from the [extension]. */ class SarifGradleExtensionProvider( private val project: Project, - private val extension: SarifGradleExtension + private val extension: SarifGradleExtension, + var taskParameters: Map = mapOf() ) : SarifExtensionProvider { override val targetClasses: List - get() = extension.targetClasses - .getOrElse(listOf()) + get() = taskParameters["targetClasses"]?.transformKeywordAll()?.parseToList() + ?: extension.targetClasses.orNull + ?: listOf() override val projectRoot: File - get() = extension.projectRoot.orNull + get() = (taskParameters["projectRoot"] ?: extension.projectRoot.orNull) ?.toPath()?.toFile() ?: project.projectDir override val generatedTestsRelativeRoot: String - get() = extension.generatedTestsRelativeRoot.orNull + get() = taskParameters["generatedTestsRelativeRoot"] + ?: extension.generatedTestsRelativeRoot.orNull ?: "build/generated/test" override val sarifReportsRelativeRoot: String - get() = extension.sarifReportsRelativeRoot.orNull + get() = taskParameters["sarifReportsRelativeRoot"] + ?: extension.sarifReportsRelativeRoot.orNull ?: "build/generated/sarif" + // We don't get this field from `taskParameters` because marking the directory + // as a test source root is possible while the gradle project is reloading, + // but `taskParameters` become available only when the user runs the gradle task + // `generateTestsAndSarifReport` (that is, after a reloading). override val markGeneratedTestsDirectoryAsTestSourcesRoot: Boolean get() = extension.markGeneratedTestsDirectoryAsTestSourcesRoot.orNull ?: true override val testFramework: TestFramework - get() = extension.testFramework - .map(::testFrameworkParse) - .getOrElse(TestFramework.defaultItem) + get() = (taskParameters["testFramework"] ?: extension.testFramework.orNull) + ?.let(::testFrameworkParse) + ?: TestFramework.defaultItem override val mockFramework: MockFramework - get() = extension.mockFramework - .map(::mockFrameworkParse) - .getOrElse(MockFramework.defaultItem) + get() = (taskParameters["mockFramework"] ?: extension.mockFramework.orNull) + ?.let(::mockFrameworkParse) + ?: MockFramework.defaultItem override val generationTimeout: Long - get() = extension.generationTimeout - .map(::generationTimeoutParse) - .getOrElse(60 * 1000L) // 60 seconds + get() = (taskParameters["generationTimeout"]?.toLongOrNull() ?: extension.generationTimeout.orNull) + ?.let(::generationTimeoutParse) + ?: (60 * 1000L) // 60 seconds override val codegenLanguage: CodegenLanguage - get() = extension.codegenLanguage - .map(::codegenLanguageParse) - .getOrElse(CodegenLanguage.defaultItem) + get() = (taskParameters["codegenLanguage"] ?: extension.codegenLanguage.orNull) + ?.let(::codegenLanguageParse) + ?: CodegenLanguage.defaultItem override val mockStrategy: MockStrategyApi - get() = extension.mockStrategy - .map(::mockStrategyParse) - .getOrElse(MockStrategyApi.defaultItem) + get() = (taskParameters["mockStrategy"] ?: extension.mockStrategy.orNull) + ?.let(::mockStrategyParse) + ?: MockStrategyApi.defaultItem override val staticsMocking: StaticsMocking - get() = extension.staticsMocking - .map(::staticsMockingParse) - .getOrElse(StaticsMocking.defaultItem) + get() = (taskParameters["staticsMocking"] ?: extension.staticsMocking.orNull) + ?.let(::staticsMockingParse) + ?: StaticsMocking.defaultItem override val forceStaticMocking: ForceStaticMocking - get() = extension.forceStaticMocking - .map(::forceStaticMockingParse) - .getOrElse(ForceStaticMocking.defaultItem) + get() = (taskParameters["forceStaticMocking"] ?: extension.forceStaticMocking.orNull) + ?.let(::forceStaticMockingParse) + ?: ForceStaticMocking.defaultItem override val classesToMockAlways: Set get() = classesToMockAlwaysParse( - extension.classesToMockAlways.getOrElse(listOf()) + specifiedClasses = taskParameters["classesToMockAlways"]?.parseToList() + ?: extension.classesToMockAlways.orNull + ?: listOf() ) + + /** + * SARIF report file containing static analysis information about all [targetClasses]. + */ + val mergedSarifReportFileName: String? + get() = taskParameters["mergedSarifReportFileName"] + + // internal + + /** + * Keyword "all" is the same as "[]" for [targetClasses], but more user-friendly. + */ + private fun String.transformKeywordAll(): String = + if (this == "all") "[]" else this + + /** + * Example: "[A, B, C]" -> ["A", "B", "C"]. + */ + private fun String.parseToList() = + this.removePrefix("[") + .removeSuffix("]") + .split(",") + .map { it.trim() } + .filter { it != "" } } diff --git a/utbot-gradle/src/main/kotlin/org/utbot/gradle/plugin/wrappers/GradleProjectWrapper.kt b/utbot-gradle/src/main/kotlin/org/utbot/gradle/plugin/wrappers/GradleProjectWrapper.kt index 2a7c7748f1..ad40f4dcd0 100644 --- a/utbot-gradle/src/main/kotlin/org/utbot/gradle/plugin/wrappers/GradleProjectWrapper.kt +++ b/utbot-gradle/src/main/kotlin/org/utbot/gradle/plugin/wrappers/GradleProjectWrapper.kt @@ -54,12 +54,12 @@ class GradleProjectWrapper( } /** - * SARIF report file containing results from all others reports from the [project]. + * SARIF report file containing results from all other reports from the [project]. */ val sarifReportFile: File by lazy { Paths.get( generatedSarifDirectory.path, - "${project.name}Report.sarif" + sarifProperties.mergedSarifReportFileName ?: "${project.name}Report.sarif" ).toFile().apply { createNewFileWithParentDirectories() } diff --git a/utbot-gradle/src/test/kotlin/org/utbot/gradle/plugin/extension/SarifGradleExtensionProviderTest.kt b/utbot-gradle/src/test/kotlin/org/utbot/gradle/plugin/extension/SarifGradleExtensionProviderTest.kt index 0bc54f1c3e..d52610a6b6 100644 --- a/utbot-gradle/src/test/kotlin/org/utbot/gradle/plugin/extension/SarifGradleExtensionProviderTest.kt +++ b/utbot-gradle/src/test/kotlin/org/utbot/gradle/plugin/extension/SarifGradleExtensionProviderTest.kt @@ -23,19 +23,46 @@ class SarifGradleExtensionProviderTest { inner class TargetClassesTest { @Test fun `should be an empty list by default`() { - setTargetClasses(null) + setTargetClassesInExtension(null) assertEquals(listOf(), extensionProvider.targetClasses) } @Test fun `should be provided from the extension`() { val targetClasses = listOf("com.abc.Main") - setTargetClasses(targetClasses) + setTargetClassesInExtension(targetClasses) assertEquals(targetClasses, extensionProvider.targetClasses) } - private fun setTargetClasses(value: List?) = + @Test + fun `should be provided from the task parameters`() { + val targetClasses = listOf("com.abc.Main") + setTargetClassesInTaskParameters(targetClasses) + assertEquals(targetClasses, extensionProvider.targetClasses) + } + + @Test + fun `should be provided from the task parameters, not from the extension`() { + val targetClasses = listOf("com.abc.Main") + val anotherTargetClasses = listOf("com.abc.Another") + setTargetClassesInTaskParameters(targetClasses) + setTargetClassesInExtension(anotherTargetClasses) + assertEquals(targetClasses, extensionProvider.targetClasses) + } + + @Test + fun `should be resolved from the keyword 'all'`() { + extensionProvider.taskParameters = mapOf("targetClasses" to "all") + assertEquals(listOf(), extensionProvider.targetClasses) + } + + private fun setTargetClassesInExtension(value: List?) { Mockito.`when`(extensionMock.targetClasses).thenReturn(createListProperty(value)) + } + + private fun setTargetClassesInTaskParameters(value: List) { + extensionProvider.taskParameters = mapOf("targetClasses" to value.joinToString(",", "[", "]")) + } } @Nested @@ -43,19 +70,40 @@ class SarifGradleExtensionProviderTest { inner class ProjectRootTest { @Test fun `should be projectDir by default`() { - setProjectRoot(null) + setProjectRootInExtension(null) assertEquals(project.projectDir, extensionProvider.projectRoot) } @Test fun `should be provided from the extension`() { val projectRoot = "some/dir/" - setProjectRoot(projectRoot) + setProjectRootInExtension(projectRoot) assertEquals(File(projectRoot), extensionProvider.projectRoot) } - private fun setProjectRoot(value: String?) = + @Test + fun `should be provided from the task parameters`() { + val projectRoot = "some/directory/" + setProjectRootInTaskParameters(projectRoot) + assertEquals(File(projectRoot), extensionProvider.projectRoot) + } + + @Test + fun `should be provided from the task parameters, not from the extension`() { + val projectRoot = "some/dir/" + val anotherProjectRoot = "another/dir/" + setProjectRootInTaskParameters(projectRoot) + setProjectRootInExtension(anotherProjectRoot) + assertEquals(File(projectRoot), extensionProvider.projectRoot) + } + + private fun setProjectRootInExtension(value: String?) { Mockito.`when`(extensionMock.projectRoot).thenReturn(createStringProperty(value)) + } + + private fun setProjectRootInTaskParameters(value: String) { + extensionProvider.taskParameters = mapOf("projectRoot" to value) + } } @Nested @@ -64,19 +112,40 @@ class SarifGradleExtensionProviderTest { @Test fun `should be build generated test by default`() { val testsRootExpected = "build/generated/test" - setGeneratedTestsRelativeRoot(null) + setGeneratedTestsRelativeRootInExtension(null) assertEquals(testsRootExpected.toPath(), extensionProvider.generatedTestsRelativeRoot.toPath()) } @Test fun `should be provided from the extension`() { val testsRoot = "some/dir/" - setGeneratedTestsRelativeRoot(testsRoot) + setGeneratedTestsRelativeRootInExtension(testsRoot) + assertEquals(testsRoot.toPath(), extensionProvider.generatedTestsRelativeRoot.toPath()) + } + + @Test + fun `should be provided from the task parameters`() { + val testsRoot = "some/directory/" + setGeneratedTestsRelativeRootInTaskParameters(testsRoot) assertEquals(testsRoot.toPath(), extensionProvider.generatedTestsRelativeRoot.toPath()) } - private fun setGeneratedTestsRelativeRoot(value: String?) = + @Test + fun `should be provided from the task parameters, not from the extension`() { + val testsRoot = "some/dir/" + val anotherTestsRoot = "another/dir/" + setGeneratedTestsRelativeRootInTaskParameters(testsRoot) + setGeneratedTestsRelativeRootInExtension(anotherTestsRoot) + assertEquals(testsRoot.toPath(), extensionProvider.generatedTestsRelativeRoot.toPath()) + } + + private fun setGeneratedTestsRelativeRootInExtension(value: String?) { Mockito.`when`(extensionMock.generatedTestsRelativeRoot).thenReturn(createStringProperty(value)) + } + + private fun setGeneratedTestsRelativeRootInTaskParameters(value: String) { + extensionProvider.taskParameters = mapOf("generatedTestsRelativeRoot" to value) + } } @Nested @@ -84,7 +153,7 @@ class SarifGradleExtensionProviderTest { inner class SarifReportsRelativeRootTest { @Test fun `should be build generated sarif by default`() { - setSarifReportsRelativeRoot(null) + setSarifReportsRelativeRootInExtension(null) val sarifRoot = "build/generated/sarif" assertEquals(sarifRoot.toPath(), extensionProvider.sarifReportsRelativeRoot.toPath()) } @@ -92,12 +161,33 @@ class SarifGradleExtensionProviderTest { @Test fun `should be provided from the extension`() { val sarifRoot = "some/dir/" - setSarifReportsRelativeRoot(sarifRoot) + setSarifReportsRelativeRootInExtension(sarifRoot) + assertEquals(sarifRoot.toPath(), extensionProvider.sarifReportsRelativeRoot.toPath()) + } + + @Test + fun `should be provided from the task parameters`() { + val sarifRoot = "some/directory/" + setSarifReportsRelativeRootInTaskParameters(sarifRoot) + assertEquals(sarifRoot.toPath(), extensionProvider.sarifReportsRelativeRoot.toPath()) + } + + @Test + fun `should be provided from the task parameters, not from the extension`() { + val sarifRoot = "some/dir/" + val anotherSarifRoot = "another/dir/" + setSarifReportsRelativeRootInTaskParameters(sarifRoot) + setSarifReportsRelativeRootInExtension(anotherSarifRoot) assertEquals(sarifRoot.toPath(), extensionProvider.sarifReportsRelativeRoot.toPath()) } - private fun setSarifReportsRelativeRoot(value: String?) = + private fun setSarifReportsRelativeRootInExtension(value: String?) { Mockito.`when`(extensionMock.sarifReportsRelativeRoot).thenReturn(createStringProperty(value)) + } + + private fun setSarifReportsRelativeRootInTaskParameters(value: String) { + extensionProvider.taskParameters = mapOf("sarifReportsRelativeRoot" to value) + } } @Nested @@ -115,8 +205,10 @@ class SarifGradleExtensionProviderTest { assertEquals(false, extensionProvider.markGeneratedTestsDirectoryAsTestSourcesRoot) } - private fun setMark(value: Boolean?) = - Mockito.`when`(extensionMock.markGeneratedTestsDirectoryAsTestSourcesRoot).thenReturn(createBooleanProperty(value)) + private fun setMark(value: Boolean?) { + Mockito.`when`(extensionMock.markGeneratedTestsDirectoryAsTestSourcesRoot) + .thenReturn(createBooleanProperty(value)) + } } @Nested @@ -124,38 +216,56 @@ class SarifGradleExtensionProviderTest { inner class TestFrameworkTest { @Test fun `should be TestFramework defaultItem by default`() { - setTestFramework(null) + setTestFrameworkInExtension(null) assertEquals(TestFramework.defaultItem, extensionProvider.testFramework) } @Test fun `should be equal to Junit4`() { - setTestFramework("junit4") + setTestFrameworkInExtension("junit4") assertEquals(Junit4, extensionProvider.testFramework) } @Test fun `should be equal to Junit5`() { - setTestFramework("junit5") + setTestFrameworkInExtension("junit5") assertEquals(Junit5, extensionProvider.testFramework) } @Test fun `should be equal to TestNg`() { - setTestFramework("testng") + setTestFrameworkInExtension("testng") assertEquals(TestNg, extensionProvider.testFramework) } @Test fun `should fail on unknown test framework`() { - setTestFramework("unknown") + setTestFrameworkInExtension("unknown") assertThrows { extensionProvider.testFramework } } - private fun setTestFramework(value: String?) = + @Test + fun `should be provided from the task parameters`() { + setTestFrameworkInTaskParameters("junit4") + assertEquals(Junit4, extensionProvider.testFramework) + } + + @Test + fun `should be provided from the task parameters, not from the extension`() { + setTestFrameworkInTaskParameters("testng") + setTestFrameworkInExtension("junit5") + assertEquals(TestNg, extensionProvider.testFramework) + } + + private fun setTestFrameworkInExtension(value: String?) { Mockito.`when`(extensionMock.testFramework).thenReturn(createStringProperty(value)) + } + + private fun setTestFrameworkInTaskParameters(value: String) { + extensionProvider.taskParameters = mapOf("testFramework" to value) + } } @Nested @@ -163,26 +273,46 @@ class SarifGradleExtensionProviderTest { inner class MockFrameworkTest { @Test fun `should be MockFramework defaultItem by default`() { - setMockFramework(null) + setMockFrameworkInExtension(null) assertEquals(MockFramework.defaultItem, extensionProvider.mockFramework) } @Test fun `should be equal to MOCKITO`() { - setMockFramework("mockito") + setMockFrameworkInExtension("mockito") assertEquals(MockFramework.MOCKITO, extensionProvider.mockFramework) } @Test fun `should fail on unknown mock framework`() { - setMockFramework("unknown") + setMockFrameworkInExtension("unknown") + assertThrows { + extensionProvider.mockFramework + } + } + + @Test + fun `should be provided from the task parameters`() { + setMockFrameworkInTaskParameters("mockito") + assertEquals(MockFramework.MOCKITO, extensionProvider.mockFramework) + } + + @Test + fun `should be provided from the task parameters, not from the extension`() { + setMockFrameworkInTaskParameters("unknown") + setMockFrameworkInExtension("mockito") assertThrows { extensionProvider.mockFramework } } - private fun setMockFramework(value: String?) = + private fun setMockFrameworkInExtension(value: String?) { Mockito.`when`(extensionMock.mockFramework).thenReturn(createStringProperty(value)) + } + + private fun setMockFrameworkInTaskParameters(value: String) { + extensionProvider.taskParameters = mapOf("mockFramework" to value) + } } @Nested @@ -190,26 +320,44 @@ class SarifGradleExtensionProviderTest { inner class GenerationTimeoutTest { @Test fun `should be 60 seconds by default`() { - setGenerationTimeout(null) + setGenerationTimeoutInExtension(null) assertEquals(60 * 1000L, extensionProvider.generationTimeout) } @Test fun `should be provided from the extension`() { - setGenerationTimeout(100L) + setGenerationTimeoutInExtension(100L) assertEquals(100L, extensionProvider.generationTimeout) } + @Test + fun `should be provided from the task parameters`() { + setGenerationTimeoutInTaskParameters("100") + assertEquals(100L, extensionProvider.generationTimeout) + } + + @Test + fun `should be provided from the task parameters, not from the extension`() { + setGenerationTimeoutInTaskParameters("999") + setGenerationTimeoutInExtension(100L) + assertEquals(999L, extensionProvider.generationTimeout) + } + @Test fun `should fail on negative timeout`() { - setGenerationTimeout(-1) + setGenerationTimeoutInExtension(-1) assertThrows { extensionProvider.generationTimeout } } - private fun setGenerationTimeout(value: Long?) = + private fun setGenerationTimeoutInExtension(value: Long?) { Mockito.`when`(extensionMock.generationTimeout).thenReturn(createLongProperty(value)) + } + + private fun setGenerationTimeoutInTaskParameters(value: String) { + extensionProvider.taskParameters = mapOf("generationTimeout" to value) + } } @Nested @@ -217,32 +365,50 @@ class SarifGradleExtensionProviderTest { inner class CodegenLanguageTest { @Test fun `should be CodegenLanguage defaultItem by default`() { - setCodegenLanguage(null) + setCodegenLanguageInExtension(null) assertEquals(CodegenLanguage.defaultItem, extensionProvider.codegenLanguage) } @Test fun `should be equal to JAVA`() { - setCodegenLanguage("java") + setCodegenLanguageInExtension("java") assertEquals(CodegenLanguage.JAVA, extensionProvider.codegenLanguage) } @Test fun `should be equal to KOTLIN`() { - setCodegenLanguage("kotlin") + setCodegenLanguageInExtension("kotlin") assertEquals(CodegenLanguage.KOTLIN, extensionProvider.codegenLanguage) } @Test fun `should fail on unknown codegen language`() { - setCodegenLanguage("unknown") + setCodegenLanguageInExtension("unknown") assertThrows { extensionProvider.codegenLanguage } } - private fun setCodegenLanguage(value: String?) = + @Test + fun `should be provided from the task parameters`() { + setCodegenLanguageInTaskParameters("kotlin") + assertEquals(CodegenLanguage.KOTLIN, extensionProvider.codegenLanguage) + } + + @Test + fun `should be provided from the task parameters, not from the extension`() { + setCodegenLanguageInTaskParameters("java") + setCodegenLanguageInExtension("kotlin") + assertEquals(CodegenLanguage.JAVA, extensionProvider.codegenLanguage) + } + + private fun setCodegenLanguageInExtension(value: String?) { Mockito.`when`(extensionMock.codegenLanguage).thenReturn(createStringProperty(value)) + } + + private fun setCodegenLanguageInTaskParameters(value: String) { + extensionProvider.taskParameters = mapOf("codegenLanguage" to value) + } } @Nested @@ -250,38 +416,56 @@ class SarifGradleExtensionProviderTest { inner class MockStrategyTest { @Test fun `should be MockStrategyApi defaultItem by default`() { - setMockStrategy(null) + setMockStrategyInExtension(null) assertEquals(MockStrategyApi.defaultItem, extensionProvider.mockStrategy) } @Test fun `should be equal to NO_MOCKS`() { - setMockStrategy("no-mocks") + setMockStrategyInExtension("no-mocks") assertEquals(MockStrategyApi.NO_MOCKS, extensionProvider.mockStrategy) } @Test fun `should be equal to OTHER_PACKAGES`() { - setMockStrategy("other-packages") + setMockStrategyInExtension("other-packages") assertEquals(MockStrategyApi.OTHER_PACKAGES, extensionProvider.mockStrategy) } @Test fun `should be equal to OTHER_CLASSES`() { - setMockStrategy("other-classes") + setMockStrategyInExtension("other-classes") assertEquals(MockStrategyApi.OTHER_CLASSES, extensionProvider.mockStrategy) } @Test fun `should fail on unknown mock strategy`() { - setMockStrategy("unknown") + setMockStrategyInExtension("unknown") assertThrows { extensionProvider.mockStrategy } } - private fun setMockStrategy(value: String?) = + @Test + fun `should be provided from the task parameters`() { + setMockStrategyInTaskParameters("no-mocks") + assertEquals(MockStrategyApi.NO_MOCKS, extensionProvider.mockStrategy) + } + + @Test + fun `should be provided from the task parameters, not from the extension`() { + setMockStrategyInTaskParameters("other-packages") + setMockStrategyInExtension("other-classes") + assertEquals(MockStrategyApi.OTHER_PACKAGES, extensionProvider.mockStrategy) + } + + private fun setMockStrategyInExtension(value: String?) { Mockito.`when`(extensionMock.mockStrategy).thenReturn(createStringProperty(value)) + } + + private fun setMockStrategyInTaskParameters(value: String) { + extensionProvider.taskParameters = mapOf("mockStrategy" to value) + } } @Nested @@ -289,32 +473,50 @@ class SarifGradleExtensionProviderTest { inner class StaticsMockingTest { @Test fun `should be StaticsMocking defaultItem by default`() { - setStaticsMocking(null) + setStaticsMockingInExtension(null) assertEquals(StaticsMocking.defaultItem, extensionProvider.staticsMocking) } @Test fun `should be equal to NoStaticMocking`() { - setStaticsMocking("do-not-mock-statics") + setStaticsMockingInExtension("do-not-mock-statics") assertEquals(NoStaticMocking, extensionProvider.staticsMocking) } @Test fun `should be equal to`() { - setStaticsMocking("mock-statics") + setStaticsMockingInExtension("mock-statics") assertEquals(MockitoStaticMocking, extensionProvider.staticsMocking) } @Test fun `should fail on unknown statics mocking`() { - setStaticsMocking("unknown") + setStaticsMockingInExtension("unknown") assertThrows { extensionProvider.staticsMocking } } - private fun setStaticsMocking(value: String?) = + @Test + fun `should be provided from the task parameters`() { + setStaticsMockingInTaskParameters("do-not-mock-statics") + assertEquals(NoStaticMocking, extensionProvider.staticsMocking) + } + + @Test + fun `should be provided from the task parameters, not from the extension`() { + setStaticsMockingInTaskParameters("mock-statics") + setStaticsMockingInExtension("do-not-mock-statics") + assertEquals(MockitoStaticMocking, extensionProvider.staticsMocking) + } + + private fun setStaticsMockingInExtension(value: String?) { Mockito.`when`(extensionMock.staticsMocking).thenReturn(createStringProperty(value)) + } + + private fun setStaticsMockingInTaskParameters(value: String) { + extensionProvider.taskParameters = mapOf("staticsMocking" to value) + } } @Nested @@ -322,32 +524,50 @@ class SarifGradleExtensionProviderTest { inner class ForceStaticMockingTest { @Test fun `should be ForceStaticMocking defaultItem by default`() { - setForceStaticMocking(null) + setForceStaticMockingInExtension(null) assertEquals(ForceStaticMocking.defaultItem, extensionProvider.forceStaticMocking) } @Test fun `should be equal to FORCE`() { - setForceStaticMocking("force") + setForceStaticMockingInExtension("force") assertEquals(ForceStaticMocking.FORCE, extensionProvider.forceStaticMocking) } @Test fun `should be equal to DO_NOT_FORCE`() { - setForceStaticMocking("do-not-force") + setForceStaticMockingInExtension("do-not-force") assertEquals(ForceStaticMocking.DO_NOT_FORCE, extensionProvider.forceStaticMocking) } @Test fun `should fail on unknown force static mocking`() { - setForceStaticMocking("unknown") + setForceStaticMockingInExtension("unknown") assertThrows { extensionProvider.forceStaticMocking } } - private fun setForceStaticMocking(value: String?) = + @Test + fun `should be provided from the task parameters`() { + setForceStaticMockingInTaskParameters("do-not-force") + assertEquals(ForceStaticMocking.DO_NOT_FORCE, extensionProvider.forceStaticMocking) + } + + @Test + fun `should be provided from the task parameters, not from the extension`() { + setForceStaticMockingInTaskParameters("force") + setForceStaticMockingInExtension("do-not-force") + assertEquals(ForceStaticMocking.FORCE, extensionProvider.forceStaticMocking) + } + + private fun setForceStaticMockingInExtension(value: String?) { Mockito.`when`(extensionMock.forceStaticMocking).thenReturn(createStringProperty(value)) + } + + private fun setForceStaticMockingInTaskParameters(value: String) { + extensionProvider.taskParameters = mapOf("forceStaticMocking" to value) + } } @Nested @@ -359,7 +579,7 @@ class SarifGradleExtensionProviderTest { @Test fun `should be defaultSuperClassesToMockAlwaysNames by default`() { - setClassesToMockAlways(null) + setClassesToMockAlwaysInExtension(null) assertEquals(defaultClasses, extensionProvider.classesToMockAlways) } @@ -367,12 +587,34 @@ class SarifGradleExtensionProviderTest { fun `should be provided from the extension`() { val classes = listOf("com.abc.Main") val expectedClasses = classes.map(::ClassId).toSet() + defaultClasses - setClassesToMockAlways(classes) + setClassesToMockAlwaysInExtension(classes) + assertEquals(expectedClasses, extensionProvider.classesToMockAlways) + } + + @Test + fun `should be provided from the task parameters`() { + val classes = listOf("com.abc.Main") + val expectedClasses = classes.map(::ClassId).toSet() + defaultClasses + setClassesToMockAlwaysInTaskParameters(classes) assertEquals(expectedClasses, extensionProvider.classesToMockAlways) } - private fun setClassesToMockAlways(value: List?) = + @Test + fun `should be provided from the task parameters, not from the extension`() { + val classes = listOf("com.abc.Main") + val anotherClasses = listOf("com.abc.Another") + val expectedClasses = classes.map(::ClassId).toSet() + defaultClasses + setClassesToMockAlwaysInTaskParameters(classes) + setClassesToMockAlwaysInExtension(anotherClasses) + assertEquals(expectedClasses, extensionProvider.classesToMockAlways) + } + + private fun setClassesToMockAlwaysInExtension(value: List?) = Mockito.`when`(extensionMock.classesToMockAlways).thenReturn(createListProperty(value)) + + private fun setClassesToMockAlwaysInTaskParameters(value: List) { + extensionProvider.taskParameters = mapOf("classesToMockAlways" to value.joinToString(",", "[", "]")) + } } // internal