public async Task HttpSource_GetJObjectAsync_ThrottlesRequests() { // Arrange using (var td = TestFileSystemUtility.CreateRandomTestFolder()) { var tc = new TestContext(td); tc.SetResponseSequence(new[] { new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{}") }, }); // Act await tc.HttpSource.GetJObjectAsync( new HttpSourceRequest(tc.Url, tc.Logger), tc.Logger, token : CancellationToken.None); // Assert tc.Throttle.Verify(x => x.WaitAsync(), Times.Once); tc.Throttle.Verify(x => x.Release(), Times.Once); } }
public void DeleteDirectory(string path, bool recursive) { var fullPath = Path.Combine(ProjectFullPath, path); // this will delete recursive regadless of input, doesn't matter for testing TestFileSystemUtility.DeleteRandomTestFolder(fullPath); }
public void XProjUtility_DependencyNotFound() { // Arrange using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder()) { var json1 = @"{ ""dependencies"": { ""project2"": ""1.0.0"" } }, ""frameworks"": { ""net46"": {} } }"; var proj1Folder = Path.Combine(workingDir, "project1"); Directory.CreateDirectory(proj1Folder); var path1 = Path.Combine(proj1Folder, "project.json"); File.WriteAllText(path1, json1); var xproj1 = Path.Combine(proj1Folder, "project1.xproj"); File.WriteAllText(xproj1, string.Empty); // Act var references = XProjUtility.GetProjectReferences(xproj1); // Assert Assert.Equal(0, references.Count()); } }
public async Task RestoreResult_WritesSkipCommitToMinimal() { // Arrange using (var td = TestFileSystemUtility.CreateRandomTestFolder()) { var path = Path.Combine(td, "project.lock.json"); var logger = new TestLogger(); var result = new RestoreResult( success: true, restoreGraphs: null, compatibilityCheckResults: null, lockFile: new LockFile(), previousLockFile: new LockFile(), // same lock file lockFilePath: path, msbuild: new MSBuildRestoreResult("project", td, true), toolRestoreResults: Enumerable.Empty <ToolRestoreResult>()); // Act await result.CommitAsync(logger, CancellationToken.None); // Assert Assert.Contains( $"Lock file has not changed. Skipping lock file write. Path: {path}", logger.MinimalMessages); Assert.False(File.Exists(path), $"The lock file should not have been written: {path}"); Assert.Equal(1, logger.Messages.Count); } }
public void ListCommand_WithUserSpecifiedSource() { // Arrange var nugetexe = Util.GetNuGetExePath(); using (var repositoryPath = TestFileSystemUtility.CreateRandomTestFolder()) { Util.CreateTestPackage("testPackage1", "1.1.0", repositoryPath); Util.CreateTestPackage("testPackage2", "2.0.0", repositoryPath); string[] args = new string[] { "list", "-Source", repositoryPath }; // Act var result = CommandRunner.Run( nugetexe, Directory.GetCurrentDirectory(), string.Join(" ", args), waitForExit: true); // Assert Assert.Equal(0, result.Item1); var output = result.Item2; Assert.Equal("testPackage1 1.1.0\r\ntestPackage2 2.0.0\r\n", output); } }
public void RequestFactory_FindConfigInProjectFolder() { // Verifies that we include any config file found in the project folder using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder()) { // Arrange var innerConfigFile = Path.Combine(workingDir, "sub", Settings.DefaultSettingsFileName); var outerConfigFile = Path.Combine(workingDir, Settings.DefaultSettingsFileName); var projectDirectory = Path.GetDirectoryName(innerConfigFile); Directory.CreateDirectory(projectDirectory); File.WriteAllText(innerConfigFile, InnerConfig); File.WriteAllText(outerConfigFile, OuterConfig); var restoreArgs = new RestoreArgs(); // Act var settings = restoreArgs.GetSettings(projectDirectory); var innerValue = settings.GetValue("SectionName", "inner-key"); var outerValue = settings.GetValue("SectionName", "outer-key"); // Assert Assert.Equal("inner-value", innerValue); Assert.Equal("outer-value", outerValue); } }
public void FileUtility_DeleteBasicFail() { using (var testDirectory = TestFileSystemUtility.CreateRandomTestFolder()) { // Arrange var path = Path.Combine(testDirectory, "a"); File.WriteAllText(path, "a"); using (var stream = File.OpenWrite(path)) { // Act & Assert if (RuntimeEnvironmentHelper.IsWindows) { Assert.Throws(typeof(IOException), () => FileUtility.Delete(path)); } else { // Linux and OSX will delete the file without an error FileUtility.Delete(path); Assert.False(File.Exists(path)); } } } }
public void GetSettingValuesEvaluatesEnvironmentVariableWithAbsolutePath() { //Arrange var expectedRepositoryPath = @"/home/log"; if (RuntimeEnvironmentHelper.IsWindows) { expectedRepositoryPath = @"C:\log"; } using (var nugetConfigFileFolder = TestFileSystemUtility.CreateRandomTestFolder()) { var nugetConfigFile = "NuGet.config"; var nugetConfigFilePath = Path.Combine(nugetConfigFileFolder, nugetConfigFile); File.WriteAllText(nugetConfigFilePath, DefaultNuGetConfigurationWithEnvironmentVariable); Environment.SetEnvironmentVariable("RP_ENV_VAR", expectedRepositoryPath); //Act ISettings settings = new Settings(nugetConfigFileFolder, nugetConfigFile); //Assert var settingsForConfig = settings.GetSettingValues("config", isPath: true); Assert.Single(settingsForConfig); Assert.Equal(expectedRepositoryPath, settingsForConfig.Single().Value); } }
public void GetFallbackPackageFolders_MultipleFoldersFromNuGetConfig() { // Arrange var config = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <add key=""d"" value=""C:\Temp\d"" /> <add key=""b"" value=""C:\Temp\b"" /> <add key=""c"" value=""C:\Temp\c"" /> </fallbackPackageFolders> </configuration>"; var nugetConfigPath = "NuGet.Config"; using (var mockBaseDirectory = TestFileSystemUtility.CreateRandomTestFolder()) { ConfigurationFileTestUtility.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, config); Settings settings = new Settings(mockBaseDirectory); // Act var paths = SettingsUtility.GetFallbackPackageFolders(settings).ToArray(); // Assert Assert.Equal(3, paths.Length); Assert.Equal("d", GetFileName(paths[0])); Assert.Equal("b", GetFileName(paths[1])); Assert.Equal("c", GetFileName(paths[2])); } }
public void PackagesConfigWriter_ThrowOnMissingPackagesNode() { // Arrange using (var folderPath = TestFileSystemUtility.CreateRandomTestFolder()) { var filePath = Path.Combine(folderPath, "packages.config"); using (var fileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write)) { using (var fileWriter = new StreamWriter(fileStream)) { string content = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> </configuration> "; fileWriter.Write(content); } } using (PackagesConfigWriter writer = new PackagesConfigWriter(filePath, false)) { // Assert Assert.Throws <PackagesConfigWriterException>(() => writer.AddPackageEntry("packageA", NuGetVersion.Parse("2.0.1"), NuGetFramework.Parse("net4"))); } } }
public void PackagesConfigWriter_NoOldPackagesConfigFileLeftOnDisk() { // Arrange using (var folderPath = TestFileSystemUtility.CreateRandomTestFolder()) { var directoryInfo = new DirectoryInfo(folderPath); var filePath = Path.Combine(folderPath, "packages.config"); using (var fileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write)) { using (var fileWriter = new StreamWriter(fileStream)) { string content = @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id = ""packageA"" version = ""1.0.0"" targetFramework = ""win81"" userInstalled = ""true"" protocolVersion = ""V2"" /> </packages>"; fileWriter.Write(content); } } using (PackagesConfigWriter writer = new PackagesConfigWriter(filePath, false)) { // Act writer.AddPackageEntry("packageB", NuGetVersion.Parse("2.0.1"), NuGetFramework.Parse("net4")); } // Assert var packagesConfigFiles = directoryInfo.GetFiles(). Where(p => p.Name.ToLowerInvariant().Contains("packages.config")); Assert.Equal(1, packagesConfigFiles.Count()); } }
public async Task ProjectKNuGetProject_WithPackageTypes_InstallPackageAsync() { // Arrange using (var testDirectory = TestFileSystemUtility.CreateRandomTestFolder()) { var tc = new TestContext(testDirectory); using (var download = tc.InitializePackage()) { // Act var result = await tc.Target.InstallPackageAsync( tc.PackageIdentity, download, tc.ProjectContext.Object, CancellationToken.None); // Assert Assert.True(result); tc.PackageManager.Verify( x => x.InstallPackageAsync( It.Is <INuGetPackageMoniker>(y => y.Id == tc.PackageIdentity.Id && y.Version == tc.PackageIdentity.Version.ToNormalizedString()), It.Is <IReadOnlyDictionary <string, object> >(y => y.ContainsKey("PackageTypes") && Enumerable.SequenceEqual((IEnumerable <PackageType>)y["PackageTypes"], tc.PackageTypes)), It.IsAny <TextWriter>(), It.IsAny <IProgress <INuGetPackageInstallProgress> >(), It.IsAny <CancellationToken>()), Times.Once); } } }
public void EnsureProjectFactoryDoesNotAddFileThatIsAlreadyInPackage() { // Setup var nugetexe = Util.GetNuGetExePath(); using (var workingDirectory = TestFileSystemUtility.CreateRandomTestFolder()) { // Arrange var projPath = Path.Combine(workingDirectory, "Assembly.csproj"); File.WriteAllText(projPath, GetProjectContent()); File.WriteAllText(Path.Combine(workingDirectory, "Assembly.nuspec"), GetNuspecContent()); File.WriteAllText(Path.Combine(workingDirectory, "Source.cs"), GetSourceFileContent()); // Act var r = CommandRunner.Run( nugetexe, workingDirectory, "pack Assembly.csproj -build", waitForExit: true); // Assert var package = new OptimizedZipPackage(Path.Combine(workingDirectory, "Assembly.1.0.0.nupkg")); var files = package.GetFiles().Select(f => f.Path).ToArray(); Assert.Equal(0, r.Item1); Array.Sort(files); Assert.Equal(files, new[] { @"lib\net45\Assembly.dll", @"lib\net45\Assembly.xml" }); } }
public void TestBuildIntegratedNuGetPackageSpecNameMatchesFilePath() { // Arrange var packageIdentity = new PackageIdentity("packageA", new NuGetVersion("1.0.0")); using (var randomTestPackageSourcePath = TestFileSystemUtility.CreateRandomTestFolder()) using (var randomPackagesFolderPath = TestFileSystemUtility.CreateRandomTestFolder()) using (var randomProjectFolderPath = TestFileSystemUtility.CreateRandomTestFolder()) { var randomConfig = Path.Combine(randomProjectFolderPath, "project.json"); var token = CancellationToken.None; CreateConfigJson(randomConfig); var projectTargetFramework = NuGetFramework.Parse("netcore50"); var testNuGetProjectContext = new TestNuGetProjectContext(); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem( projectTargetFramework, testNuGetProjectContext, randomProjectFolderPath, "msbuildName"); var projectFilePath = Path.Combine(randomProjectFolderPath, "fileName.csproj"); var buildIntegratedProject = new BuildIntegratedNuGetProject(randomConfig, projectFilePath, msBuildNuGetProjectSystem); // Assert Assert.Equal(projectFilePath, buildIntegratedProject.MSBuildProjectPath); Assert.Equal("fileName", buildIntegratedProject.ProjectName); Assert.Equal("fileName", buildIntegratedProject.PackageSpec.Name); } }
public void ConfigCommand_MisconfiguredPluginCredentialProviderDoesNotBlockConfigCommand() { using (var testFolder = TestFileSystemUtility.CreateRandomTestFolder()) { var configFile = Path.Combine(testFolder, "file.tmp"); var missingPluginProvider = Path.Combine(Path.GetTempPath(), "PluginDoesNotExist.exe"); Util.CreateFile(Path.GetDirectoryName(configFile), Path.GetFileName(configFile), "<configuration/>"); string[] args = new string[] { "config", "-Set", $"CredentialProvider.Plugin.BadPlugin={missingPluginProvider}", "-ConfigFile", configFile }; // This call sets a bad credential provider int result = Program.Main(args); // This call should still succeed, since bad credential provider is not used in config commands int result2 = Program.Main(args); // Assert Assert.Equal(0, result); Assert.Equal(0, result2); } }
public void GetFallbackPackageFolders_RelativePathChild() { // Arrange var config = @"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <fallbackPackageFolders> <add key=""shared"" value=""test"" /> </fallbackPackageFolders> </configuration>"; var nugetConfigPath = "NuGet.Config"; using (var mockBaseDirectory = TestFileSystemUtility.CreateRandomTestFolder()) { var testFolder = Path.Combine(mockBaseDirectory, "test"); ConfigurationFileTestUtility.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, config); Settings settings = new Settings(mockBaseDirectory); // Act var paths = SettingsUtility.GetFallbackPackageFolders(settings); // Assert Assert.Equal(testFolder, paths.Single()); } }
public void RestoreCommand_VerifyMinClientVersionV3Source() { // Arrange using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder()) using (var projectDir = TestFileSystemUtility.CreateRandomTestFolder()) { var specPath = Path.Combine(projectDir, "TestProject", "project.json"); var spec = XPlatTestUtils.BasicConfigNetCoreApp; // This package has a minclientversion of 9999 XPlatTestUtils.AddDependency(spec, "TestPackage.MinClientVersion", "1.0.0"); XPlatTestUtils.WriteJson(spec, specPath); var lockFilePath = Path.Combine(projectDir, "project.lock.json"); var log = new TestCommandOutputLogger(); var args = new string[] { "restore", projectDir, "-s", "https://api.nuget.org/v3/index.json", "--packages", packagesDir }; // Act var exitCode = Program.MainInternal(args, log); // Assert Assert.Equal(1, log.Errors); Assert.Contains("'TestPackage.MinClientVersion 1.0.0' package requires NuGet client version '9.9999.0' or above", log.ShowMessages()); Assert.False(File.Exists(lockFilePath)); } }
public void Restore_WithMissingConfigFile_Fails() { using (var projectDir = TestFileSystemUtility.CreateRandomTestFolder()) using (var configDir = TestFileSystemUtility.CreateRandomTestFolder()) { var specPath = Path.Combine(projectDir, "XPlatRestoreTests", "project.json"); var spec = XPlatTestUtils.BasicConfigNetCoreApp; XPlatTestUtils.AddDependency(spec, "costura.fody", "1.3.3"); XPlatTestUtils.AddDependency(spec, "fody", "1.29.4"); XPlatTestUtils.WriteJson(spec, specPath); var log = new TestCommandOutputLogger(); var args = new string[] { "restore", projectDir, "--configfile", Path.Combine(configDir, "DoesNotExist.config"), }; // Act var exitCode = Program.MainInternal(args, log); // Assert Assert.Equal(1, exitCode); Assert.Equal(1, log.Errors); Assert.Contains("DoesNotExist.config", log.ShowErrors()); // file does not exist } }
public async Task RequestFactory_FindProjectJsonFilesInDirectory() { // Arrange var cache = new RestoreCommandProvidersCache(); var provider = new ProjectJsonRestoreRequestProvider(cache); using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder()) { var p1 = Path.Combine(workingDir, "project.json"); var p2 = Path.Combine(workingDir, "sub", "project.json"); var p3 = Path.Combine(workingDir, "myproj.project.json"); Directory.CreateDirectory(Path.GetDirectoryName(p1)); Directory.CreateDirectory(Path.GetDirectoryName(p2)); File.WriteAllText(p1, EmptyProjectJson); File.WriteAllText(p2, EmptyProjectJson); File.WriteAllText(p3, EmptyProjectJson); var context = new RestoreArgs(); context.CacheContext = new SourceCacheContext(); context.Log = new TestLogger(); // Act var supports = await provider.Supports(workingDir); var requests = await provider.CreateRequests(workingDir, context); // Assert Assert.Equal(true, supports); Assert.Equal(3, requests.Count); } }
public async Task Restore_FallbackFolderContainsAllPackages() { using (var sourceDir = TestFileSystemUtility.CreateRandomTestFolder()) using (var fallbackDir1 = TestFileSystemUtility.CreateRandomTestFolder()) using (var fallbackDir2 = TestFileSystemUtility.CreateRandomTestFolder()) using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder()) using (var projectDir = TestFileSystemUtility.CreateRandomTestFolder()) { var specPath = Path.Combine(projectDir, "XPlatRestoreTests", "project.json"); var spec = XPlatTestUtils.BasicConfigNetCoreApp; XPlatTestUtils.AddDependency(spec, "a", "1.0.0"); XPlatTestUtils.AddDependency(spec, "b", "1.0.0"); XPlatTestUtils.WriteJson(spec, specPath); var packageA = new SimpleTestPackageContext("a", "1.0.0"); var packageB = new SimpleTestPackageContext("b", "1.0.0"); var saveMode = PackageSaveMode.Nuspec | PackageSaveMode.Files; await SimpleTestPackageUtility.CreateFolderFeedV3( fallbackDir2, saveMode, packageA, packageB); var log = new TestCommandOutputLogger(); var config = $@"<?xml version=""1.0"" encoding=""utf-8""?> <configuration> <config> <add key=""globalPackagesFolder"" value=""{packagesDir}"" /> </config> <fallbackPackageFolders> <add key=""a"" value=""{fallbackDir1}"" /> <add key=""b"" value=""{fallbackDir2}"" /> </fallbackPackageFolders> <packageSources> <add key=""a"" value=""{sourceDir}"" /> </packageSources> </configuration>"; File.WriteAllText(Path.Combine(projectDir, "NuGet.Config"), config); var args = new string[] { "restore", projectDir, }; // Act var exitCode = Program.MainInternal(args, log); // Assert Assert.Equal(0, exitCode); Assert.Equal(0, log.Errors); Assert.Equal(0, log.Warnings); Assert.Equal(0, Directory.GetDirectories(packagesDir).Length); } }
public async Task PackagePreFetcher_NoInstallActionsInput() { using (var packagesFolderDir = TestFileSystemUtility.CreateRandomTestFolder()) { // Arrange var actions = new List <NuGetProjectAction>(); var packagesFolder = new FolderNuGetProject(packagesFolderDir); var testSettings = new Configuration.NullSettings(); var logger = new TestLogger(); var target = new PackageIdentity("packageA", NuGetVersion.Parse("1.0.0")); var target2 = new PackageIdentity("packageB", NuGetVersion.Parse("1.0.0")); actions.Add(NuGetProjectAction.CreateUninstallProjectAction(target)); actions.Add(NuGetProjectAction.CreateUninstallProjectAction(target2)); // Act var result = await PackagePreFetcher.GetPackagesAsync( actions, packagesFolder, testSettings, logger, CancellationToken.None); // Assert Assert.Equal(0, result.Count); } }
public void InitCommand_Success_DestinationDoesNotExist() { // Arrange using (var testFolder = TestFileSystemUtility.CreateRandomTestFolder()) using (var destinationFolder = TestFileSystemUtility.CreateRandomTestFolder()) using (var testInfo = new TestInfo(testFolder, Path.Combine(destinationFolder, "DoesNotExistSubFolder"))) { var packages = testInfo.AddPackagesToSource(); var args = new string[] { "init", testInfo.SourceFeed, testInfo.DestinationFeed, }; // Act var result = CommandRunner.Run( testInfo.NuGetExePath, testInfo.WorkingPath, string.Join(" ", args), waitForExit: true); // Assert Util.VerifyResultSuccess(result); Util.VerifyPackagesExist(packages, testInfo.DestinationFeed); } }
public async Task LocalDownloadResource_PackageIsReturnedUnzippedFolder() { using (var root = TestFileSystemUtility.CreateRandomTestFolder()) { // Arrange var testLogger = new TestLogger(); var id = new PackageIdentity("a", NuGetVersion.Parse("1.0.0")); SimpleTestPackageUtility.CreateFolderFeedUnzip(root, id); var localResource = new FindLocalPackagesResourceUnzipped(root); var resource = new LocalDownloadResource(localResource); // Act var result = await resource.GetDownloadResourceResultAsync( id, NullSettings.Instance, testLogger, CancellationToken.None); using (var reader = result.PackageReader) using (var stream = result.PackageStream) { // Assert Assert.Equal(DownloadResourceResultStatus.Available, result.Status); Assert.Equal("a", reader.GetIdentity().Id); Assert.Equal("1.0.0", reader.GetIdentity().Version.ToFullString()); Assert.True(stream.CanSeek); Assert.True(reader is PackageFolderReader); } } }
public void InitCommand_Fail_SourceDoesNotExist() { // Arrange using (var testFolder = TestFileSystemUtility.CreateRandomTestFolder()) using (var testInfo = new TestInfo(Path.Combine(testFolder, "DoesNotExist"))) { var args = new string[] { "init", testInfo.SourceFeed, testInfo.DestinationFeed, }; // Act var result = CommandRunner.Run( testInfo.NuGetExePath, testInfo.WorkingPath, string.Join(" ", args), waitForExit: true); // Assert var expectedErrorMessage = string.Format(NuGetResources.InitCommand_FeedIsNotFound, testInfo.SourceFeed); Util.VerifyResultFailure(result, expectedErrorMessage); } }
public void ListCommand_ShowLicenseUrlWithDetailedVerbosity() { // Arrange var nugetexe = Util.GetNuGetExePath(); using (var repositoryPath = TestFileSystemUtility.CreateRandomTestFolder()) { Util.CreateTestPackage("testPackage1", "1.1.0", repositoryPath, new Uri("http://kaka")); string[] args = new string[] { "list", "-Source", repositoryPath, "-verbosity", "detailed" }; // Act var r = CommandRunner.Run( nugetexe, Directory.GetCurrentDirectory(), string.Join(" ", args), waitForExit: true); // Assert Assert.Equal(0, r.Item1); var output = r.Item2; string[] lines = output.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); Assert.Equal(5, lines.Length); Assert.Equal("testPackage1", lines[1]); Assert.Equal(" 1.1.0", lines[2]); Assert.Equal(" desc of testPackage1 1.1.0", lines[3]); Assert.Equal(" License url: http://kaka", lines[4]); } }
public void InitCommand_Fail_DestinationIsHttpSource() { // Arrange var httpUrl = "https://api.nuget.org/v3/index.json"; using (var testInfo = new TestInfo(TestFileSystemUtility.CreateRandomTestFolder(), httpUrl)) { var args = new string[] { "init", testInfo.SourceFeed, testInfo.DestinationFeed, }; // Act var result = CommandRunner.Run( testInfo.NuGetExePath, testInfo.WorkingPath, string.Join(" ", args), waitForExit: true); // Assert var expectedErrorMessage = string.Format(NuGetResources.Path_Invalid_NotFileNotUnc, testInfo.DestinationFeed); Util.VerifyResultFailure(result, expectedErrorMessage); } }
private async Task <IEnumerable <NuGetProjectAction> > PacManCleanInstall(SourceRepositoryProvider sourceRepositoryProvider, PackageIdentity target) { // Arrange using (var testSolutionManager = new TestSolutionManager(true)) using (var randomPackagesConfigFolderPath = TestFileSystemUtility.CreateRandomTestFolder()) { var testSettings = new Configuration.NullSettings(); var token = CancellationToken.None; var deleteOnRestartManger = new TestDeleteOnRestartManager(); var nuGetPackageManager = new NuGetPackageManager( sourceRepositoryProvider, testSettings, testSolutionManager, deleteOnRestartManger); var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(testSolutionManager, testSettings); var randomPackagesConfigPath = Path.Combine(randomPackagesConfigFolderPath, "packages.config"); var projectTargetFramework = NuGetFramework.Parse("net45"); var msBuildNuGetProjectSystem = new TestMSBuildNuGetProjectSystem(projectTargetFramework, new TestNuGetProjectContext()); var msBuildNuGetProject = new MSBuildNuGetProject(msBuildNuGetProjectSystem, packagesFolderPath, randomPackagesConfigFolderPath); // Act var nugetProjectActions = await nuGetPackageManager.PreviewInstallPackageAsync(msBuildNuGetProject, target, new ResolutionContext(), new TestNuGetProjectContext(), sourceRepositoryProvider.GetRepositories().First(), null, token); return(nugetProjectActions); } }
public void InitCommand_Fail_DestinationIsInvalid() { // Arrange var invalidPath = "foo|<>|bar"; using (var testInfo = new TestInfo(TestFileSystemUtility.CreateRandomTestFolder(), invalidPath)) { var args = new string[] { "init", testInfo.SourceFeed, testInfo.DestinationFeed, }; // Act var result = CommandRunner.Run( testInfo.NuGetExePath, testInfo.WorkingPath, string.Join(" ", args), waitForExit: true); // Assert var expectedMessage = string.Format(NuGetResources.Path_Invalid, invalidPath); Util.VerifyResultFailure(result, expectedMessage); } }
/// <summary> /// Provides the path to Xplat dll on the test machine. /// It traverses in the directory tree going one step up at a time and looks for src folder. /// Once in src, it looks for the xplat dll in the location specified by <code>_xplatDll</code>. /// </summary> /// <returns> /// <code>String</code> containing the path to the dotnet cli within the local repository. /// Can return <code>null</code> if no src directory or xplat dll is found, in which case the tests can fail. /// </returns> public static string GetXplatDll() { var dir = TestFileSystemUtility.ParentDirectoryLookup() .FirstOrDefault(d => Directory.Exists(Path.Combine(d.FullName, "src"))); if (dir != null) { const string configuration = #if DEBUG "Debug"; #else "Release"; #endif var relativePaths = new string[] { Path.Combine("artifacts", "NuGet.CommandLine.XPlat", "bin", configuration, "netcoreapp5.0", XPlatDll) }; foreach (var relativePath in relativePaths) { var filePath = Path.Combine(dir.FullName, relativePath); if (File.Exists(filePath)) { return(filePath); } } } return(null); }
public async Task HttpSource_ValidatesInvalidCachedContent() { // Arrange using (var td = TestFileSystemUtility.CreateRandomTestFolder()) { var tc = new TestContext(td); tc.WriteToCache(tc.CacheKey, tc.CacheContent); // Act var result = await tc.HttpSource.GetAsync( new HttpSourceCachedRequest( tc.Url, tc.CacheKey, tc.CacheContext) { EnsureValidContents = tc.GetStreamValidator(validCache: false, validNetwork: true) }, tc.Logger, CancellationToken.None); // Assert Assert.True(tc.ValidatedCacheContent, "The cache content should have been validated."); Assert.True(tc.ValidatedNetworkContent, "The network content should have been validated."); Assert.Equal(tc.NetworkContent, new StreamReader(result.Stream).ReadToEnd()); tc.Throttle.Verify(x => x.WaitAsync(), Times.Once); tc.Throttle.Verify(x => x.Release(), Times.Once); } }