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