From d753828d9641d4e1a9babbb6ed1e248cc4a209df Mon Sep 17 00:00:00 2001 From: Sergei Vorobyov Date: Wed, 28 May 2025 18:10:37 +0200 Subject: [PATCH] [TestFramework] cleanup: merge DependencyAssertions utilities GitOrigin-RevId: c084b1ae3afa72275003305afa9bf4b774655060 --- .../DependencyAssertions.kt | 28 -- .../moduleAssertion/DependencyAssertions.kt | 88 +++-- .../utils/module/DependencyAssertionTest.kt | 344 ++++++++++++++++++ .../utils/module/ModuleAssertionTestCase.kt | 19 + .../gradle-declarative-sync/BUILD.bazel | 1 + .../intellij.gradle.declarativeSync.tests.iml | 1 + .../testSources/GradleDeclarativeSyncTest.kt | 38 +- 7 files changed, 453 insertions(+), 66 deletions(-) delete mode 100644 platform/testFramework/src/com/intellij/platform/testFramework/assertion/dependencyAssertion/DependencyAssertions.kt create mode 100644 platform/testFramework/testSrc/com/intellij/testFramework/utils/module/DependencyAssertionTest.kt diff --git a/platform/testFramework/src/com/intellij/platform/testFramework/assertion/dependencyAssertion/DependencyAssertions.kt b/platform/testFramework/src/com/intellij/platform/testFramework/assertion/dependencyAssertion/DependencyAssertions.kt deleted file mode 100644 index 1caa4059fe95..000000000000 --- a/platform/testFramework/src/com/intellij/platform/testFramework/assertion/dependencyAssertion/DependencyAssertions.kt +++ /dev/null @@ -1,28 +0,0 @@ -// Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. -package com.intellij.platform.testFramework.assertion.dependencyAssertion - -import com.intellij.platform.testFramework.assertion.collectionAssertion.CollectionAssertions.assertEqualsUnordered -import com.intellij.platform.workspace.jps.entities.LibraryDependency -import com.intellij.platform.workspace.jps.entities.ModuleDependency -import com.intellij.platform.workspace.jps.entities.ModuleEntity -import com.intellij.platform.workspace.storage.EntityStorage -import com.intellij.platform.workspace.storage.entities -import org.junit.Assert.assertEquals -import org.junit.Assert.assertTrue - -object DependencyAssertions { - @JvmStatic - fun assertModuleLibDep(storage: EntityStorage, moduleName: String, depName: String) { - val modules = storage.entities().filter { it.name == moduleName }.toList() - assertEquals(1, modules.size) - assertTrue(modules[0].dependencies.filter { it is LibraryDependency }.map { (it as LibraryDependency).library.name }.contains(depName)) - } - - @JvmStatic - fun assertModuleModuleDeps(storage: EntityStorage, moduleName: String, vararg depNames: String) { - val modules = storage.entities().filter { it.name == moduleName }.toList() - assertEquals(1, modules.size) - val moduleDeps = modules[0].dependencies.filterIsInstance().map { it.module.name }.toList() - assertEqualsUnordered(depNames.toList(), moduleDeps) - } -} \ No newline at end of file diff --git a/platform/testFramework/src/com/intellij/platform/testFramework/assertion/moduleAssertion/DependencyAssertions.kt b/platform/testFramework/src/com/intellij/platform/testFramework/assertion/moduleAssertion/DependencyAssertions.kt index fa29e21a15ee..c7b39f99ae9c 100644 --- a/platform/testFramework/src/com/intellij/platform/testFramework/assertion/moduleAssertion/DependencyAssertions.kt +++ b/platform/testFramework/src/com/intellij/platform/testFramework/assertion/moduleAssertion/DependencyAssertions.kt @@ -1,48 +1,82 @@ // Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.platform.testFramework.assertion.moduleAssertion -import com.intellij.platform.testFramework.assertion.collectionAssertion.CollectionAssertions.assertEqualsUnordered +import com.intellij.platform.testFramework.assertion.collectionAssertion.CollectionAssertions import com.intellij.platform.workspace.jps.entities.* import org.junit.jupiter.api.Assertions object DependencyAssertions { - val INHERITED_SDK = InheritedSdkDependency::class.simpleName!! - val MODULE_SOURCE = ModuleSourceDependency::class.simpleName!! + val INHERITED_SDK: String = InheritedSdkDependency::class.simpleName!! + val MODULE_SOURCE: String = ModuleSourceDependency::class.simpleName!! + private val ModuleDependencyItem.dependencyName: String + get() = when (this) { + is ModuleSourceDependency -> MODULE_SOURCE + is InheritedSdkDependency -> INHERITED_SDK + is SdkDependency -> sdk.name + is LibraryDependency -> library.name + is ModuleDependency -> module.name + } + + @JvmStatic fun assertDependencies(module: ModuleEntity, vararg expectedNames: String) { assertDependencies(module, expectedNames.asList()) } + @JvmStatic + fun assertLibraryDependencies(module: ModuleEntity, vararg expectedNames: String) { + assertLibraryDependencies(module, expectedNames.asList()) + } + + @JvmStatic + fun assertLibraryDependencies(module: ModuleEntity, expectedNames: List) { + assertDependencies(module, LibraryDependency::class.java, expectedNames) + } + + @JvmStatic + fun assertModuleDependencies(module: ModuleEntity, vararg expectedNames: String) { + assertModuleDependencies(module, expectedNames.asList()) + } + + @JvmStatic + fun assertModuleDependencies(module: ModuleEntity, expectedNames: List) { + assertDependencies(module, ModuleDependency::class.java, expectedNames) + } + + @JvmStatic + fun assertLibraryDependency(module: ModuleEntity, name: String, assertion: (LibraryDependency) -> Unit = {}) { + assertDependency(module, LibraryDependency::class.java, name, assertion) + } + + @JvmStatic + fun assertModuleDependency(module: ModuleEntity, name: String, assertion: (ModuleDependency) -> Unit = {}) { + assertDependency(module, ModuleDependency::class.java, name, assertion) + } + + @JvmStatic fun assertDependencies(module: ModuleEntity, expectedNames: List) { - val actualNames = module.dependencies.map { dependency -> - when (dependency) { - InheritedSdkDependency -> INHERITED_SDK - ModuleSourceDependency -> MODULE_SOURCE - is LibraryDependency -> dependency.library.name - is ModuleDependency -> dependency.module.name - is SdkDependency -> dependency.sdk.name - } - } - assertEqualsUnordered(expectedNames, actualNames) - } - - fun assertLibraryDependency(module: ModuleEntity, name: String, assertion: (LibraryDependency) -> Unit) { - module.dependencies.filterIsInstance() - .find { it.library.name == name } - .let { dependency -> - Assertions.assertNotNull(dependency, "Cannot find '$name' library dependency in '${module.name}' module") - Assertions.assertEquals(name, dependency!!.library.name) - assertion(dependency) + module.dependencies + .map { it.dependencyName } + .let { actualNames -> + CollectionAssertions.assertEqualsUnordered(expectedNames, actualNames) } } - fun assertModuleDependency(module: ModuleEntity, name: String, assertion: (ModuleDependency) -> Unit) { - module.dependencies.filterIsInstance() - .find { it.module.name == name } + private fun assertDependencies(module: ModuleEntity, type: Class, expectedNames: List) { + module.dependencies.filterIsInstance(type) + .map { it.dependencyName } + .let { actualNames -> + CollectionAssertions.assertEqualsUnordered(expectedNames, actualNames) + } + } + + private fun assertDependency(module: ModuleEntity, type: Class, name: String, assertion: (T) -> Unit = {}) { + module.dependencies.filterIsInstance(type) + .find { it.dependencyName == name } .let { dependency -> - Assertions.assertNotNull(dependency, "Cannot find '$name' module dependency in '${module.name}' module") - Assertions.assertEquals(name, dependency!!.module.name) + Assertions.assertNotNull(dependency, "Cannot find '$name' (${type.simpleName}) dependency in '${module.name}' module") + Assertions.assertEquals(name, dependency!!.dependencyName) assertion(dependency) } } diff --git a/platform/testFramework/testSrc/com/intellij/testFramework/utils/module/DependencyAssertionTest.kt b/platform/testFramework/testSrc/com/intellij/testFramework/utils/module/DependencyAssertionTest.kt new file mode 100644 index 000000000000..791da57d4d2f --- /dev/null +++ b/platform/testFramework/testSrc/com/intellij/testFramework/utils/module/DependencyAssertionTest.kt @@ -0,0 +1,344 @@ +// Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. +package com.intellij.testFramework.utils.module + +import com.intellij.platform.backend.workspace.workspaceModel +import com.intellij.platform.testFramework.assertion.moduleAssertion.DependencyAssertions +import com.intellij.platform.testFramework.assertion.moduleAssertion.ModuleAssertions +import kotlinx.coroutines.runBlocking +import org.junit.jupiter.api.Assertions +import org.junit.jupiter.api.Test + +class DependencyAssertionTest : ModuleAssertionTestCase() { + + @Test + fun `test DependencyAssertions#assertDependencies`() { + runBlocking { + project.workspaceModel.update { + addLibraryEntity("library1") + addLibraryEntity("library2") + addModuleEntity("project") { + addModuleDependency("project.module1") + addModuleDependency("project.module2") + addLibraryDependency("library1") + addLibraryDependency("library2") + } + addModuleEntity("project.module1") { + addModuleDependency("project.module2") + addLibraryDependency("library2") + } + addModuleEntity("project.module2") + } + ModuleAssertions.assertModuleEntity(project, "project") { module -> + + DependencyAssertions.assertDependencies(module, "project.module1", "project.module2", "library1", "library2") + + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertDependencies(module, emptyList()) + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertDependencies(module, "project.module1", "project.module2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertDependencies(module, "library1", "library2") + } + } + ModuleAssertions.assertModuleEntity(project, "project.module1") { module -> + + DependencyAssertions.assertDependencies(module, "project.module2", "library2") + + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertDependencies(module, emptyList()) + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertDependencies(module, "project.module2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertDependencies(module, "library2") + } + } + ModuleAssertions.assertModuleEntity(project, "project.module2") { module -> + + DependencyAssertions.assertDependencies(module, emptyList()) + + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertDependencies(module, "project.module1", "project.module2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertDependencies(module, "library1", "library2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertDependencies(module, "project.module1", "project.module2", "library1", "library2") + } + } + } + } + + @Test + fun `test DependencyAssertions#assertModuleDependencies`() { + runBlocking { + project.workspaceModel.update { + addLibraryEntity("library1") + addLibraryEntity("library2") + addModuleEntity("project") { + addModuleDependency("project.module1") + addModuleDependency("project.module2") + addLibraryDependency("library1") + addLibraryDependency("library2") + } + addModuleEntity("project.module1") { + addModuleDependency("project.module2") + addLibraryDependency("library2") + } + addModuleEntity("project.module2") + } + ModuleAssertions.assertModuleEntity(project, "project") { module -> + + DependencyAssertions.assertModuleDependencies(module, "project.module1", "project.module2") + + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependencies(module, emptyList()) + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependencies(module, "library1", "library2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependencies(module, "project.module1", "project.module2", "library1", "library2") + } + } + ModuleAssertions.assertModuleEntity(project, "project.module1") { module -> + + DependencyAssertions.assertModuleDependencies(module, "project.module2") + + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependencies(module, emptyList()) + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependencies(module, "library2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependencies(module, "library2", "project.module2") + } + } + ModuleAssertions.assertModuleEntity(project, "project.module2") { module -> + + DependencyAssertions.assertModuleDependencies(module, emptyList()) + + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependencies(module, "library1", "library2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependencies(module, "project.module1", "project.module2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependencies(module, "library1", "library2", "project.module1", "project.module2") + } + } + } + } + + @Test + fun `test DependencyAssertions#assertLibraryDependencies`() { + runBlocking { + project.workspaceModel.update { + addLibraryEntity("library1") + addLibraryEntity("library2") + addModuleEntity("project") { + addModuleDependency("project.module1") + addModuleDependency("project.module2") + addLibraryDependency("library1") + addLibraryDependency("library2") + } + addModuleEntity("project.module1") { + addModuleDependency("project.module2") + addLibraryDependency("library2") + } + addModuleEntity("project.module2") + } + ModuleAssertions.assertModuleEntity(project, "project") { module -> + + DependencyAssertions.assertLibraryDependencies(module, "library1", "library2") + + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependencies(module, emptyList()) + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependencies(module, "project.module1", "project.module2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependencies(module, "library1", "library2", "project.module1", "project.module2") + } + } + ModuleAssertions.assertModuleEntity(project, "project.module1") { module -> + + DependencyAssertions.assertLibraryDependencies(module, "library2") + + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependencies(module, emptyList()) + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependencies(module, "library1", "library2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependencies(module, "project.module2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependencies(module, "library2", "project.module2") + } + } + ModuleAssertions.assertModuleEntity(project, "project.module2") { module -> + + DependencyAssertions.assertLibraryDependencies(module, emptyList()) + + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependencies(module, "library1", "library2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependencies(module, "project.module1", "project.module2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependencies(module, "library1", "library2", "project.module1", "project.module2") + } + } + } + } + + @Test + fun `test DependencyAssertions#assertModuleDependency`() { + runBlocking { + project.workspaceModel.update { + addLibraryEntity("library1") + addLibraryEntity("library2") + addModuleEntity("project") { + addModuleDependency("project.module1") + addModuleDependency("project.module2") + addLibraryDependency("library1") + addLibraryDependency("library2") + } + addModuleEntity("project.module1") { + addModuleDependency("project.module2") + addLibraryDependency("library2") + } + addModuleEntity("project.module2") + } + ModuleAssertions.assertModuleEntity(project, "project") { module -> + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependency(module, "library1") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependency(module, "library2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "project") + } + + DependencyAssertions.assertModuleDependency(module, "project.module1") + + DependencyAssertions.assertModuleDependency(module, "project.module2") + } + ModuleAssertions.assertModuleEntity(project, "project.module1") { module -> + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependency(module, "library1") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependency(module, "library2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "project") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependency(module, "project.module1") + } + + DependencyAssertions.assertModuleDependency(module, "project.module2") + } + ModuleAssertions.assertModuleEntity(project, "project.module2") { module -> + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependency(module, "library1") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependency(module, "library2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "project") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependency(module, "project.module1") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertModuleDependency(module, "project.module2") + } + } + } + } + + @Test + fun `test DependencyAssertions#assertLibraryDependency`() { + runBlocking { + project.workspaceModel.update { + addLibraryEntity("library1") + addLibraryEntity("library2") + addModuleEntity("project") { + addModuleDependency("project.module1") + addModuleDependency("project.module2") + addLibraryDependency("library1") + addLibraryDependency("library2") + } + addModuleEntity("project.module1") { + addModuleDependency("project.module2") + addLibraryDependency("library2") + } + addModuleEntity("project.module2") + } + ModuleAssertions.assertModuleEntity(project, "project") { module -> + + DependencyAssertions.assertLibraryDependency(module, "library1") + + DependencyAssertions.assertLibraryDependency(module, "library2") + + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "project") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "project.module1") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "project.module2") + } + } + ModuleAssertions.assertModuleEntity(project, "project.module1") { module -> + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "library1") + } + + DependencyAssertions.assertLibraryDependency(module, "library2") + + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "project") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "project.module1") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "project.module2") + } + } + ModuleAssertions.assertModuleEntity(project, "project.module2") { module -> + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "library1") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "library2") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "project") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "project.module1") + } + Assertions.assertThrows(AssertionError::class.java) { + DependencyAssertions.assertLibraryDependency(module, "project.module2") + } + } + } + } +} \ No newline at end of file diff --git a/platform/testFramework/testSrc/com/intellij/testFramework/utils/module/ModuleAssertionTestCase.kt b/platform/testFramework/testSrc/com/intellij/testFramework/utils/module/ModuleAssertionTestCase.kt index 725f4bc60d84..2dec10040a68 100644 --- a/platform/testFramework/testSrc/com/intellij/testFramework/utils/module/ModuleAssertionTestCase.kt +++ b/platform/testFramework/testSrc/com/intellij/testFramework/utils/module/ModuleAssertionTestCase.kt @@ -4,7 +4,14 @@ package com.intellij.testFramework.utils.module import com.intellij.platform.backend.workspace.WorkspaceModel import com.intellij.platform.backend.workspace.workspaceModel import com.intellij.platform.workspace.jps.entities.ContentRootEntity +import com.intellij.platform.workspace.jps.entities.DependencyScope.COMPILE +import com.intellij.platform.workspace.jps.entities.LibraryDependency +import com.intellij.platform.workspace.jps.entities.LibraryEntity +import com.intellij.platform.workspace.jps.entities.LibraryId +import com.intellij.platform.workspace.jps.entities.LibraryTableId +import com.intellij.platform.workspace.jps.entities.ModuleDependency import com.intellij.platform.workspace.jps.entities.ModuleEntity +import com.intellij.platform.workspace.jps.entities.ModuleId import com.intellij.platform.workspace.jps.entities.SourceRootEntity import com.intellij.platform.workspace.jps.entities.SourceRootTypeId import com.intellij.platform.workspace.storage.MutableEntityStorage @@ -50,4 +57,16 @@ abstract class ModuleAssertionTestCase { val sourceRoot = sourceRootPath.toVirtualFileUrl(virtualFileUrlManager) sourceRoots += SourceRootEntity(sourceRoot, typeId, NonPersistentEntitySource) } + + fun MutableEntityStorage.addLibraryEntity(libraryName: String) { + addEntity(LibraryEntity(libraryName, LibraryTableId.ProjectLibraryTableId, emptyList(), NonPersistentEntitySource)) + } + + fun ModuleEntity.Builder.addLibraryDependency(libraryName: String) { + dependencies += LibraryDependency(LibraryId(libraryName, LibraryTableId.ProjectLibraryTableId), exported = false, COMPILE) + } + + fun ModuleEntity.Builder.addModuleDependency(moduleName: String) { + dependencies += ModuleDependency(ModuleId(moduleName), exported = false, COMPILE, productionOnTest = false) + } } \ No newline at end of file diff --git a/plugins/gradle/gradle-declarative-sync/BUILD.bazel b/plugins/gradle/gradle-declarative-sync/BUILD.bazel index 98fd7a8f3f91..d722dfccf4c6 100644 --- a/plugins/gradle/gradle-declarative-sync/BUILD.bazel +++ b/plugins/gradle/gradle-declarative-sync/BUILD.bazel @@ -57,6 +57,7 @@ jvm_library( "//android/gradle-dsl", "//platform/workspace/storage", "//android/gradle-dsl-declarative", + "//platform/workspace/jps", ] ) diff --git a/plugins/gradle/gradle-declarative-sync/intellij.gradle.declarativeSync.tests.iml b/plugins/gradle/gradle-declarative-sync/intellij.gradle.declarativeSync.tests.iml index c18e9122660e..0ac9ec6ffe94 100644 --- a/plugins/gradle/gradle-declarative-sync/intellij.gradle.declarativeSync.tests.iml +++ b/plugins/gradle/gradle-declarative-sync/intellij.gradle.declarativeSync.tests.iml @@ -24,5 +24,6 @@ + \ No newline at end of file diff --git a/plugins/gradle/gradle-declarative-sync/testSources/GradleDeclarativeSyncTest.kt b/plugins/gradle/gradle-declarative-sync/testSources/GradleDeclarativeSyncTest.kt index 8009371350a9..fe10bb42de95 100644 --- a/plugins/gradle/gradle-declarative-sync/testSources/GradleDeclarativeSyncTest.kt +++ b/plugins/gradle/gradle-declarative-sync/testSources/GradleDeclarativeSyncTest.kt @@ -8,7 +8,7 @@ import com.intellij.openapi.util.Disposer import com.intellij.openapi.util.io.toCanonicalPath import com.intellij.openapi.util.use import com.intellij.platform.backend.workspace.workspaceModel -import com.intellij.platform.testFramework.assertion.dependencyAssertion.DependencyAssertions +import com.intellij.platform.testFramework.assertion.moduleAssertion.DependencyAssertions import com.intellij.platform.testFramework.assertion.moduleAssertion.ContentRootAssertions import com.intellij.platform.testFramework.assertion.moduleAssertion.ModuleAssertions import org.jetbrains.plugins.gradle.importing.syncAction.GradlePhasedSyncTestCase @@ -113,10 +113,14 @@ class GradleDeclarativeSyncTest : GradlePhasedSyncTestCase() { ContentRootAssertions.assertContentRoots(virtualFileUrlManager, storage, "project.main", projectRoot.resolve("src/main")) ContentRootAssertions.assertContentRoots(virtualFileUrlManager, storage, "project.test", projectRoot.resolve("src/test")) - DependencyAssertions.assertModuleLibDep(storage, "project.main", "Gradle: com.google.guava:guava:32.1.3-jre") - DependencyAssertions.assertModuleModuleDeps(storage, "project.test", "project.main") - DependencyAssertions.assertModuleLibDep(storage, "project.test", "Gradle: com.google.guava:guava:32.1.3-jre") - DependencyAssertions.assertModuleLibDep(storage, "project.test", "Gradle: org.junit.jupiter:junit-jupiter:5.10.2") + ModuleAssertions.assertModuleEntity(storage, "project.main") { module -> + DependencyAssertions.assertLibraryDependency(module, "Gradle: com.google.guava:guava:32.1.3-jre") + } + ModuleAssertions.assertModuleEntity(storage, "project.test") { module -> + DependencyAssertions.assertModuleDependency(module, "project.main") + DependencyAssertions.assertLibraryDependency(module, "Gradle: com.google.guava:guava:32.1.3-jre") + DependencyAssertions.assertLibraryDependency(module, "Gradle: org.junit.jupiter:junit-jupiter:5.10.2") + } } } @@ -286,7 +290,9 @@ class GradleDeclarativeSyncTest : GradlePhasedSyncTestCase() { ContentRootAssertions.assertContentRoots(virtualFileUrlManager, storage, "project.list.main", projectRoot.resolve("list/src/main")) ContentRootAssertions.assertContentRoots(virtualFileUrlManager, storage, "project.list.test", projectRoot.resolve("list/src/test")) - DependencyAssertions.assertModuleLibDep(storage, "project.app.main", "Gradle: org.apache.commons:commons-text:1.11.0") + ModuleAssertions.assertModuleEntity(storage, "project.app.main") { module -> + DependencyAssertions.assertLibraryDependency(module, "Gradle: org.apache.commons:commons-text:1.11.0") + } // TODO add transitive module dependencies // (if app depends on utilities and utilities depends on list then app should also depend on list) @@ -295,13 +301,23 @@ class GradleDeclarativeSyncTest : GradlePhasedSyncTestCase() { //DependencyAssertions.assertModuleModuleDeps(storage, "project.app.test", // "project.app.main", "project.utilities.main", "project.list.main") - DependencyAssertions.assertModuleLibDep(storage, "project.app.main", "Gradle: org.apache.commons:commons-text:1.11.0") - DependencyAssertions.assertModuleLibDep(storage, "project.app.test", "Gradle: org.junit.jupiter:junit-jupiter:5.10.2") + ModuleAssertions.assertModuleEntity(storage, "project.app.main") { module -> + DependencyAssertions.assertLibraryDependency(module, "Gradle: org.apache.commons:commons-text:1.11.0") + } + ModuleAssertions.assertModuleEntity(storage, "project.app.test") { module -> + DependencyAssertions.assertLibraryDependency(module, "Gradle: org.junit.jupiter:junit-jupiter:5.10.2") + } - DependencyAssertions.assertModuleModuleDeps(storage, "project.utilities.main", "project.list.main") - DependencyAssertions.assertModuleModuleDeps(storage, "project.utilities.test", "project.utilities.main", "project.list.main") + ModuleAssertions.assertModuleEntity(storage, "project.utilities.main") { module -> + DependencyAssertions.assertModuleDependencies(module, "project.list.main") + } + ModuleAssertions.assertModuleEntity(storage, "project.utilities.test") { module -> + DependencyAssertions.assertModuleDependencies(module, "project.utilities.main", "project.list.main") + } - DependencyAssertions.assertModuleModuleDeps(storage, "project.list.test", "project.list.main") + ModuleAssertions.assertModuleEntity(storage, "project.list.test") { module -> + DependencyAssertions.assertModuleDependency(module, "project.list.main") + } } }