public void FallbackRepositoryRetursNullIfPrimaryRepositoryDoesNotHaveDependencyAndDependencyResolverThrows() { // Arrange var package = PackageUtility.CreatePackage("M1", "1.0"); var dependencyResolver = new Mock <IPackageRepository>(MockBehavior.Strict); dependencyResolver.As <IDependencyResolver>() .Setup(c => c.ResolveDependency(It.IsAny <PackageDependency>(), It.IsAny <IPackageConstraintProvider>(), false, It.IsAny <bool>(), DependencyVersion.Lowest)) .Throws(new Exception("Connection failure.")); var aggregateRepository = new AggregateRepository(new[] { dependencyResolver.Object }) { IgnoreFailingRepositories = true }; var primaryRepository = new MockPackageRepository(); primaryRepository.AddPackage(package); var fallbackRepository = new FallbackRepository(primaryRepository, aggregateRepository); // Act var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M2", new VersionSpec { MinVersion = new SemanticVersion("1.0.1") }), false, false); // Assert Assert.Null(resolvedPackage); }
public void FallbackRepositoryCallsPackagesFindPackageOnThePrimaryRepository() { // Arrange var primaryRepository = new Mock <IPackageRepository>(MockBehavior.Strict); IPackage package = PackageUtility.CreatePackage("A", "1.0"); primaryRepository.As <IPackageLookup>().Setup(p => p.FindPackage("A", new SemanticVersion("1.0"))).Returns(package).Verifiable(); var fallbackRepository = new FallbackRepository(primaryRepository.Object, new MockPackageRepository()); // Act IPackage foundPackage = fallbackRepository.FindPackage("A", new SemanticVersion("1.0")); // Assert primaryRepository.VerifyAll(); Assert.Same(package, foundPackage); }
public void ExistsReturnsTrueIfPrimaryRepositoryContainsPackage() { // Arrange IPackage package = PackageUtility.CreatePackage("A", "1.0"); var primaryRepository = new Mock <IPackageRepository>(MockBehavior.Strict); primaryRepository.As <IPackageLookup>() .Setup(s => s.Exists("A", new SemanticVersion("1.0"))) .Returns(true) .Verifiable(); var fallbackRepository = new FallbackRepository(primaryRepository.Object, new MockPackageRepository()); // Act var exists = fallbackRepository.Exists("A", new SemanticVersion("1.0")); // Assert Assert.True(exists); primaryRepository.Verify(); }
public void FallbackRepositoryDoesNotQueryDependencyResolverIfPrimaryRepositoryContainsRequiredDependency() { // Arrange var package = PackageUtility.CreatePackage("M1", "1.0"); var dependencyResolver = new Mock <IPackageRepository>(MockBehavior.Strict); dependencyResolver.As <IDependencyResolver>() .Setup(c => c.ResolveDependency(It.IsAny <PackageDependency>(), It.IsAny <IPackageConstraintProvider>(), false, It.IsAny <bool>(), DependencyVersion.Lowest)) .Throws(new Exception("This method should not be called.")); var primaryRepository = new MockPackageRepository(); primaryRepository.AddPackage(package); var fallbackRepository = new FallbackRepository(primaryRepository, dependencyResolver.Object); // Act var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M1"), false, false); // Assert Assert.Same(package, resolvedPackage); }
public void FallbackRepositoryUsesDependencyResolverIfPrimaryRepositoryDoesNotHaveRequiredDependency() { // Arrange IPackage packageA10 = PackageUtility.CreatePackage("M1", "1.0"), packageA11 = PackageUtility.CreatePackage("M2", "1.1"); var primaryRepository = new MockPackageRepository(); primaryRepository.AddPackage(packageA10); var dependencyResolver = new MockPackageRepository(); dependencyResolver.AddPackage(packageA11); var fallbackRepository = new FallbackRepository(primaryRepository, dependencyResolver); // Act var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M2", new VersionSpec { MinVersion = new SemanticVersion("1.0.1") }), false, false); // Assert Assert.Same(resolvedPackage, packageA11); }
public void CreateFallbackRepositoryUsesResolvedSourceNameWhenEnsuringRepositoryIsNotAlreadyListedInAggregate() { // Arrange var mockRepositoryFactory = new Mock <IPackageRepositoryFactory>(); var mockSourceProvider = new Mock <IVsPackageSourceProvider>(); var mockRepository1 = new MockPackageRepository(); var mockRepository2 = new MockPackageRepository("http://redirected"); var aggregateRepo = new AggregateRepository(new[] { mockRepository1, mockRepository2 }); var source1 = new PackageSource("Source1"); var source2 = new PackageSource("Source2"); var aggregateSource = AggregatePackageSource.Instance; mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0")); mockRepository2.AddPackage(PackageUtility.CreatePackage("A", "1.2")); mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2, aggregateSource }); mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny <string>())).Returns <string>(s => { switch (s) { case "Source1": return(mockRepository1); case "Source2": return(mockRepository2); default: return(null); } }); var packageManagerFactory = new VsPackageManagerFactory(new Mock <ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, new Mock <IFileSystemProvider>().Object, new Mock <IRepositorySettings>().Object, new Mock <VsPackageInstallerEvents>().Object, mockRepository1, machineWideSettings: null); // Act FallbackRepository repository = (FallbackRepository)packageManagerFactory.CreateFallbackRepository(mockRepository2); // Assert var dependencyResolver = (AggregateRepository)repository.DependencyResolver; Assert.Equal(2, dependencyResolver.Repositories.Count()); }
public void CreateFallbackRepositoryDoesNotThrowWhenIteratingOverFailingRepositories() { // Arrange var mockRepositoryFactory = new Mock <IPackageRepositoryFactory>(); var mockSourceProvider = new Mock <IVsPackageSourceProvider>(); var mockRepository1 = new MockPackageRepository(); var mockRepository2 = new MockPackageRepository("http://redirected"); var source1 = new PackageSource("Source1"); var source2 = new PackageSource("Source2"); var source3 = new PackageSource("SourceBad"); var aggregateSource = AggregatePackageSource.Instance; mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source3, source2, aggregateSource }); mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny <string>())).Returns <string>(s => { switch (s) { case "Source1": return(mockRepository1); case "Source2": return(mockRepository2); case "SourceBad": throw new InvalidOperationException(); default: return(null); } }); var packageManagerFactory = new VsPackageManagerFactory(new Mock <ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, new Mock <IFileSystemProvider>().Object, new Mock <IRepositorySettings>().Object, new Mock <VsPackageInstallerEvents>().Object, mockRepository1, machineWideSettings: null); // Act FallbackRepository repository = (FallbackRepository)packageManagerFactory.CreateFallbackRepository(mockRepository2); // Assert var dependencyResolver = (AggregateRepository)repository.DependencyResolver; Assert.Equal(2, dependencyResolver.Repositories.Count()); }
public void ExistsReturnsTrueIfPrimaryRepositoryContainsPackage() { // Arrange IPackage package = PackageUtility.CreatePackage("A", "1.0"); var primaryRepository = new Mock<IPackageRepository>(MockBehavior.Strict); primaryRepository.As<IPackageLookup>() .Setup(s => s.Exists("A", new SemanticVersion("1.0"))) .Returns(true) .Verifiable(); var fallbackRepository = new FallbackRepository(primaryRepository.Object, new MockPackageRepository()); // Act var exists = fallbackRepository.Exists("A", new SemanticVersion("1.0")); // Assert Assert.True(exists); primaryRepository.Verify(); }
public void FallbackRepositoryCallsPackagesFindPackageOnThePrimaryRepository() { // Arrange var primaryRepository = new Mock<IPackageRepository>(MockBehavior.Strict); IPackage package = PackageUtility.CreatePackage("A", "1.0"); primaryRepository.As<IPackageLookup>().Setup(p => p.FindPackage("A", new SemanticVersion("1.0"))).Returns(package).Verifiable(); var fallbackRepository = new FallbackRepository(primaryRepository.Object, new MockPackageRepository()); // Act IPackage foundPackage = fallbackRepository.FindPackage("A", new SemanticVersion("1.0")); // Assert primaryRepository.VerifyAll(); Assert.Same(package, foundPackage); }
public void FallbackRepositoryRetursNullIfPrimaryRepositoryDoesNotHaveDependencyAndDependencyResolverThrows() { // Arrange var package = PackageUtility.CreatePackage("M1", "1.0"); var dependencyResolver = new Mock<IPackageRepository>(MockBehavior.Strict); dependencyResolver.As<IDependencyResolver>() .Setup(c => c.ResolveDependency(It.IsAny<PackageDependency>(), It.IsAny<IPackageConstraintProvider>(), false, It.IsAny<bool>())) .Throws(new Exception("Connection failure.")); var aggregateRepository = new AggregateRepository(new[] { dependencyResolver.Object }) { IgnoreFailingRepositories = true }; var primaryRepository = new MockPackageRepository(); primaryRepository.AddPackage(package); var fallbackRepository = new FallbackRepository(primaryRepository, aggregateRepository); // Act var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M2", new VersionSpec { MinVersion = new SemanticVersion("1.0.1") }), false, false); // Assert Assert.Null(resolvedPackage); }
public void FallbackRepositoryDoesNotQueryDependencyResolverIfPrimaryRepositoryContainsRequiredDependency() { // Arrange var package = PackageUtility.CreatePackage("M1", "1.0"); var dependencyResolver = new Mock<IPackageRepository>(MockBehavior.Strict); dependencyResolver.As<IDependencyResolver>() .Setup(c => c.ResolveDependency(It.IsAny<PackageDependency>(), It.IsAny<IPackageConstraintProvider>(), false, It.IsAny<bool>())) .Throws(new Exception("This method should not be called.")); var primaryRepository = new MockPackageRepository(); primaryRepository.AddPackage(package); var fallbackRepository = new FallbackRepository(primaryRepository, dependencyResolver.Object); // Act var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M1"), false, false); // Assert Assert.Same(package, resolvedPackage); }