public void ServerPackageRepositorySearchUnlisted() { var tempPath = Path.GetTempPath(); var workingDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString()); try { // Arrange // create the server repo, from a directory containing a package. Func <string, bool, bool> settingsFunc = (key, defaultValue) => { if (key == "enableDelisting") { return(true); } return(defaultValue); }; CreateDirectory(workingDirectory); var packageFile = CreatePackage("test1", "1.0", workingDirectory); var fileSystem = new PhysicalFileSystem(workingDirectory); var serverRepository = new ServerPackageRepository( new DefaultPackagePathResolver(fileSystem), fileSystem, settingsFunc) { HashProvider = GetHashProvider().Object }; var packages = serverRepository.Search("test1", true).ToList(); Assert.Equal(1, packages.Count); Assert.Equal("test1", packages[0].Id); Assert.Equal("1.0", packages[0].Version.ToString()); // delist the package serverRepository.RemovePackage("test1", new SemanticVersion("1.0")); // verify that the package is not returned by search packages = serverRepository.Search("test1", true).ToList(); Assert.Equal(0, packages.Count); // Act: search with includeDelisted=true packages = serverRepository.Search( "test1", targetFrameworks: Enumerable.Empty <string>(), allowPrereleaseVersions: true, includeDelisted: true).ToList(); // Verify Assert.Equal(1, packages.Count); Assert.Equal("test1", packages[0].Id); Assert.Equal("1.0", packages[0].Version.ToString()); } finally { // Cleanup DeleteDirectory(workingDirectory); } }
public void ServerPackageRepositoryFindPackageById() { // Arrange var mockProjectSystem = new Mock <MockProjectSystem>() { CallBase = true }; _packageStreams = new Dictionary <string, MemoryStream>(); AddPackage(mockProjectSystem, "test", "1.0"); AddPackage(mockProjectSystem, "test2", "1.0"); AddPackage(mockProjectSystem, "test3", "1.0-alpha"); AddPackage(mockProjectSystem, "test4", "2.0"); var serverRepository = new ServerPackageRepository(new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object); serverRepository.HashProvider = GetHashProvider(); // Act var valid = serverRepository.FindPackagesById("test"); var invalid = serverRepository.FindPackagesById("bad"); // Assert Assert.Equal("test", valid.First().Id); Assert.Equal(0, invalid.Count()); }
public void ServerPackageRepositoryIsAbsoluteLatest() { // Arrange var mockProjectSystem = new Mock <MockProjectSystem>() { CallBase = true }; _packageStreams = new Dictionary <string, MemoryStream>(); AddPackage(mockProjectSystem, "test", "2.0-alpha"); AddPackage(mockProjectSystem, "test", "2.1-alpha"); AddPackage(mockProjectSystem, "test", "2.2-beta"); AddPackage(mockProjectSystem, "test", "2.3"); var serverRepository = new ServerPackageRepository(new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object); serverRepository.HashProvider = GetHashProvider(); // Act var packages = serverRepository.GetPackagesWithDerivedData(); // Assert Assert.Equal(1, packages.Where(p => p.IsAbsoluteLatestVersion).Count()); Assert.Equal("2.3", packages.Where(p => p.IsAbsoluteLatestVersion).First().Version); }
public DefaultServiceResolver(string packagePath, NameValueCollection settings) { _hashProvider = new CryptoHashProvider(Core.Constants.HashAlgorithm); _settingsProvider = new WebConfigSettingsProvider(settings); _packageRepository = new ServerPackageRepository(packagePath, _hashProvider, _settingsProvider, new TraceLogger()); _packageAuthenticationService = new PackageAuthenticationService(settings); }
public async Task ServerPackageRepository_CustomCacheFileNameWithoutExtensionIsConfigured_CustomCacheFileWithExtensionIsCreated() { using (var temporaryDirectory = new TemporaryDirectory()) { ServerPackageRepository serverRepository = await CreateServerPackageRepositoryAsync( temporaryDirectory.Path, getSetting : (key, defaultValue) => key == "cacheFileName"? "CustomFileName" : defaultValue); string expectedCacheFileName = Path.Combine(serverRepository.Source, "CustomFileName.cache.bin"); Assert.True(File.Exists(expectedCacheFileName)); } }
public async Task ServerPackageRepository_CustomCacheFileNameNotConfigured_UseMachineNameAsFileName(string fileNameFromConfig) { using (var temporaryDirectory = new TemporaryDirectory()) { ServerPackageRepository serverRepository = await CreateServerPackageRepositoryAsync( temporaryDirectory.Path, getSetting : (key, defaultValue) => key == "cacheFileName"?fileNameFromConfig : defaultValue); string expectedCacheFileName = Path.Combine(serverRepository.Source, Environment.MachineName.ToLowerInvariant() + ".cache.bin"); Assert.True(File.Exists(expectedCacheFileName)); } }
public ServerPackageRepository CreateServerPackageRepository( string path, ServerPackageRepositoryConfig config, Action <ExpandedPackageRepository> setupRepository = null) { config.RootPath = path; var expandedPackageRepository = new ExpandedPackageRepository(config); setupRepository?.Invoke(expandedPackageRepository); var serverRepository = new ServerPackageRepository( innerRepository: expandedPackageRepository, serverConfig: config); serverRepository.GetPackages(); // caches the files return(serverRepository); }
public ServerPackageRepository CreateServerPackageRepository(string path, Action <ExpandedPackageRepository> setupRepository = null, Func <string, bool, bool> getSetting = null) { var fileSystem = new PhysicalFileSystem(path); var expandedPackageRepository = new ExpandedPackageRepository(fileSystem); if (setupRepository != null) { setupRepository(expandedPackageRepository); } var serverRepository = new ServerPackageRepository( fileSystem, runBackgroundTasks: false, innerRepository: expandedPackageRepository, logger: new Logging.NullLogger(), getSetting: getSetting); serverRepository.GetPackages(); // caches the files return(serverRepository); }
public static async Task <ServerPackageRepository> CreateServerPackageRepositoryAsync( string path, Action <ExpandedPackageRepository> setupRepository = null, Func <string, object, object> getSetting = null) { var fileSystem = new PhysicalFileSystem(path); var expandedPackageRepository = new ExpandedPackageRepository(fileSystem); setupRepository?.Invoke(expandedPackageRepository); var serverRepository = new ServerPackageRepository( fileSystem, runBackgroundTasks: false, innerRepository: expandedPackageRepository, logger: new Infrastructure.NullLogger(), settingsProvider: getSetting != null ? new FuncSettingsProvider(getSetting) : null); await serverRepository.GetPackagesAsync(ClientCompatibility.Max, Token); // caches the files return(serverRepository); }
public void ServerPackageRepositoryReadsDerivedData() { // Arrange var mockProjectSystem = new Mock <MockProjectSystem>() { CallBase = true }; var package = new PackageBuilder() { Id = "Test", Version = new SemanticVersion("1.0"), Description = "Description" }; var mockFile = new Mock <IPackageFile>(); mockFile.Setup(m => m.Path).Returns("foo"); mockFile.Setup(m => m.GetStream()).Returns(new MemoryStream()); package.Files.Add(mockFile.Object); package.Authors.Add("Test Author"); var memoryStream = new MemoryStream(); package.Save(memoryStream); memoryStream.Seek(0, SeekOrigin.Begin); mockProjectSystem.Object.AddFile("foo.nupkg"); mockProjectSystem.Setup(c => c.OpenFile(It.IsAny <string>())).Returns(() => new MemoryStream(memoryStream.ToArray())); var serverRepository = new ServerPackageRepository(new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object); serverRepository.HashProvider = GetHashProvider(); // Act var packages = serverRepository.GetPackagesWithDerivedData(); // Assert byte[] data = memoryStream.ToArray(); Assert.Equal(data.Length, packages.Single().PackageSize); Assert.Equal(data.Select(Invert).ToArray(), Convert.FromBase64String(packages.Single().PackageHash).ToArray()); //CollectionAssert.AreEquivalent(data.Select(Invert).ToArray(), Convert.FromBase64String(packages.Single().PackageHash)); Assert.Equal(data.Length, packages.Single().PackageSize); }
public override void Load() { Bind <ISymbolsPathResolver>().To <SymbolsPathResolver>(); Bind <ISymbolPackagePathResolver>().To <SymbolPackagePathResolver>(); Bind <IToolPathResolver>().To <ToolPathResolver>(); Bind <IPackageAuthenticationService>().To <PackageAuthenticationService>(); var serverPackageRepository = new ServerPackageRepository ( NuPeekConfiguration.NugetPackagePath, new CryptoHashProvider(), new TraceLogger() ); Bind <IServerPackageRepository>().ToConstant(serverPackageRepository); var symbolPackageService = new SymbolPackageService ( new ServerPackageRepository ( NuPeekConfiguration.SymbolPackagePath, new CryptoHashProvider(), new TraceLogger() ), Kernel.Get <IPackageAuthenticationService>() ); Bind <SymbolPackageService>().ToConstant(symbolPackageService); var symbolService = new SymbolService ( Kernel.Get <PackageService>(), symbolPackageService, Kernel.Get <ISymbolsPathResolver>(), Kernel.Get <ISymbolPackagePathResolver>(), Kernel.Get <SymbolTools>() ); Bind <SymbolService>().ToConstant(symbolService); }
public void ServerPackageRepositoryEmptyRepo() { // Arrange var mockProjectSystem = new Mock <MockProjectSystem>() { CallBase = true }; _packageStreams = new Dictionary <string, MemoryStream>(); var serverRepository = new ServerPackageRepository(new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object); serverRepository.HashProvider = GetHashProvider(); var package = CreatePackage("test", "1.0"); // Act var findPackage = serverRepository.FindPackage("test", new SemanticVersion("1.0")); var findPackagesById = serverRepository.FindPackagesById("test"); var getMetadataPackage = serverRepository.GetMetadataPackage(package); var getPackages = serverRepository.GetPackages().ToList(); var getPackagesWithDerivedData = serverRepository.GetPackagesWithDerivedData().ToList(); var getUpdates = serverRepository.GetUpdates(Enumerable.Empty <IPackageName>(), true, true, Enumerable.Empty <FrameworkName>(), Enumerable.Empty <IVersionSpec>()); var search = serverRepository.Search("test", true).ToList(); var source = serverRepository.Source; // Assert Assert.Null(findPackage); Assert.Empty(findPackagesById); Assert.Null(getMetadataPackage); Assert.Empty(getPackages); Assert.Null(getMetadataPackage); Assert.Empty(getPackagesWithDerivedData); Assert.Empty(getUpdates); Assert.Empty(search); Assert.NotEmpty(source); }
public void ServerPackageRepositoryRemovePackage() { // Arrange var mockProjectSystem = new Mock <MockProjectSystem>() { CallBase = true }; _packageStreams = new Dictionary <string, MemoryStream>(); AddPackage(mockProjectSystem, "test", "1.11"); AddPackage(mockProjectSystem, "test", "1.9"); AddPackage(mockProjectSystem, "test", "2.0-alpha"); var serverRepository = new ServerPackageRepository(new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object); serverRepository.HashProvider = GetHashProvider(); var package = CreatePackage("test", "1.11"); var package2 = CreatePackage("test", "2.0-alpha"); // call to cache the first time var packages = serverRepository.GetPackagesWithDerivedData(); // Act serverRepository.RemovePackage(package); serverRepository.RemovePackage(package2); packages = serverRepository.GetPackagesWithDerivedData(); // Assert Assert.Equal(1, packages.Count()); Assert.Equal(1, packages.Where(p => p.IsLatestVersion).Count()); Assert.Equal("1.9", packages.Where(p => p.IsLatestVersion).First().Version); Assert.Equal(1, packages.Where(p => p.IsAbsoluteLatestVersion).Count()); Assert.Equal("1.9", packages.Where(p => p.IsAbsoluteLatestVersion).First().Version); }