public IPackageObject FindPackage(string path, IPackageReference packageRef) { Guard.AgainstNullArgument("packageRef", packageRef); var repository = new LocalPackageRepository(path); var package = packageRef.Version != null ? repository.FindPackage(packageRef.PackageId, new SemanticVersion(packageRef.Version, packageRef.SpecialVersion), true, true) : repository.FindPackage(packageRef.PackageId); return(package == null ? null : new PackageObject(package, packageRef.FrameworkName)); }
/*<summary> * Using Nuget.Core API, we gather all nuget`s packages that specific project depend on them. * </summary> * <returns></returns> */ private static void addDependencies(string projectName, Module module, string localSource, string[] packageConfigPath, string Configuration) { if (packageConfigPath.Length != 0) { var sharedPackages = new LocalPackageRepository(localSource); var packageReferenceFile = new PackageReferenceFile(packageConfigPath[0]); IEnumerable <PackageReference> projectPackages = packageReferenceFile.GetPackageReferences(); foreach (PackageReference package in projectPackages) { var pack = sharedPackages.FindPackage(package.Id, package.Version); using (Stream packageStream = ((NuGet.OptimizedZipPackage)(pack)).GetStream()) { byte[] buf = new byte[packageStream.Length]; int byteread = packageStream.Read(buf, 0, buf.Length); module.Dependencies.Add(new Dependency { type = "nupkg", md5 = MD5CheckSum.GenerateMD5(buf), sha1 = Sha1Reference.GenerateSHA1(buf), scopes = new List <string> { Configuration }, id = pack.Id + ":" + pack.Version }); } } } }
static void OutputGraph(LocalPackageRepository repository, IEnumerable <IPackage> packages, int depth, int maxDepth) { foreach (IPackage package in packages) { Console.WriteLine("{0}{1} v{2}", new string(' ', depth * 3), package.Id, package.Version); IList <IPackage> dependentPackages = new List <IPackage>(); foreach (var dependencySet in package.DependencySets) { foreach (var dependency in dependencySet.Dependencies) { var dependentPackage = repository.FindPackage(dependency.Id, dependency.VersionSpec, true, true); if (dependentPackage != null) { dependentPackages.Add(dependentPackage); } } } if (depth < maxDepth) { OutputGraph(repository, dependentPackages, depth + 1, maxDepth); } } }
private IPackage ReadPackage(string packageName) { var path = Path.Combine(TestRootPath, packageName, "bin/Debug"); var repository = new LocalPackageRepository(path); return(repository.FindPackage(packageName)); }
public void FindPackageReturnsPackagesWithDotInId() { // Arrange var repositoryRoot = CreatePackage("Test", "1.0.0", @"Test.1.0.0.nupkg"); CreatePackage("Test", "1.2.0", @"SubDir\Test.1.0.0.nupkg"); CreatePackage("test.extensions", "1.0", "Test.Extensions.1.0.0.0.nupkg", repositoryRoot); CreatePackage("test.extensions", "1.3.0-alpha", "Test.Extensions.1.3.0-alpha.nupkg", repositoryRoot); var repository = new LocalPackageRepository(repositoryRoot); // Act var result1 = repository.FindPackage("test.extensions", new SemanticVersion("1.0")); var result2 = repository.FindPackage("test.extensions", new SemanticVersion("1.3-alpha")); // Assert AssertPackage("test.extensions", "1.0", result1); AssertPackage("test.extensions", "1.3.0-alpha", result2); }
public void FindPackageReturnsPackageWithVersionedFileNameAtRoot(string id, string version, string packageName) { // Arrange var repositoryRoot = CreatePackage(id, version, packageName); var repository = new LocalPackageRepository(repositoryRoot); // Act var findPackage = repository.FindPackage(id, new SemanticVersion(version)); // Assert AssertPackage(id, version, findPackage); }
public void FindPackageReturnsPackageWithVersionedFileNameAtRoot(string id, string version, string packageName) { // Arrange var repositoryRoot = CreatePackage(id, version, packageName); var repository = new LocalPackageRepository(repositoryRoot); // Act var findPackage = repository.FindPackage(id, new SemanticVersion(version)); // Assert AssertPackage(id, version, findPackage); }
internal PackageEngine(FileInfo localPackage) : this() { var dir = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), "LocalTemplates")); localPackage.CopyTo(Path.Combine(dir.FullName, localPackage.Name), true); Repository = new LocalPackageRepository(dir.FullName, true); Manager = new PackageManager(Repository, Resolver, FileSystem); Package = Repository.FindPackage(localPackage.Name.Replace(localPackage.Extension, string.Empty), new VersionSpec() { MinVersion = new SemanticVersion(0, 0, 0, 0) }, true, true); }
//================================================================ #region Getting the package from NuGet private InstalledPackage TryGetPackageFromNuGetCache(PackageRequest request, FileSyncer binFileSyncer) { var sw = Stopwatch.StartNew(); // Use cache only if not deploying from source and an exact version is specified: if (request.Source != null) { return(null); } var requestVersionsRange = !string.IsNullOrEmpty(request.VersionsRange) ? VersionUtility.ParseVersionSpec(request.VersionsRange) : new VersionSpec(); if (requestVersionsRange.MinVersion == null || requestVersionsRange.MinVersion.Equals(new SemanticVersion("0.0")) || requestVersionsRange.MinVersion != requestVersionsRange.MaxVersion) { _logger.Trace(() => $"Not looking for {request.ReportIdVersionsRange()} in packages cache because the request does not specify an exact version."); return(null); } // Find the NuGet package: var nugetRepository = new LocalPackageRepository(Paths.PackagesCacheFolder, enableCaching: false); IPackage package = nugetRepository.FindPackage(request.Id, requestVersionsRange, allowPrereleaseVersions: true, allowUnlisted: true); _performanceLogger.Write(sw, () => $"PackageDownloader: {(package == null ? "Did not find" : "Found")} the NuGet package {request.ReportIdVersionsRange()} in cache."); if (package == null) { return(null); } // Copy binary files and resources: string packageSubfolder = nugetRepository.PathResolver.GetPackageDirectory(request.Id, requestVersionsRange.MinVersion); _deployPackagesLogger.Trace(() => $"Reading package from cache '{packageSubfolder}'."); string targetFolder = Path.Combine(Paths.PackagesCacheFolder, packageSubfolder); foreach (var file in FilterCompatibleLibFiles(package.GetFiles())) { binFileSyncer.AddFile(Path.Combine(targetFolder, file.Path), Paths.PluginsFolder, Path.Combine(Paths.PluginsFolder, file.EffectivePath)); } binFileSyncer.AddFolderContent(Path.Combine(targetFolder, "Plugins"), Paths.PluginsFolder, recursive: false); // Obsolete bin folder; lib should be used instead. binFileSyncer.AddFolderContent(Path.Combine(targetFolder, "Resources"), Paths.ResourcesFolder, SimplifyPackageName(package.Id), recursive: true); return(new InstalledPackage(package.Id, package.Version.ToString(), GetNuGetPackageDependencies(package), targetFolder, request, Paths.PackagesCacheFolder)); }
public void FindPackageReturnsPackageWithUnVersionedFileNameWhenUsingVersionlessPathResolver(string id, string version, string packageName) { // Arrange var repositoryRoot = CreatePackage(id, version, packageName); var fileSystem = new PhysicalFileSystem(repositoryRoot); var pathResolver = new DefaultPackagePathResolver(fileSystem, useSideBySidePaths: false); var repository = new LocalPackageRepository(pathResolver, fileSystem); // Act var findPackage = repository.FindPackage(id, new SemanticVersion(version)); // Assert AssertPackage(id, version, findPackage); }
private IPackage FindCandidate(string name, SemanticVersion version) { if (version == null) { return(_repository.FindPackagesById(name).FirstOrDefault()); } else if (version.IsSnapshot) { return(_repository.FindPackagesById(name) .OrderByDescending(pk => pk.Version.SpecialVersion, StringComparer.OrdinalIgnoreCase) .FirstOrDefault(pk => pk.Version.EqualsSnapshot(version))); } return(_repository.FindPackage(name, version)); }
public void FindPackageReturnsPackageWithUnVersionedFileNameWhenUsingVersionlessPathResolver(string id, string version, string packageName) { // Arrange var repositoryRoot = CreatePackage(id, version, packageName); var fileSystem = new PhysicalFileSystem(repositoryRoot); var pathResolver = new DefaultPackagePathResolver(fileSystem, useSideBySidePaths: false); var repository = new LocalPackageRepository(pathResolver, fileSystem); // Act var findPackage = repository.FindPackage(id, new SemanticVersion(version)); // Assert AssertPackage(id, version, findPackage); }
static void OutputGraph(LocalPackageRepository repository, IEnumerable <IPackage> packages, int depth) { foreach (IPackage package in packages) { Console.WriteLine("{0}{1} v{2}", new string(' ', depth), package.Id, package.Version); IList <IPackage> dependentPackages = new List <IPackage>(); foreach (var dependency in package.Dependencies) { dependentPackages.Add(repository.FindPackage(dependency.Id, dependency.VersionSpec.ToString())); } OutputGraph(repository, dependentPackages, depth += 3); } }
//================================================================ #region Getting the package from NuGet private InstalledPackage TryGetPackageFromNuGetCache(PackageRequest request, FileSyncer binFileSyncer) { // Use cache only if not deploying from source and an exact version is specified: if (request.Source != null) { return(null); } var requestVersionsRange = !string.IsNullOrEmpty(request.VersionsRange) ? VersionUtility.ParseVersionSpec(request.VersionsRange) : new VersionSpec(); // Default NuGet behavior is to download the smallest version in the given range, so only MinVersion is checked here: if (!SpecifiedMinVersion(requestVersionsRange)) { _logger.Trace(() => $"Not looking for {request.ReportIdVersionsRange()} in packages cache because the request does not specify an exact version."); return(null); } // Find the NuGet package: var nugetRepository = new LocalPackageRepository(_packagesCacheFolder, enableCaching: false); IPackage package = nugetRepository.FindPackage(request.Id, requestVersionsRange, allowPrereleaseVersions: true, allowUnlisted: true); if (package == null) { _logger.Trace(() => $"Did not find NuGet package {request.ReportIdVersionsRange()} in cache."); return(null); } // Copy binary files: string packageSubfolder = nugetRepository.PathResolver.GetPackageDirectory(request.Id, package.Version); _logger.Trace(() => $"Reading package {request.Id} from cache '{packageSubfolder}'."); _logger.Info(() => $"Reading {request.Id} from cache."); string targetFolder = Path.Combine(_packagesCacheFolder, packageSubfolder); foreach (var file in FilterCompatibleLibFiles(package.GetFiles())) { binFileSyncer.AddFile(Path.Combine(targetFolder, file.Path), Paths.PluginsFolder, Path.Combine(Paths.PluginsFolder, file.EffectivePath)); } binFileSyncer.AddFolderContent(Path.Combine(targetFolder, "Plugins"), Paths.PluginsFolder, recursive: false); // Obsolete bin folder; lib should be used instead. return(new InstalledPackage(package.Id, package.Version.ToString(), GetNuGetPackageDependencies(package), targetFolder, request, _packagesCacheFolder)); }
public static IList <Package> Collect(string projectFolder) { string packageReferenceFilePath = Path.Combine(projectFolder, "packages.config"); if (!File.Exists(packageReferenceFilePath)) { return(new List <Package>()); } string solutionFolder = Path.GetFullPath(Path.Combine(projectFolder, @"..\")); string packageRepositoryPath = Path.Combine(solutionFolder, "packages"); var packageReferences = new PackageReferenceFile(packageReferenceFilePath); var packageRepository = new LocalPackageRepository(packageRepositoryPath); var packages = new List <Package>(); foreach (var packageReference in packageReferences.GetPackageReferences()) { string packageId = packageReference.Id; if (ExcludedPackageNames.Any(w => packageId.ToLower().Contains(w.ToLower()))) { continue; } var package = new Package { Name = packageId, Version = packageReference.Version.Version.ToString(), TargetFramework = packageReference?.TargetFramework?.Version?.ToString() }; // Try to get remaining attributes from local package store var nugetPackage = packageRepository.FindPackage(packageId, packageReference.Version); if (nugetPackage != null) { package.Summary = nugetPackage.Summary; package.Description = nugetPackage.Description; package.Authors = String.Join(",", nugetPackage.Authors); package.IconUrl = nugetPackage.IconUrl; package.ProjectUrl = nugetPackage.ProjectUrl; } packages.Add(package); } return(packages); }
public void RunFromGallery() { Directory.CreateDirectory(_targetDirectory); var client = new HttpClient(DeveloperFeed); client.SendingRequest += (sender, e) => { e.Request.Credentials = _credentials; e.Request.PreAuthenticate = true; }; var remoteRepo = new DataServicePackageRepository(client); var targetRepo = new LocalPackageRepository(_targetDirectory); var packages = remoteRepo.GetPackages() .Where(p => p.IsAbsoluteLatestVersion) .ToList(); Parallel.ForEach(packages, new ParallelOptions { MaxDegreeOfParallelism = 4 }, package => { // Some packages are updated without revving the version. We'll only opt not to re-download // a package if an identical version does not exist on disk. var existingPackage = targetRepo.FindPackage(package.Id, package.Version); var dataServicePackage = (DataServicePackage)package; if (existingPackage == null || !existingPackage.GetHash(dataServicePackage.PackageHashAlgorithm).Equals(dataServicePackage.PackageHash, StringComparison.Ordinal)) { Trace.WriteLine(string.Format("{0}: Adding package {1}", DateTime.Now, package.GetFullName())); var packagePath = GetPackagePath(package); using (var input = package.GetStream()) using (var output = File.Create(packagePath)) { input.CopyTo(output); } PurgeOldVersions(targetRepo, package); } }); }
public ReferenceAttacher(Solution solution) { _solution = solution; _repository = new LocalPackageRepository(_solution.PackagesDirectory()); _packages = new Cache <string, IPackage>(name => { try { return(_repository.FindPackage(name)); } catch (Exception) { return(null); } }); _toolsVersionMatch["4.0"] = "net40"; }
private static void ReportDependencyPackage(LocalPackageRepository repository, List <Dependency> dependencies, IPackage package, HashSet <string> packageCollection) { Dependency targetDependency = new Dependency(); dependencies.Add(targetDependency); targetDependency.key = "nuget:" + package.Id; targetDependency.name = package.Id; targetDependency.versions.Add(package.Version.ToString()); //versions = new List<string> { package.Version.ToString() }, //targetDependency.description = package.Description, //homepageUrl = package.ProjectUrl?.AbsoluteUri, //targetDependency.name = projectLibrary.FrameworkName.ToString(); //targetDependency.key = $"netframework:{projectLibrary.FrameworkName.ToString()}"; // We let add duplicate package in our Dependency tree, but won't allow its further children. if (packageCollection.Contains(package.GetFullName())) { return; } packageCollection.Add(package.GetFullName()); foreach (var dependencySet in package.DependencySets) { foreach (var dependency in dependencySet.Dependencies) { IPackage dependentPackage = repository.FindPackage(dependency.Id, dependency.VersionSpec, true, true); if (dependentPackage != null) { ReportDependencyPackage(repository, targetDependency.dependencies, dependentPackage, packageCollection); } } } }
public void FindPackageMatchesExactVersion() { // Arrange string id = "Test"; string version = "1.3.1.0"; string packageName = "Test.1.3.1.nupkg"; var repositoryRoot = CreatePackage(id, version, packageName); CreatePackage(id, "1.3.4", "Test.nupkg", repositoryRoot); // Create dummy files. Attempting to open these packages would throw, so we know we're not opening it. File.WriteAllText(Path.Combine(repositoryRoot, "Test.1.3.2.nupkg"), ""); File.WriteAllText(Path.Combine(repositoryRoot, "Test.1.3.nupkg"), ""); File.WriteAllText(Path.Combine(repositoryRoot, "Test.1.31.nupkg"), ""); var repository = new LocalPackageRepository(repositoryRoot); // Act var findPackage = repository.FindPackage(id, new SemanticVersion(version)); // Assert AssertPackage(id, version, findPackage); }
public void FindPackageReturnsPackagesFromNestedDirectories() { // Arrange string id = "Test"; string version = "1.3.1.0"; string packageName = @"SubDir\Test.1.3.1.nupkg"; var repositoryRoot = CreatePackage(id, version, packageName); CreatePackage(id, "1.3.4", "Test.nupkg", repositoryRoot); // Create dummy files. Attempting to open these packages would throw, so we know we're not opening it. File.WriteAllText(Path.Combine(repositoryRoot, "Test.1.3.2.nupkg"), ""); File.WriteAllText(Path.Combine(repositoryRoot, "Test.1.3.nupkg"), ""); File.WriteAllText(Path.Combine(repositoryRoot, "Test.1.31.nupkg"), ""); var repository = new LocalPackageRepository(repositoryRoot); // Act var findPackage = repository.FindPackage(id, new SemanticVersion(version)); // Assert AssertPackage(id, version, findPackage); }
static void OutputGraph(LocalPackageRepository repository, IEnumerable <IPackage> packages, int depth, ECSDependecy basePkg) { foreach (IPackage package in packages) { ECSDependecy dep = new ECSDependecy { versions = new List <string> { package.Version.ToString() }, key = "nuget:" + package.Id, name = package.Id, //package.Title == null ? package.Title : package.Id, description = package.Description, homepageUrl = package.ProjectUrl?.AbsoluteUri, dependencies = new List <ECSDependecy>(), licenses = new List <License> { }, }; dep.licenses.Add(new License { name = "unknown", url = package.LicenseUrl?.AbsoluteUri }); Console.WriteLine("{0}{1} v{2}", new string(' ', depth), package.Id, package.Version); basePkg.dependencies.Add(dep); IList <IPackage> dependentPackages = new List <IPackage>(); foreach (var dependencySet in package.DependencySets) { foreach (var dependency in dependencySet.Dependencies) { dependentPackages.Add(repository.FindPackage(dependency.Id, dependency.VersionSpec, true, true)); } } OutputGraph(repository, dependentPackages, depth + 3, dep); } }
public static ScriptExtensions CompileAssembly(PackageConfiguration configuration, string editorRepositoryPath, bool includeDebugInformation) { var path = Environment.CurrentDirectory; var configurationRoot = ConfigurationHelper.GetConfigurationRoot(configuration); var scriptProjectFile = Path.Combine(path, Path.ChangeExtension(OutputAssemblyName, ProjectExtension)); if (!File.Exists(scriptProjectFile)) { return(new ScriptExtensions(configuration, null)); } var extensionsPath = Path.Combine(path, OutputAssemblyName); if (!Directory.Exists(extensionsPath)) { return(new ScriptExtensions(configuration, null)); } var scriptFiles = Directory.GetFiles(extensionsPath, ScriptExtension, SearchOption.AllDirectories); if (scriptFiles.Length == 0) { return(new ScriptExtensions(configuration, null)); } var assemblyNames = new HashSet <string>(); var assemblyDirectory = Path.GetTempPath() + OutputAssemblyName + "." + Guid.NewGuid().ToString(); var scriptEnvironment = new ScriptExtensions(configuration, assemblyDirectory); var packageRepository = new LocalPackageRepository(editorRepositoryPath); var projectReferences = from id in scriptEnvironment.GetPackageReferences() let package = packageRepository.FindPackage(id) where package != null from assemblyReference in FindAssemblyReferences(packageRepository, package) select assemblyReference; assemblyNames.AddRange(scriptEnvironment.GetAssemblyReferences()); assemblyNames.AddRange(projectReferences); var assemblyFile = Path.Combine(assemblyDirectory, Path.ChangeExtension(OutputAssemblyName, DllExtension)); var assemblyReferences = (from fileName in assemblyNames let assemblyName = Path.GetFileNameWithoutExtension(fileName) let assemblyLocation = ConfigurationHelper.GetAssemblyLocation(configuration, assemblyName) select assemblyLocation == null ? fileName : Path.IsPathRooted(assemblyLocation) ? assemblyLocation : Path.Combine(configurationRoot, assemblyLocation)) .ToArray(); var compilerParameters = new CompilerParameters(assemblyReferences, assemblyFile); compilerParameters.GenerateExecutable = false; compilerParameters.GenerateInMemory = false; compilerParameters.IncludeDebugInformation = includeDebugInformation; if (!includeDebugInformation) { compilerParameters.CompilerOptions = "/optimize"; } using (var codeProvider = new CSharpCodeProvider()) { var results = codeProvider.CompileAssemblyFromFile(compilerParameters, scriptFiles); if (results.Errors.HasErrors) { try { Console.Error.WriteLine("--- Error building script extensions ---"); foreach (var error in results.Errors) { Console.Error.WriteLine(error); } } finally { scriptEnvironment.Dispose(); } return(new ScriptExtensions(configuration, null)); } else { var assemblyName = AssemblyName.GetAssemblyName(assemblyFile); configuration.AssemblyReferences.Add(assemblyName.Name); configuration.AssemblyLocations.Add(assemblyName.Name, ProcessorArchitecture.MSIL, assemblyName.CodeBase); scriptEnvironment.AssemblyName = assemblyName; } return(scriptEnvironment); } }
private static void Do(LocalPackageRepository inputRepository, PackageManager inputManager, IPackage package, string cacheDirectory, IEnumerable <string> references, string outputDirectory) { Console.WriteLine("--- Building {0} ---", package.GetFullName()); var solution = new ProjectCollection(); var logger = new ConsoleLogger(); logger.Verbosity = LoggerVerbosity.Minimal; inputManager.InstallPackage(package, false, false); var packageDirectory = Path.Combine(cacheDirectory, package.Id); var moduleDirectory = Directory.GetDirectories(Path.Combine(packageDirectory, "Content", "Modules"))[0]; var moduleName = Path.GetFileName(moduleDirectory); var project = solution.LoadProject(Path.Combine(moduleDirectory, moduleName + ".csproj")); var candidateDirectories = references .Select(r => Path.Combine(cacheDirectory, r)) .Concat(Directory.EnumerateDirectories(cacheDirectory).Where(d => !Path.GetFileName(d).StartsWith("Orchard."))) .Join(new[] { "net40-full", "net40", "net35", "net20", "net", "" }, l => true, r => true, (l, r) => Path.Combine(l, "lib", r)) .Where(Directory.Exists) .ToList(); foreach (var item in GetReferences(project).ToList()) { var referenceName = GetReferenceName(item); var referenceDirectory = candidateDirectories.FirstOrDefault(d => File.Exists(Path.Combine(d, referenceName + ".dll"))); if (referenceDirectory != null) { Console.WriteLine("Replacing reference {0} with {1}", referenceName, referenceDirectory); ReplaceReference(project, item, referenceName, referenceDirectory); } } var dependencies = new List <ManifestDependency>(); foreach (var item in GetModuleReferences(project).ToList()) { var referencedModuleName = item.GetMetadataValue("Name"); var referencedPackageId = "Orchard.Module." + item.GetMetadataValue("Name"); var referencedPackage = inputRepository.FindPackage(referencedPackageId); Console.WriteLine("Depends on {0}", referencedModuleName); dependencies.Add(new ManifestDependency { Id = referencedPackage.Id, Version = "[" + referencedPackage.Version + "]" }); Do(inputRepository, inputManager, referencedPackage, cacheDirectory, references, outputDirectory); ReplaceReference(project, item, referencedModuleName, Path.Combine(cacheDirectory, referencedPackageId, "Content", "Modules", referencedModuleName, "bin")); } if (!File.Exists(Path.Combine(moduleDirectory, "bin", moduleName + ".dll"))) { if (!project.Build(logger)) { throw new Exception("Failed to build"); } } var rules = new[] { @"bin\" + moduleName + ".dll", @"Module.txt", @"Placement.info", @"Web.config", @"Content\**", @"Scripts\**", @"Recipes\**", @"Styles\**", @"Views\**" }; var manifest = Manifest.Create(package); manifest.Metadata.DependencySets = new List <ManifestDependencySet> { new ManifestDependencySet { Dependencies = dependencies } }; manifest.Files = rules.Select(r => new ManifestFile { Source = @"Content\Modules\" + moduleName + @"\**\" + r, Target = @"Content\Modules\" + moduleName }).ToList(); var builder = new PackageBuilder(); builder.Populate(manifest.Metadata); builder.PopulateFiles(packageDirectory, manifest.Files); Directory.CreateDirectory(outputDirectory); var outputPackgeFileName = Path.Combine(outputDirectory, manifest.Metadata.Id + "." + manifest.Metadata.Version + ".nupkg"); using (var outputPackageFile = File.Create(outputPackgeFileName)) builder.Save(outputPackageFile); }
public void FindPackageMatchesExactVersionIfSideBySideIsEnabled() { // Arrange var fileSystem = new Mock<MockProjectSystem> { CallBase = true }; fileSystem.Setup(c => c.FileExists(It.Is<string>(a => a.Equals(@"A.1.0\A.1.0.nupkg")))).Returns(false); fileSystem.Setup(c => c.FileExists(It.Is<string>(a => a.Equals(@"A.0.8\A.0.8.nupkg")))).Returns(false); fileSystem.Setup(c => c.FileExists(It.Is<string>(a => a.Equals(@"A.1.1\A.1.1.nupkg")))).Returns(true); var repository = new LocalPackageRepository(new DefaultPackagePathResolver(fileSystem.Object, useSideBySidePaths: true), fileSystem.Object, enableCaching: false); var searchedPaths = new List<string>(); Func<string, IPackage> openPackage = p => { searchedPaths.Add(p); string id = Path.GetFileNameWithoutExtension(p); return PackageUtility.CreatePackage("A", "1.1"); }; // Act and Assert IPackage result = repository.FindPackage(openPackage, "A", new SemanticVersion("1.0")); Assert.Null(result); Assert.False(searchedPaths.Any()); result = repository.FindPackage(openPackage, "A", new SemanticVersion("0.8")); Assert.Null(result); Assert.False(searchedPaths.Any()); result = repository.FindPackage(openPackage, "A", new SemanticVersion("1.1")); Assert.Equal(@"A.1.1\A.1.1.nupkg", searchedPaths.Single()); Assert.Equal("A", result.Id); Assert.Equal(new SemanticVersion("1.1"), result.Version); fileSystem.Verify(); }
public void FindPackageReturnsPackagesWithDotInId() { // Arrange var repositoryRoot = CreatePackage("Test", "1.0.0", @"Test.1.0.0.nupkg"); CreatePackage("Test", "1.2.0", @"SubDir\Test.1.0.0.nupkg"); CreatePackage("test.extensions", "1.0", "Test.Extensions.1.0.0.0.nupkg", repositoryRoot); CreatePackage("test.extensions", "1.3.0-alpha", "Test.Extensions.1.3.0-alpha.nupkg", repositoryRoot); var repository = new LocalPackageRepository(repositoryRoot); // Act var result1 = repository.FindPackage("test.extensions", new SemanticVersion("1.0")); var result2 = repository.FindPackage("test.extensions", new SemanticVersion("1.3-alpha")); // Assert AssertPackage("test.extensions", "1.0", result1); AssertPackage("test.extensions", "1.3.0-alpha", result2); }
public void FindPackageMatchesExactVersionIfSideBySideIsDisabled() { // Arrange var fileSystem = new MockFileSystem(); fileSystem.AddFile(PathFixUtility.FixPath(@"A\A.nupkg")); var repository = new LocalPackageRepository(new DefaultPackagePathResolver(fileSystem, useSideBySidePaths: false), fileSystem, enableCaching: false); var searchedPaths = new List<string>(); Func<string, IPackage> openPackage = p => { searchedPaths.Add(p); return PackageUtility.CreatePackage("A", "1.1"); }; // Act and Assert IPackage result = repository.FindPackage(openPackage, "A", new SemanticVersion("1.0")); Assert.Null(result); Assert.Equal(PathFixUtility.FixPath(@"A\A.nupkg"), searchedPaths.Single()); searchedPaths.Clear(); result = repository.FindPackage(openPackage, "A", new SemanticVersion("0.8")); Assert.Null(result); Assert.Equal(PathFixUtility.FixPath(@"A\A.nupkg"), searchedPaths.Single()); searchedPaths.Clear(); result = repository.FindPackage(openPackage, "A", new SemanticVersion("1.1")); Assert.Equal("A", result.Id); Assert.Equal(new SemanticVersion("1.1"), result.Version); }
public void FindPackageVerifiesPackageFileExistsOnFileSystemWhenCaching() { // Arrange var fileSystem = new MockFileSystem(); fileSystem.AddFile(@"A.1.0.0.nupkg"); var repository = new LocalPackageRepository(new DefaultPackagePathResolver(fileSystem, useSideBySidePaths: true), fileSystem, enableCaching: true); var searchedPaths = new List<string>(); Func<string, IPackage> openPackage = p => { searchedPaths.Add(p); return PackageUtility.CreatePackage("A", "1.0"); }; // Act - 1 IPackage result = repository.FindPackage(openPackage, "A", new SemanticVersion("1.0")); // Assert - 1 Assert.NotNull(result); Assert.Equal("A", result.Id); Assert.Equal(new SemanticVersion("1.0"), result.Version); // Act - 2 fileSystem.DeleteFile("A.1.0.0.nupkg"); result = repository.FindPackage(openPackage, "A", new SemanticVersion("1.0")); // Assert - 2 Assert.Null(result); }
public Task <Stream> OpenNupkgStreamAsync(PackageInfo package) { return(Task.FromResult(_repository.FindPackage(package.Id, package.Version).GetStream())); }