[TestFramework] cleanup: merge DependencyAssertions utilities

GitOrigin-RevId: c084b1ae3afa72275003305afa9bf4b774655060

platform/testFramework/src/com/intellij/platform/testFramework/assertion/dependencyAssertion/DependencyAssertions.kt

@@ -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<ModuleEntity>().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<ModuleEntity>().filter { it.name == moduleName }.toList()
-    assertEquals(1, modules.size)
-    val moduleDeps = modules[0].dependencies.filterIsInstance<ModuleDependency>().map { it.module.name }.toList()
-    assertEqualsUnordered(depNames.toList(), moduleDeps)
-  }
-}

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<String>) {
+    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<String>) {
+    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<String>) {
-    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<LibraryDependency>()
-      .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<ModuleDependency>()
-      .find { it.module.name == name }
+  private fun <T : ModuleDependencyItem> assertDependencies(module: ModuleEntity, type: Class<T>, expectedNames: List<String>) {
+    module.dependencies.filterIsInstance(type)
+      .map { it.dependencyName }
+      .let { actualNames ->
+        CollectionAssertions.assertEqualsUnordered(expectedNames, actualNames)
+      }
+  }
+
+  private fun <T : ModuleDependencyItem> assertDependency(module: ModuleEntity, type: Class<T>, 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)
       }
   }

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")
+        }
+      }
+    }
+  }
+}

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)
+  }
 }

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",
   ]
 )
 

plugins/gradle/gradle-declarative-sync/intellij.gradle.declarativeSync.tests.iml

@@ -24,5 +24,6 @@
     <orderEntry type="module" module-name="intellij.android.gradle.dsl" scope="TEST" />
     <orderEntry type="module" module-name="intellij.platform.workspace.storage" scope="TEST" />
     <orderEntry type="module" module-name="intellij.android.gradle.dsl.declarative" scope="TEST" />
+    <orderEntry type="module" module-name="intellij.platform.workspace.jps" scope="TEST" />
   </component>
 </module>

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")
+          }
         }
       }