diff --git a/plugins/devkit/intellij.devkit.workspaceModel/tests/testSrc/com/intellij/devkit/workspaceModel/AllIntellijEntitiesGenerationTest.kt b/plugins/devkit/intellij.devkit.workspaceModel/tests/testSrc/com/intellij/devkit/workspaceModel/AllIntellijEntitiesGenerationTest.kt
index 5bdfe9da954d..f95efe11fc98 100644
--- a/plugins/devkit/intellij.devkit.workspaceModel/tests/testSrc/com/intellij/devkit/workspaceModel/AllIntellijEntitiesGenerationTest.kt
+++ b/plugins/devkit/intellij.devkit.workspaceModel/tests/testSrc/com/intellij/devkit/workspaceModel/AllIntellijEntitiesGenerationTest.kt
@@ -7,6 +7,7 @@ import com.intellij.java.workspace.entities.JavaSourceRootPropertiesEntity
 import com.intellij.java.workspace.entities.javaSourceRoots
 import com.intellij.openapi.application.runWriteActionAndWait
 import com.intellij.openapi.diagnostic.logger
+import com.intellij.openapi.roots.ModifiableRootModel
 import com.intellij.openapi.roots.ModuleRootManager
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.openapi.vfs.VfsUtil
@@ -144,65 +145,53 @@ class AllIntellijEntitiesGenerationTest : CodeGenerationTestBase() {
     var storageChanged = false
     modulesToCheck.forEach { (moduleEntity, sourceRoot), pathToPackages ->
       val isTestModule = sourceRoot.rootTypeId == JAVA_TEST_ROOT_ENTITY_TYPE_ID
+
+      fun generateForSpecificModule(processAbstractTypes: Boolean, beforeGeneration: (ModifiableRootModel) -> Unit,
+                                    afterGeneration: (ModifiableRootModel) -> Unit) {
+        runWriteActionAndWait {
+          val modifiableModel = ModuleRootManager.getInstance(module).modifiableModel
+          beforeGeneration(modifiableModel)
+          modifiableModel.commit()
+        }
+        val projectModelUpdateResult = generationFunction(storage, moduleEntity, sourceRoot, pathToPackages, processAbstractTypes, false, isTestModule)
+        storageChanged = storageChanged || projectModelUpdateResult
+        runWriteActionAndWait {
+          val modifiableModel = ModuleRootManager.getInstance(module).modifiableModel
+          afterGeneration(modifiableModel)
+          modifiableModel.commit()
+        }
+      }
+
       when (moduleEntity.name) {
         "intellij.platform.workspace.storage"-> {
-          runWriteActionAndWait {
-            val modifiableModel = ModuleRootManager.getInstance(module).modifiableModel
-            removeWorkspaceStorageLibrary(modifiableModel)
-            modifiableModel.commit()
-          }
-          val projectModelUpdateResult = generationFunction(storage, moduleEntity, sourceRoot, pathToPackages, false, true, isTestModule)
-          storageChanged = storageChanged || projectModelUpdateResult
-          runWriteActionAndWait {
-            val modifiableModel = ModuleRootManager.getInstance(module).modifiableModel
-            addWorkspaceStorageLibrary(modifiableModel)
-            modifiableModel.commit()
-          }
+          generateForSpecificModule(false, { modifiableModel -> removeWorkspaceStorageLibrary(modifiableModel) },
+                                    { modifiableModel -> addWorkspaceStorageLibrary(modifiableModel) })
         }
         "intellij.platform.workspace.jps"-> {
-          runWriteActionAndWait {
-            val modifiableModel = ModuleRootManager.getInstance(module).modifiableModel
-            removeWorkspaceJpsEntitiesLibrary(modifiableModel)
-            modifiableModel.commit()
-          }
-          val projectModelUpdateResult = generationFunction(storage, moduleEntity, sourceRoot, pathToPackages, false, false, isTestModule)
-          storageChanged = storageChanged || projectModelUpdateResult
-          runWriteActionAndWait {
-            val modifiableModel = ModuleRootManager.getInstance(module).modifiableModel
-            addWorkspaceJpsEntitiesLibrary(modifiableModel)
-            modifiableModel.commit()
-          }
+          generateForSpecificModule(false, { modifiableModel -> removeWorkspaceJpsEntitiesLibrary(modifiableModel) },
+                                    { modifiableModel -> addWorkspaceJpsEntitiesLibrary(modifiableModel) })
         }
         "intellij.javaee.platform", "intellij.javaee.ejb", "intellij.javaee.web" -> {
           // For these modules we need to have reference to `ConfigFileItem` thus we added its module as library
-          runWriteActionAndWait {
-            val modifiableModel = ModuleRootManager.getInstance(module).modifiableModel
-            addIntellijJavaLibrary(modifiableModel)
-            modifiableModel.commit()
-          }
-          val projectModelUpdateResult = generationFunction(storage, moduleEntity, sourceRoot, pathToPackages, false, false, isTestModule)
-          storageChanged = storageChanged || projectModelUpdateResult
-          runWriteActionAndWait {
-            val modifiableModel = ModuleRootManager.getInstance(module).modifiableModel
-            removeIntellijJavaLibrary(modifiableModel)
-            modifiableModel.commit()
-          }
+          generateForSpecificModule(false, { modifiableModel -> addIntellijJavaLibrary(modifiableModel) },
+                                    { modifiableModel -> removeIntellijJavaLibrary(modifiableModel) })
+        }
+        "intellij.rider.plugins.unity" -> {
+          generateForSpecificModule(true, { modifiableModel -> addRiderPluginLibrary(modifiableModel) },
+                                    { modifiableModel -> removeRiderPluginLibrary(modifiableModel) })
+        }
+        "intellij.rider.rdclient.dotnet" -> {
+          generateForSpecificModule(true, { modifiableModel -> addRiderModelLibrary(modifiableModel) },
+                                    { modifiableModel -> removeRiderModelLibrary(modifiableModel) })
         }
         "kotlin.base.facet" -> {
-          runWriteActionAndWait {
-            val modifiableModel = ModuleRootManager.getInstance(module).modifiableModel
+          generateForSpecificModule(false, { modifiableModel ->
             addIntellijJavaLibrary(modifiableModel)
             addKotlinJpsCommonJar(modifiableModel)
-            modifiableModel.commit()
-          }
-          val projectModelUpdateResult = generationFunction(storage, moduleEntity, sourceRoot, pathToPackages, false, false, isTestModule)
-          storageChanged = storageChanged || projectModelUpdateResult
-          runWriteActionAndWait {
-            val modifiableModel = ModuleRootManager.getInstance(module).modifiableModel
+          }, { modifiableModel ->
             removeIntellijJavaLibrary(modifiableModel)
             removeKotlinJpsCommonJar(modifiableModel)
-            modifiableModel.commit()
-          }
+          })
         }
         in modulesWithAbstractTypes -> {
           val projectModelUpdateResult = generationFunction(storage, moduleEntity, sourceRoot, pathToPackages, true, false, isTestModule)
diff --git a/plugins/devkit/intellij.devkit.workspaceModel/tests/testSrc/com/intellij/devkit/workspaceModel/CodeGenerationTestBase.kt b/plugins/devkit/intellij.devkit.workspaceModel/tests/testSrc/com/intellij/devkit/workspaceModel/CodeGenerationTestBase.kt
index 194b3ba86752..33d130c2349b 100644
--- a/plugins/devkit/intellij.devkit.workspaceModel/tests/testSrc/com/intellij/devkit/workspaceModel/CodeGenerationTestBase.kt
+++ b/plugins/devkit/intellij.devkit.workspaceModel/tests/testSrc/com/intellij/devkit/workspaceModel/CodeGenerationTestBase.kt
@@ -223,6 +223,22 @@ abstract class CodeGenerationTestBase : KotlinLightCodeInsightFixtureTestCase()
       addJarDirectoryBaseOnClass(model, "kotlinc-kotlin-jps-common", KotlinModuleKind::class.java)
     }
 
+    internal fun addRiderPluginLibrary(model: ModifiableRootModel) {
+      addLibraryBaseOnPath(model, "rider-plugin", "intellij.rider.plugins.unity")
+    }
+
+    internal fun removeRiderPluginLibrary(model: ModifiableRootModel) {
+      removeLibraryByName(model, "rider-plugin")
+    }
+
+    internal fun addRiderModelLibrary(model: ModifiableRootModel) {
+      addLibraryBaseOnPath(model, "rider-model", "intellij.rider.model.generated")
+    }
+
+    internal fun removeRiderModelLibrary(model: ModifiableRootModel) {
+      removeLibraryByName(model, "rider-model")
+    }
+
     private fun removeLibraryByName(model: ModifiableRootModel, libraryName: String) {
       val moduleLibraryTable = model.moduleLibraryTable
       val modifiableModel = model.moduleLibraryTable.modifiableModel
@@ -232,25 +248,45 @@ abstract class CodeGenerationTestBase : KotlinLightCodeInsightFixtureTestCase()
     }
 
     private fun addLibraryBaseOnClass(model: ModifiableRootModel, libraryName: String, baseClass: Class<*>) {
-      addDependencyBaseOnClass(model, libraryName, baseClass) {
+      addDependencyFromCompilationOutput(model, libraryName, baseClass) {
+        addRoot(it, OrderRootType.CLASSES)
+      }
+    }
+
+    private fun addLibraryBaseOnPath(model: ModifiableRootModel, libraryName: String, classpath: String) {
+      addDependencyFromCompilationOutput(model, libraryName, classpath) {
         addRoot(it, OrderRootType.CLASSES)
       }
     }
 
     private fun addJarDirectoryBaseOnClass(model: ModifiableRootModel, libraryName: String, baseClass: Class<*>) {
-      addDependencyBaseOnClass(model, libraryName, baseClass) {
+      addDependencyFromCompilationOutput(model, libraryName, baseClass) {
         addJarDirectory(it, true)
       }
     }
 
-    private fun addDependencyBaseOnClass(model: ModifiableRootModel, libraryName: String, baseClass: Class<*>, addDependency: ModifiableModel.(VirtualFile) -> Unit) {
+    private fun addDependencyFromCompilationOutput(model: ModifiableRootModel, libraryName: String, baseClass: Class<*>, addDependency: ModifiableModel.(VirtualFile) -> Unit) {
       val library = model.moduleLibraryTable.modifiableModel.createLibrary(libraryName)
       val modifiableModel = library.modifiableModel
-      val workspaceStorageClassesPath = VfsUtil.pathToUrl(PathUtil.getJarPathForClass(baseClass))
-      val workspaceStorageClassesRoot = VirtualFileManager.getInstance().refreshAndFindFileByUrl(workspaceStorageClassesPath)
-      assertNotNull("Cannot find $workspaceStorageClassesPath", workspaceStorageClassesRoot)
-      VfsUtil.markDirtyAndRefresh(false, true, true, workspaceStorageClassesRoot)
-      modifiableModel.addDependency(workspaceStorageClassesRoot!!)
+      val classesPathUrl = VfsUtil.pathToUrl(PathUtil.getJarPathForClass(baseClass))
+      val classesRootVirtualFile = VirtualFileManager.getInstance().refreshAndFindFileByUrl(classesPathUrl)
+      assertNotNull("Cannot find $classesPathUrl", classesRootVirtualFile)
+      VfsUtil.markDirtyAndRefresh(false, true, true, classesRootVirtualFile)
+      modifiableModel.addDependency(classesRootVirtualFile!!)
+      modifiableModel.commit()
+    }
+
+    private fun addDependencyFromCompilationOutput(model: ModifiableRootModel, libraryName: String, classpathFolder: String, addDependency: ModifiableModel.(VirtualFile) -> Unit) {
+      val library = model.moduleLibraryTable.modifiableModel.createLibrary(libraryName)
+      val modifiableModel = library.modifiableModel
+
+      val classesPathUrl = VfsUtil.pathToUrl(PathUtil.getJarPathForClass(WorkspaceEntity::class.java))
+      val classesRootVirtualFile = VirtualFileManager.getInstance().refreshAndFindFileByUrl(classesPathUrl)
+
+      val classpathFolderVirtualFile = classesRootVirtualFile?.parent?.children?.find { it.name == classpathFolder }
+      assertNotNull("Cannot find $classpathFolder in $classesRootVirtualFile. Possibly, project was partially compiled", classpathFolderVirtualFile)
+      VfsUtil.markDirtyAndRefresh(false, true, true, classpathFolderVirtualFile)
+      modifiableModel.addDependency(classpathFolderVirtualFile!!)
       modifiableModel.commit()
     }
   }