| public ReferenceExists ( string name ) : bool | ||
| name | string | |
| Результат | bool | |
public void AddPackageReferenceAppliesPackageReferencesCorrectly()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=4.5"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage(
"A",
"1.0",
assemblyReferences: new[] { "lib\\a.dll", "lib\\b.dll" });
sourceRepository.AddPackage(packageA);
Mock<IPackage> mockPackageA = Mock.Get<IPackage>(packageA);
mockPackageA.Setup(m => m.PackageAssemblyReferences).Returns(
new PackageReferenceSet[] {
new PackageReferenceSet(VersionUtility.ParseFrameworkName("net40"), new [] { "a.dll" }),
new PackageReferenceSet(null, new [] { "b.dll" })
}
);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(projectManager.LocalRepository.Exists("A"));
Assert.True(projectSystem.ReferenceExists("a.dll"));
Assert.False(projectSystem.ReferenceExists("b.dll"));
}
public void AddPackageReferencePrefersFullProfileOverClientProfileWhenInstallIntoFullProfileProject()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=4.5"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage(
"A",
"1.0",
content: new[] { "net40-client\\b.txt", "net40\\a.txt" },
assemblyReferences: new[] { "lib\\net40\\a.dll", "lib\\net40-client\\b.dll" });
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(projectSystem.ReferenceExists("b.dll"));
Assert.False(projectSystem.FileExists("b.txt"));
Assert.True(projectSystem.ReferenceExists("a.dll"));
Assert.True(projectSystem.FileExists("a.txt"));
}
public void AddPackageReferencePicksPortableLibraryAssemblyOverFallbackAssembly()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(VersionUtility.ParseFrameworkName("portable-sl4+net45"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage("A", "1.0", assemblyReferences: new[] { "netcf\\you.dll", "lib\\portable-sl4+net45+wp8+windows8\\portable.dll", "lib\\me.dll" });
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(projectSystem.ReferenceExists("me.dll"));
Assert.False(projectSystem.ReferenceExists("you.dll"));
Assert.True(projectSystem.ReferenceExists("portable.dll"));
}
public void AddPackageReferenceRecognizeEmptyFrameworkFolder5()
{
// Arrange
var projectSystem = new MockProjectSystem(new FrameworkName(".NETCore", new Version("4.5")));
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0",
assemblyReferences: new string[] {
"lib\\sl3\\reference.dll",
"lib\\winrt\\_._",
"lib\\winrt45\\one.dll"
});
mockRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(projectSystem.ReferenceExists("reference.dll"));
Assert.False(projectSystem.ReferenceExists("_._"));
Assert.True(projectSystem.ReferenceExists("one.dll"));
Assert.True(localRepository.Exists("A"));
}
public void AddPackageReferencePicksAssemblyFromClientProfileOverFullProfile()
{
// Arrange
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("4.5"), "Client"));
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0",
new[] { "contentFile.txt" },
new[] { "lib\\net45-client\\a.dll", "lib\\net45\\b.dll" });
mockRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(projectSystem.ReferenceExists("a.dll"));
Assert.False(projectSystem.ReferenceExists("b.dll"));
}
public void AddPackageReferenceDoesNotThrowIfThereIsCompatibleAssemblyInContentButNotInLib()
{
// Arrange
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework", new Version("4.0")));
var localRepository = new MockPackageRepository();
var mockRepository = new MockPackageRepository();
var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var packageA = PackageUtility.CreatePackage("A", "1.0",
content: new[] { "net20\\reference.txt" },
assemblyReferences: new string[] { "lib\\WindowsPhone7\\one.dll" });
mockRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.True(localRepository.Exists("A"));
Assert.False(projectSystem.ReferenceExists("one.dll"));
Assert.True(projectSystem.FileExists("reference.txt"));
}
public void ReinstallPackagesRestoresPackageInAllProjectsWithNewContentIfSourcePackageChanges()
{
// Arrange
var localRepositoryMock = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
var localRepository = localRepositoryMock.Object;
var sourceRepository = new MockPackageRepository();
var projectSystem1 = new MockProjectSystem();
var pathResolver1 = new DefaultPackagePathResolver(projectSystem1);
var packageReferenceRepository1 = new PackageReferenceRepository(projectSystem1, localRepository);
var projectManager1 = new ProjectManager(localRepository, pathResolver1, projectSystem1, packageReferenceRepository1);
var projectSystem2 = new MockProjectSystem();
var pathResolver2 = new DefaultPackagePathResolver(projectSystem2);
var packageReferenceRepository2 = new PackageReferenceRepository(projectSystem2, localRepository);
var projectManager2 = new ProjectManager(localRepository, pathResolver2, projectSystem2, packageReferenceRepository2);
var project1 = TestUtils.GetProject("Project1");
var project2 = TestUtils.GetProject("Project2");
var packageManager = new MockVsPackageManager(
TestUtils.GetSolutionManager(projects: new[] { project1, project2 }),
sourceRepository,
new Mock<IFileSystemProvider>().Object,
projectSystem2,
localRepository,
new Mock<IDeleteOnRestartManager>().Object,
new Mock<VsPackageInstallerEvents>().Object);
packageManager.RegisterProjectManager(project1, projectManager1);
packageManager.RegisterProjectManager(project2, projectManager2);
var packageA = PackageUtility.CreatePackage(
"A",
"1.2-alpha",
new[] { "content.txt" },
new[] { "lib\\ref.dll" });
var packageA2 = PackageUtility.CreatePackage(
"A",
"1.2-alpha",
new[] { "foo.txt" },
new[] { "lib\\bar.dll" });
var packageB = PackageUtility.CreatePackage(
"B",
"2.0",
new[] { "hello.txt" },
new[] { "lib\\comma.dll" });
var packageB2 = PackageUtility.CreatePackage(
"B",
"2.0",
new[] { "world.txt" },
new[] { "lib\\dude.dll" });
sourceRepository.Add(packageA);
sourceRepository.Add(packageB);
// install package A -> project 1
// and package B -> project 2
packageManager.InstallPackage(projectManager1, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
packageManager.InstallPackage(projectManager2, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectSystem1.FileExists("content.txt"));
Assert.True(projectSystem1.ReferenceExists("ref.dll"));
Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectSystem2.FileExists("hello.txt"));
Assert.True(projectSystem2.ReferenceExists("comma.dll"));
// now change the package A and B to different packages
sourceRepository.RemovePackage(packageA);
sourceRepository.RemovePackage(packageB);
sourceRepository.AddPackage(packageA2);
sourceRepository.AddPackage(packageB2);
localRepositoryMock.Setup(p => p.IsReferenced("A", new SemanticVersion("1.2-alpha"))).Returns((string id, SemanticVersion version) => projectManager1.LocalRepository.Exists(id, version));
localRepositoryMock.Setup(p => p.IsReferenced("B", new SemanticVersion("2.0"))).Returns((string id, SemanticVersion version) => projectManager2.LocalRepository.Exists(id, version));
// Act
packageManager.ReinstallPackages(updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance, eventListener: NullPackageOperationEventListener.Instance);
// Assert
Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.False(projectSystem1.FileExists("content.txt"));
Assert.True(projectSystem1.FileExists("foo.txt"));
Assert.False(projectSystem1.ReferenceExists("ref.dll"));
Assert.True(projectSystem1.ReferenceExists("bar.dll"));
Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.False(projectSystem2.FileExists("hello.txt"));
Assert.True(projectSystem2.FileExists("world.txt"));
Assert.False(projectSystem2.ReferenceExists("comma.dll"));
Assert.True(projectSystem2.ReferenceExists("dude.dll"));
}
public void ReinstallPackagesSkipRestallingForOneProjectButProceedWithTheOther()
{
// Arrange
var localRepositoryMock = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
var localRepository = localRepositoryMock.Object;
var sourceRepository = new MockPackageRepository();
var projectSystem1 = new MockProjectSystem(new FrameworkName(".NETFramework, Version=v3.0"));
var pathResolver1 = new DefaultPackagePathResolver(projectSystem1);
var packageReferenceRepository1 = new PackageReferenceRepository(projectSystem1, localRepository);
var projectManager1 = new ProjectManager(localRepository, pathResolver1, projectSystem1, packageReferenceRepository1);
var projectSystem2 = new MockProjectSystem(new FrameworkName(".NETCore, Version=v4.5"));
var pathResolver2 = new DefaultPackagePathResolver(projectSystem2);
var packageReferenceRepository2 = new PackageReferenceRepository(projectSystem2, localRepository);
var projectManager2 = new ProjectManager(localRepository, pathResolver2, projectSystem2, packageReferenceRepository2);
var project1 = TestUtils.GetProject("Project1");
var project2 = TestUtils.GetProject("Project2");
var packageManager = new MockVsPackageManager(
TestUtils.GetSolutionManager(projects: new[] { project1, project2 }),
sourceRepository,
new Mock<IFileSystemProvider>().Object,
projectSystem2,
localRepository,
new Mock<IDeleteOnRestartManager>().Object,
new Mock<VsPackageInstallerEvents>().Object);
packageManager.RegisterProjectManager(project1, projectManager1);
packageManager.RegisterProjectManager(project2, projectManager2);
var packageA = PackageUtility.CreatePackage(
"A",
"1.2-alpha",
new[] { "net30\\content.txt", "silverlight40\\content4.txt" },
new[] { "lib\\net30\\ref.dll", "lib\\silverlight40\\refsl.dll" });
var packageB = PackageUtility.CreatePackage(
"B",
"2.0",
new[] { "winrt45\\hello.txt", "sl4-wp71\\world.txt" },
new[] { "lib\\winrt45\\comma.dll", "lib\\sl4-wp71\\dude.dll" });
sourceRepository.Add(packageA);
localRepository.AddPackage(packageA);
localRepository.AddPackage(packageB);
// install package A -> project 1
// and package B -> project 2
packageManager.InstallPackage(projectManager1, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
packageManager.InstallPackage(projectManager2, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
// now change project's target framework to silverlight
projectSystem1.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0"));
projectSystem2.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0, Profile=WindowsPhone71"));
localRepositoryMock.Setup(p => p.IsReferenced("A", new SemanticVersion("1.2-alpha"))).Returns((string id, SemanticVersion version) => projectManager1.LocalRepository.Exists(id, version));
localRepositoryMock.Setup(p => p.IsReferenced("B", new SemanticVersion("2.0"))).Returns((string id, SemanticVersion version) => projectManager2.LocalRepository.Exists(id, version));
var logger = new Mock<ILogger>();
logger.Setup(s => s.Log(
MessageLevel.Warning,
"Skipped reinstalling package '{0}' in project '{1}' because the package does not exist in the package source.",
"B 2.0",
"Project2")
).Verifiable();
// Act
packageManager.ReinstallPackages(updateDependencies: true, allowPrereleaseVersions: false, logger: logger.Object, eventListener: NullPackageOperationEventListener.Instance);
// Assert
logger.Verify();
Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.False(projectSystem1.FileExists("content.txt"));
Assert.True(projectSystem1.FileExists("content4.txt"));
Assert.False(projectSystem1.ReferenceExists("ref.dll"));
Assert.True(projectSystem1.ReferenceExists("refsl.dll"));
Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectSystem2.FileExists("hello.txt"));
Assert.False(projectSystem2.FileExists("world.txt"));
Assert.True(projectSystem2.ReferenceExists("comma.dll"));
Assert.False(projectSystem2.ReferenceExists("dude.dll"));
}
public void ReinstallPackagesRestoresAllPackagesInAProjectWithNewContentIfProjectFrameworkChanges()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=v3.0"));
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var packageReferenceRepository = new PackageReferenceRepository(projectSystem, localRepository);
var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, packageReferenceRepository);
var packageManager = new VsPackageManager(
TestUtils.GetSolutionManager(),
sourceRepository,
new Mock<IFileSystemProvider>().Object,
projectSystem,
localRepository,
new Mock<IDeleteOnRestartManager>().Object,
new Mock<VsPackageInstallerEvents>().Object);
var packageA = PackageUtility.CreatePackage(
"A",
"1.2-alpha",
new[] { "net30\\content.txt", "silverlight40\\content4.txt" },
new[] { "lib\\net30\\ref.dll", "lib\\silverlight40\\refsl.dll" });
var packageB = PackageUtility.CreatePackage(
"B",
"2.0",
new[] { "net30\\contentB.txt", "silverlight40\\content4B.txt" },
new[] { "lib\\net30\\refB.dll", "lib\\silverlight40\\refslB.dll" });
sourceRepository.Add(packageA);
sourceRepository.Add(packageB);
packageManager.InstallPackage(projectManager, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
packageManager.InstallPackage(projectManager, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectSystem.FileExists("content.txt"));
Assert.False(projectSystem.FileExists("content4.txt"));
Assert.True(projectSystem.ReferenceExists("ref.dll"));
Assert.False(projectSystem.ReferenceExists("refsl.dll"));
Assert.True(packageManager.LocalRepository.Exists("B"));
Assert.True(projectManager.LocalRepository.Exists("B"));
Assert.True(projectSystem.FileExists("contentB.txt"));
Assert.False(projectSystem.FileExists("content4B.txt"));
Assert.True(projectSystem.ReferenceExists("refB.dll"));
Assert.False(projectSystem.ReferenceExists("refslB.dll"));
// now change project's target framework to silverlight
projectSystem.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0"));
// Act
packageManager.ReinstallPackages(projectManager, updateDependencies: true, allowPrereleaseVersions: false, logger: null);
// Assert
Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.False(projectSystem.FileExists("content.txt"));
Assert.True(projectSystem.FileExists("content4.txt"));
Assert.False(projectSystem.ReferenceExists("ref.dll"));
Assert.True(projectSystem.ReferenceExists("refsl.dll"));
Assert.True(packageManager.LocalRepository.Exists("B"));
Assert.True(projectManager.LocalRepository.Exists("B"));
Assert.False(projectSystem.FileExists("contentB.txt"));
Assert.True(projectSystem.FileExists("content4B.txt"));
Assert.False(projectSystem.ReferenceExists("refB.dll"));
Assert.True(projectSystem.ReferenceExists("refslB.dll"));
}
public void UpdatePackageWithMultipleSharedDependencies()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
var projectRepository = new MockProjectPackageRepository(localRepository.Object);
var sourceRepository = new MockPackageRepository();
var fileSystem = new MockFileSystem();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
// A1 -> B1, C1
// A2 -> B1
var A10 = PackageUtility.CreatePackage("A", "1.0", assemblyReferences: new[] { "A1.dll" }, dependencies: new[] {
new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0")),
new PackageDependency("C", VersionUtility.ParseVersionSpec("1.0")),
});
var A20 = PackageUtility.CreatePackage("A", "2.0", assemblyReferences: new[] { "A2.dll" }, dependencies: new[] {
new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0"))
});
var B10 = PackageUtility.CreatePackage("B", "1.0", assemblyReferences: new[] { "B1.dll" });
var C10 = PackageUtility.CreatePackage("C", "1.0", assemblyReferences: new[] { "C1.dll" });
sourceRepository.AddPackage(A10);
sourceRepository.AddPackage(A20);
sourceRepository.AddPackage(B10);
sourceRepository.AddPackage(C10);
localRepository.Object.AddPackage(A10);
localRepository.Object.AddPackage(A20);
localRepository.Object.AddPackage(B10);
localRepository.Object.AddPackage(C10);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object);
var projectManager = new ProjectManager(localRepository.Object, pathResolver, projectSystem, projectRepository);
projectManager.AddPackageReference("A", new SemanticVersion("1.0"));
// Act
packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance);
// Assert
Assert.False(packageManager.LocalRepository.Exists(A10));
Assert.False(projectSystem.ReferenceExists("A1.dll"));
Assert.False(packageManager.LocalRepository.Exists(C10));
Assert.False(projectSystem.ReferenceExists("C1.dll"));
Assert.True(packageManager.LocalRepository.Exists(B10));
Assert.True(projectSystem.ReferenceExists("B1.dll"));
Assert.True(packageManager.LocalRepository.Exists(A20));
Assert.True(projectSystem.ReferenceExists("A2.dll"));
}
public void UpdatePackageNewVersionOfPackageHasLessDependencies()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
var projectRepository = new MockProjectPackageRepository(localRepository.Object);
var sourceRepository = new MockPackageRepository();
var fileSystem = new MockFileSystem();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
// A1 -> B1
// A2
var A10 = PackageUtility.CreatePackage("A", "1.0", assemblyReferences: new[] { "A1.dll" }, dependencies: new[] { new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0")) });
var A20 = PackageUtility.CreatePackage("A", "2.0", assemblyReferences: new[] { "A2.dll" });
var B10 = PackageUtility.CreatePackage("B", "1.0", assemblyReferences: new[] { "B1.dll" });
sourceRepository.AddPackage(A10);
sourceRepository.AddPackage(A20);
sourceRepository.AddPackage(B10);
localRepository.Object.AddPackage(A10);
localRepository.Object.AddPackage(A20);
localRepository.Object.AddPackage(B10);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object);
var projectManager = new ProjectManager(localRepository.Object, pathResolver, projectSystem, projectRepository);
projectManager.AddPackageReference("A", new Version("1.0"));
// Act
packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, logger: NullLogger.Instance);
// Assert
Assert.IsFalse(packageManager.LocalRepository.Exists(A10));
Assert.IsFalse(projectSystem.ReferenceExists("A1.dll"));
Assert.IsFalse(packageManager.LocalRepository.Exists(B10));
Assert.IsFalse(projectSystem.ReferenceExists("B1.dll"));
Assert.IsTrue(packageManager.LocalRepository.Exists(A20));
Assert.IsTrue(projectSystem.ReferenceExists("A2.dll"));
}
public void AddPackageReferencePicksJavascriptWindowsLibraryOverGenericWindowsOne()
{
// Arrange
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem(new FrameworkName(".NETCore, Version=4.5, Profile=javascript"));
var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository());
IPackage packageA = PackageUtility.CreatePackage(
"A",
"1.0",
content: new[] { "win8\\a.txt", "win8-javascript\\b.txt" },
assemblyReferences: new[] { "lib\\win8\\a.dll", "lib\\win8-javascript\\b.dll" });
sourceRepository.AddPackage(packageA);
// Act
projectManager.AddPackageReference("A");
// Assert
Assert.False(projectSystem.ReferenceExists("a.dll"));
Assert.False(projectSystem.FileExists("a.txt"));
Assert.True(projectSystem.ReferenceExists("b.dll"));
Assert.True(projectSystem.FileExists("b.txt"));
}
