public void TestMetadataSerDe()
        {
            using var tempDir = new TemporaryDirectory();
            var metadata = new DependencyProviderUtils.Metadata
            {
                AssemblyProbingPaths = new string[] { "/assembly/probe/path" },
                NativeProbingPaths   = new string[] { "/native/probe/path" },
                NuGets = new DependencyProviderUtils.NuGetMetadata[]
                {
                    new DependencyProviderUtils.NuGetMetadata
                    {
                        FileName       = "package.name.1.0.0.nupkg",
                        PackageName    = "package.name",
                        PackageVersion = "1.0.0"
                    }
                }
            };

            string serializedFilePath = Path.Combine(tempDir.Path, "serializedMetadata");

            metadata.Serialize(serializedFilePath);

            DependencyProviderUtils.Metadata deserializedMetadata =
                DependencyProviderUtils.Metadata.Deserialize(serializedFilePath);

            Assert.True(metadata.Equals(deserializedMetadata));
        }
        public void TestMetadataEquals()
        {
            string expectedAssemblyProbingPath = "/assembly/probe/path";
            string expectedNativeProbingPath   = "/native/probe/path";
            var    expectedNugetMetadata       = new DependencyProviderUtils.NuGetMetadata
            {
                FileName       = "package.name.1.0.0.nupkg",
                PackageName    = "package.name",
                PackageVersion = "1.0.0"
            };

            var metadata = new DependencyProviderUtils.Metadata
            {
                AssemblyProbingPaths = new string[] { expectedAssemblyProbingPath },
                NativeProbingPaths   = new string[] { expectedNativeProbingPath },
                NuGets = new DependencyProviderUtils.NuGetMetadata[] { expectedNugetMetadata }
            };

            Assert.False(metadata.Equals(null));
            Assert.False(metadata.Equals(new DependencyProviderUtils.Metadata()));
            Assert.False(metadata.Equals(new DependencyProviderUtils.Metadata
            {
                AssemblyProbingPaths = new string[] { expectedAssemblyProbingPath },
                NativeProbingPaths   = new string[] { expectedNativeProbingPath, "" },
                NuGets = new DependencyProviderUtils.NuGetMetadata[] { expectedNugetMetadata }
            }));
            Assert.False(metadata.Equals(new DependencyProviderUtils.Metadata
            {
                AssemblyProbingPaths = new string[] { expectedAssemblyProbingPath },
                NativeProbingPaths   = new string[] { expectedNativeProbingPath },
                NuGets = new DependencyProviderUtils.NuGetMetadata[] { expectedNugetMetadata, null }
            }));
            Assert.False(metadata.Equals(new DependencyProviderUtils.Metadata
            {
                AssemblyProbingPaths = new string[] { expectedAssemblyProbingPath, "" },
                NativeProbingPaths   = new string[] { expectedNativeProbingPath },
                NuGets = new DependencyProviderUtils.NuGetMetadata[] { expectedNugetMetadata }
            }));

            Assert.True(metadata.Equals(new DependencyProviderUtils.Metadata
            {
                AssemblyProbingPaths = new string[] { expectedAssemblyProbingPath },
                NativeProbingPaths   = new string[] { expectedNativeProbingPath },
                NuGets = new DependencyProviderUtils.NuGetMetadata[] { expectedNugetMetadata }
            }));
        }
예제 #3
0
        public void TestPackageResolver()
        {
            using var tempDir = new TemporaryDirectory();

            string packageName     = "package.name";
            string packageVersion  = "0.1.0";
            string packageRootPath =
                Path.Combine(tempDir.Path, "path", "to", "packages", packageName, packageVersion);
            string packageFrameworkPath = Path.Combine(packageRootPath, "lib", "framework");

            Directory.CreateDirectory(packageRootPath);
            var nugetFile = new FileInfo(
                Path.Combine(packageRootPath, $"{packageName}.{packageVersion}.nupkg"));

            using (File.Create(nugetFile.FullName))
            {
            }

            var assemblyPaths = new List <FileInfo>
            {
                new FileInfo(Path.Combine(packageFrameworkPath, "1.dll")),
                new FileInfo(Path.Combine(packageFrameworkPath, "2.dll"))
            };
            var probingPaths = new List <DirectoryInfo> {
                new DirectoryInfo(packageRootPath)
            };

            var mockPackageRestoreContextWrapper = new Mock <PackageRestoreContextWrapper>();

            mockPackageRestoreContextWrapper
            .SetupGet(m => m.ResolvedPackageReferences)
            .Returns(new ResolvedPackageReference[]
            {
                new ResolvedPackageReference(
                    packageName,
                    packageVersion,
                    assemblyPaths,
                    new DirectoryInfo(packageRootPath),
                    probingPaths)
            });

            var packageResolver = new PackageResolver(mockPackageRestoreContextWrapper.Object);
            IEnumerable <string> actualFiles = packageResolver.GetFiles(tempDir.Path);

            string metadataFilePath =
                Path.Combine(tempDir.Path, DependencyProviderUtils.CreateFileName(1));
            var expectedFiles = new string[]
            {
                nugetFile.FullName,
                metadataFilePath
            };

            Assert.True(expectedFiles.SequenceEqual(actualFiles));
            Assert.True(File.Exists(metadataFilePath));

            DependencyProviderUtils.Metadata actualMetadata =
                DependencyProviderUtils.Metadata.Deserialize(metadataFilePath);
            var expectedMetadata = new DependencyProviderUtils.Metadata
            {
                AssemblyProbingPaths = new string[]
                {
                    Path.Combine(packageName, packageVersion, "lib", "framework", "1.dll"),
                    Path.Combine(packageName, packageVersion, "lib", "framework", "2.dll")
                },
                NativeProbingPaths = new string[]
                {
                    Path.Combine(packageName, packageVersion)
                },
                NuGets = new DependencyProviderUtils.NuGetMetadata[]
                {
                    new DependencyProviderUtils.NuGetMetadata
                    {
                        FileName       = $"{packageName}.{packageVersion}.nupkg",
                        PackageName    = packageName,
                        PackageVersion = packageVersion
                    }
                }
            };

            Assert.True(expectedMetadata.Equals(actualMetadata));
        }