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