public ToolUpdateCommandTests()
{
_reporter = new BufferedReporter();
_fileSystem = new FileSystemMockBuilder().Build();
_environmentPathInstructionMock = new EnvironmentPathInstructionMock(_reporter, ShimsDirectory);
_store = new ToolPackageStoreMock(new DirectoryPath(ToolsDirectory), _fileSystem);
_mockFeeds = new List <MockFeed>
{
new MockFeed
{
Type = MockFeedType.FeedFromLookUpNugetConfig,
Packages = new List <MockFeedPackage>
{
new MockFeedPackage
{
PackageId = _packageId.ToString(),
Version = LowerPackageVersion
},
new MockFeedPackage
{
PackageId = _packageId.ToString(),
Version = HigherPackageVersion
}
}
}
};
}
public void GivenARootWithNonAsciiCharactorInstallSucceeds()
{
var nugetConfigPath = WriteNugetConfigFileToPointToTheFeed();
var surrogate = char.ConvertFromUtf32(int.Parse("2A601", NumberStyles.HexNumber));
string nonAscii = "ab Ṱ̺̺̕o 田中さん åä," + surrogate;
var root = new DirectoryPath(Path.Combine(TempRoot.Root, nonAscii, Path.GetRandomFileName()));
var reporter = new BufferedReporter();
var fileSystem = new FileSystemWrapper();
var store = new ToolPackageStore(root);
var installer = new ToolPackageInstaller(
store: store,
projectRestorer: new ProjectRestorer(reporter),
tempProject: GetUniqueTempProjectPathEachTest(),
offlineFeed: new DirectoryPath("does not exist"));
var package = installer.InstallPackage(new PackageLocation(nugetConfig: nugetConfigPath),
packageId: TestPackageId,
versionRange: VersionRange.Parse(TestPackageVersion),
targetFramework: _testTargetframework);
AssertPackageInstall(reporter, fileSystem, package, store);
package.Uninstall();
}
) Setup(
bool useMock,
List <MockFeed> feeds = null,
FilePath?tempProject = null,
DirectoryPath?offlineFeed = null,
FilePath?writeLocalFeedToNugetConfig = null,
[CallerMemberName] string callingMethod = "",
string identiifer = null)
{
var root = new DirectoryPath(_testAssetsManager.CreateTestDirectory(callingMethod, identifier: useMock.ToString() + identiifer).Path);
var reporter = new BufferedReporter();
IFileSystem fileSystem;
IToolPackageStore store;
IToolPackageStoreQuery storeQuery;
IToolPackageInstaller installer;
IToolPackageUninstaller uninstaller;
if (useMock)
{
fileSystem = new FileSystemMockBuilder().Build();
var frameworksMap = new Dictionary <PackageId, IEnumerable <NuGetFramework> >()
{
{ TestPackageId, TestFrameworks }
};
WriteNugetConfigFileToPointToTheFeed(fileSystem, writeLocalFeedToNugetConfig);
var toolPackageStoreMock = new ToolPackageStoreMock(root, fileSystem, frameworksMap);
store = toolPackageStoreMock;
storeQuery = toolPackageStoreMock;
installer = new ToolPackageInstallerMock(
fileSystem: fileSystem,
store: toolPackageStoreMock,
projectRestorer: new ProjectRestorerMock(
fileSystem: fileSystem,
reporter: reporter,
feeds: feeds == null
? GetMockFeedsForConfigFile(writeLocalFeedToNugetConfig)
: feeds.Concat(GetMockFeedsForConfigFile(writeLocalFeedToNugetConfig)).ToList()),
frameworksMap: frameworksMap);
uninstaller = new ToolPackageUninstallerMock(fileSystem, toolPackageStoreMock);
}
else
{
fileSystem = new FileSystemWrapper();
WriteNugetConfigFileToPointToTheFeed(fileSystem, writeLocalFeedToNugetConfig);
var toolPackageStore = new ToolPackageStoreAndQuery(root);
store = toolPackageStore;
storeQuery = toolPackageStore;
installer = new ToolPackageInstaller(
store: store,
projectRestorer: new Stage2ProjectRestorer(Log, reporter),
tempProject: tempProject ?? GetUniqueTempProjectPathEachTest(),
offlineFeed: offlineFeed ?? new DirectoryPath("does not exist"));
uninstaller = new ToolPackageUninstaller(store);
}
store.Root.Value.Should().Be(Path.GetFullPath(root.Value));
return(store, storeQuery, installer, uninstaller, reporter, fileSystem);
}
public void GivenNuGetSignCommandItDisplaysCompletions()
{
var expected = new[] {
"--certificate-fingerprint",
"--certificate-path",
"--certificate-store-name",
"--certificate-store-location",
"--certificate-subject-name",
"--certificate-password",
"--hash-algorithm",
"--timestamper",
"--timestamp-hash-algorithm",
"--verbosity",
"--output",
"--overwrite",
"-o",
"--help",
"-v",
"-?",
"-h",
"/?",
"/h"
};
var reporter = new BufferedReporter();
CompleteCommand.RunWithReporter(new[] { "dotnet nuget sign " }, reporter).Should().Be(0);
reporter.Lines.OrderBy(c => c).Should().Equal(expected.OrderBy(c => c));
}
public ToolInstallGlobalOrToolPathCommandTests()
{
_reporter = new BufferedReporter();
_fileSystem = new FileSystemMockBuilder().UseCurrentSystemTemporaryDirectory().Build();
_temporaryDirectory = _fileSystem.Directory.CreateTemporaryDirectory().DirectoryPath;
_pathToPlaceShim = Path.Combine(_temporaryDirectory, "pathToPlace");
_fileSystem.Directory.CreateDirectory(_pathToPlaceShim);
_pathToPlacePackages = _pathToPlaceShim + "Packages";
var toolPackageStoreMock = new ToolPackageStoreMock(new DirectoryPath(_pathToPlacePackages), _fileSystem);
_toolPackageStore = toolPackageStoreMock;
_toolPackageStoreQuery = toolPackageStoreMock;
_createShellShimRepository =
(_, nonGlobalLocation) => new ShellShimRepository(
new DirectoryPath(_pathToPlaceShim),
string.Empty,
fileSystem: _fileSystem,
appHostShellShimMaker: new AppHostShellShimMakerMock(_fileSystem),
filePermissionSetter: new NoOpFilePermissionSetter());
_environmentPathInstructionMock =
new EnvironmentPathInstructionMock(_reporter, _pathToPlaceShim);
_createToolPackageStoreAndInstaller = (location, forwardArguments) => (_toolPackageStore, _toolPackageStoreQuery, CreateToolPackageInstaller());
_parseResult = Parser.Instance.Parse($"dotnet tool install -g {PackageId}");
}
public void GivenPathSetItDoesNotAddPathToEnvironment()
{
var reporter = new BufferedReporter();
var toolsPath = new BashPathUnderHomeDirectory("/home/user", ".dotnet/tools");
var pathValue = @"/usr/bin";
var provider = new Mock <IEnvironmentProvider>(MockBehavior.Strict);
var fileSystem = new FileSystemMockBuilder().Build().File;
provider
.Setup(p => p.GetEnvironmentVariable("PATH"))
.Returns(pathValue + ":" + toolsPath.Path);
var environmentPath = new LinuxEnvironmentPath(
toolsPath,
reporter,
provider.Object,
fileSystem);
environmentPath.AddPackageExecutablePathToUserPath();
reporter.Lines.Should().BeEmpty();
fileSystem
.Exists(LinuxEnvironmentPath.DotnetCliToolsProfilePath)
.Should()
.Be(false);
}
public void GivenNuGetPushCommandItDisplaysCompletions()
{
var expected = new[] {
"--api-key",
"--disable-buffering",
"--force-english-output",
"--help",
"--no-service-endpoint",
"--no-symbols",
"--skip-duplicate",
"--source",
"--symbol-api-key",
"--symbol-source",
"--timeout",
"--interactive",
"-?",
"-d",
"-h",
"-k",
"-n",
"-s",
"-sk",
"-ss",
"-t",
"/?",
"/h",
};
var reporter = new BufferedReporter();
CompleteCommand.RunWithReporter(new[] { "dotnet nuget push " }, reporter).Should().Be(0);
reporter.Lines.OrderBy(c => c).Should().Equal(expected.OrderBy(c => c));
}
public void GivenOfflineFeedWhenCallItCanDownloadThePackage()
{
var reporter = new BufferedReporter();
var toolsPath = Path.Combine(Directory.GetCurrentDirectory(), Path.GetRandomFileName());
ToolPackageObtainer packageObtainer =
new ToolPackageObtainer(
toolsPath: new DirectoryPath(toolsPath),
offlineFeedPath: new DirectoryPath(GetTestLocalFeedPath()),
getTempProjectPath: GetUniqueTempProjectPathEachTest,
bundledTargetFrameworkMoniker: new Lazy <string>(),
projectRestorer: new ProjectRestorer(reporter));
ToolConfigurationAndExecutablePath toolConfigurationAndExecutablePath = packageObtainer.ObtainAndReturnExecutablePath(
packageId: TestPackageId,
packageVersion: TestPackageVersion,
targetframework: _testTargetframework);
reporter.Lines.Should().BeEmpty();
var executable = toolConfigurationAndExecutablePath
.Executable;
File.Exists(executable.Value)
.Should()
.BeTrue(executable + " should have the executable");
executable.Value.Should().NotContain(GetTestLocalFeedPath(), "Executable should not be still in fallbackfolder");
executable.Value.Should().Contain(toolsPath, "Executable should be copied to tools Path");
File.Delete(executable.Value);
}
public void GivenAllButNoPackageVersionAndInvokeTwiceInTransactionItShouldRollback(bool testMockBehaviorIsInSync)
{
var reporter = new BufferedReporter();
var nugetConfigPath = WriteNugetConfigFileToPointToTheFeed();
var toolsPath = Path.Combine(Directory.GetCurrentDirectory(), Path.GetRandomFileName());
var packageObtainer =
ConstructDefaultPackageObtainer(toolsPath, reporter, testMockBehaviorIsInSync, nugetConfigPath.Value);
packageObtainer.ObtainAndReturnExecutablePath(
packageId: TestPackageId,
nugetconfig: nugetConfigPath,
targetframework: _testTargetframework);
reporter.Lines.Should().BeEmpty();
Action secondCall = () => packageObtainer.ObtainAndReturnExecutablePath(
packageId: TestPackageId,
nugetconfig: nugetConfigPath,
targetframework: _testTargetframework);
reporter.Lines.Should().BeEmpty();
secondCall.ShouldThrow <PackageObtainException>();
Directory.Exists(Path.Combine(toolsPath, TestPackageId))
.Should().BeTrue("The result of first one is still here");
Directory.GetDirectories(Path.Combine(toolsPath, ".stage"))
.Should().BeEmpty("nothing in stage folder, already rolled back");
}
public void GiveSucessRestoreButFailedOnNextStepItCanRollBack(bool testMockBehaviorIsInSync)
{
FilePath nugetConfigPath = WriteNugetConfigFileToPointToTheFeed();
var toolsPath = Path.Combine(Directory.GetCurrentDirectory(), Path.GetRandomFileName());
var reporter = new BufferedReporter();
var packageObtainer = ConstructDefaultPackageObtainer(toolsPath, reporter, testMockBehaviorIsInSync);
void FailedStepAfterSuccessRestore() => throw new GracefulException("simulated error");
try
{
using (var t = new TransactionScope())
{
ToolConfigurationAndExecutablePath obtainAndReturnExecutablePathtransactional
= packageObtainer.ObtainAndReturnExecutablePath(
packageId: TestPackageId,
packageVersion: TestPackageVersion,
targetframework: _testTargetframework);
FailedStepAfterSuccessRestore();
t.Complete();
}
}
catch (GracefulException)
{
// catch the simulated error
}
AssertRollBack(toolsPath);
}
public void GivenAllButNoPackageVersionAndInvokeTwiceItShouldNotThrow(bool testMockBehaviorIsInSync)
{
var reporter = new BufferedReporter();
var nugetConfigPath = WriteNugetConfigFileToPointToTheFeed();
var toolsPath = Path.Combine(Directory.GetCurrentDirectory(), Path.GetRandomFileName());
var packageObtainer =
ConstructDefaultPackageObtainer(toolsPath, reporter, testMockBehaviorIsInSync, nugetConfigPath.Value);
try
{
using (var t = new TransactionScope())
{
packageObtainer.ObtainAndReturnExecutablePath(
packageId: TestPackageId,
packageVersion: TestPackageVersion,
targetframework: _testTargetframework);
packageObtainer.ObtainAndReturnExecutablePath(
packageId: TestPackageId,
packageVersion: TestPackageVersion,
targetframework: _testTargetframework);
t.Complete();
}
}
catch (PackageObtainException)
{
// catch the simulated error
}
AssertRollBack(toolsPath);
}
public void GivenFailedRestoreItCanRollBack(bool testMockBehaviorIsInSync)
{
var toolsPath = Path.Combine(Directory.GetCurrentDirectory(), Path.GetRandomFileName());
var reporter = new BufferedReporter();
var packageObtainer = ConstructDefaultPackageObtainer(toolsPath, reporter, testMockBehaviorIsInSync);
try
{
using (var t = new TransactionScope())
{
packageObtainer.ObtainAndReturnExecutablePath(
packageId: "non exist package id",
packageVersion: TestPackageVersion,
targetframework: _testTargetframework);
t.Complete();
}
}
catch (PackageObtainException)
{
// catch the intent error
}
AssertRollBack(toolsPath);
}
public void GivenASourceItCanObtainThePackageFromThatSource(bool testMockBehaviorIsInSync)
{
var reporter = new BufferedReporter();
var toolsPath = Path.Combine(Directory.GetCurrentDirectory(), Path.GetRandomFileName());
var packageObtainer = ConstructDefaultPackageObtainer(
toolsPath,
reporter,
testMockBehaviorIsInSync: testMockBehaviorIsInSync,
addSourceFeedWithFilePath: GetTestLocalFeedPath());
ToolConfigurationAndExecutablePath toolConfigurationAndExecutablePath =
packageObtainer.ObtainAndReturnExecutablePath(
packageId: TestPackageId,
packageVersion: TestPackageVersion,
targetframework: _testTargetframework,
source: GetTestLocalFeedPath());
reporter.Lines.Should().BeEmpty();
var executable = toolConfigurationAndExecutablePath.Executable;
File.Exists(executable.Value)
.Should()
.BeTrue(executable + " should have the executable");
File.Delete(executable.Value);
}
public void GivenNonExistentNugetConfigFileItThrows(bool testMockBehaviorIsInSync)
{
var reporter = new BufferedReporter();
var toolsPath = Path.Combine(Directory.GetCurrentDirectory(), Path.GetRandomFileName());
var packageObtainer =
ConstructDefaultPackageObtainer(toolsPath, reporter, testMockBehaviorIsInSync);
var nonExistNugetConfigFile = new FilePath("NonExistent.file");
Action a = () =>
{
ToolConfigurationAndExecutablePath toolConfigurationAndExecutablePath =
packageObtainer.ObtainAndReturnExecutablePath(
packageId: TestPackageId,
packageVersion: TestPackageVersion,
nugetconfig: nonExistNugetConfigFile,
targetframework: _testTargetframework);
};
a.ShouldThrow <PackageObtainException>()
.And
.Message.Should().Contain(string.Format(
CommonLocalizableStrings.NuGetConfigurationFileDoesNotExist,
Path.GetFullPath(nonExistNugetConfigFile.Value)));
reporter.Lines.Should().BeEmpty();
}
public void GivenNewCommandItDisplaysCompletions()
{
var expected = new[] {
"--dry-run",
"--force",
"--help",
"--install",
"--language",
"--list",
"--name",
"--nuget-source",
"--output",
"--type",
"--uninstall",
"-h",
"-i",
"-l",
"-lang",
"-n",
"-o",
"-u"
};
var reporter = new BufferedReporter();
CompleteCommand.RunWithReporter(new[] { "dotnet new " }, reporter).Should().Be(0);
reporter.Lines.Should().Equal(expected.OrderBy(c => c));
}
public void GivenNugetConfigAndPackageNameAndVersionAndTargetFrameworkWhenCallItCanDownloadThePackage(
bool testMockBehaviorIsInSync)
{
var reporter = new BufferedReporter();
FilePath nugetConfigPath = WriteNugetConfigFileToPointToTheFeed();
var toolsPath = Path.Combine(Directory.GetCurrentDirectory(), Path.GetRandomFileName());
var packageObtainer =
ConstructDefaultPackageObtainer(toolsPath, reporter, testMockBehaviorIsInSync, nugetConfigPath.Value);
ToolConfigurationAndExecutablePath toolConfigurationAndExecutablePath
= packageObtainer.ObtainAndReturnExecutablePath(
packageId: TestPackageId,
packageVersion: TestPackageVersion,
nugetconfig: nugetConfigPath,
targetframework: _testTargetframework);
reporter.Lines.Should().BeEmpty();
FilePath executable = toolConfigurationAndExecutablePath.Executable;
File.Exists(executable.Value)
.Should()
.BeTrue(executable + " should have the executable");
File.Delete(executable.Value);
}
public void GivenPathNotSetItAddsToEnvironment()
{
var reporter = new BufferedReporter();
var toolsPath = new BashPathUnderHomeDirectory("/home/user", ".dotnet/tools");
var pathValue = @"/usr/bin";
var provider = new Mock <IEnvironmentProvider>(MockBehavior.Strict);
IFileSystem fileSystem = new FileSystemMockBuilder().Build();
fileSystem.Directory.CreateDirectory("/etc/profile.d");
provider
.Setup(p => p.GetEnvironmentVariable("PATH"))
.Returns(pathValue);
var environmentPath = new LinuxEnvironmentPath(
toolsPath,
reporter,
provider.Object,
fileSystem.File);
environmentPath.AddPackageExecutablePathToUserPath();
reporter.Lines.Should().BeEmpty();
fileSystem
.File
.ReadAllText(LinuxEnvironmentPath.DotnetCliToolsProfilePath)
.Should()
.Be($"export PATH=\"$PATH:{toolsPath.PathWithDollar}\"");
}
public void GivenPathSetItPrintsInstruction(string toolsDirectoryOnPath)
{
BufferedReporter reporter = new BufferedReporter();
BashPathUnderHomeDirectory toolsPath = new BashPathUnderHomeDirectory(
"/home/user",
".dotnet/tools");
string pathValue = @"/usr/bin";
Mock <IEnvironmentProvider> provider = new Mock <IEnvironmentProvider>(MockBehavior.Strict);
provider
.Setup(p => p.GetEnvironmentVariable("PATH"))
.Returns(pathValue + ":" + toolsDirectoryOnPath);
provider
.Setup(p => p.GetEnvironmentVariable("SHELL"))
.Returns("/bin/zsh");
OsxZshEnvironmentPathInstruction environmentPath = new OsxZshEnvironmentPathInstruction(
toolsPath,
reporter,
provider.Object);
environmentPath.PrintAddPathInstructionIfPathDoesNotExist();
reporter.Lines.Should().Equal(
string.Format(
CommonLocalizableStrings.EnvironmentPathOSXZshManualInstructions,
toolsPath.Path));
}
public void GivenNuGetLocalsCommandItDisplaysCompletions()
{
var expected = new[] {
"--clear",
"--force-english-output",
"--help",
"--list",
"-?",
"-c",
"-h",
"-l",
"/?",
"/h",
"all",
"global-packages",
"http-cache",
"temp",
"plugins-cache"
};
var reporter = new BufferedReporter();
CompleteCommand.RunWithReporter(new[] { "dotnet nuget locals " }, reporter).Should().Be(0);
reporter.Lines.OrderBy(c => c).Should().Equal(expected.OrderBy(c => c));
}
public UninstallToolCommandTests()
{
_reporter = new BufferedReporter();
_fileSystem = new FileSystemMockBuilder().Build();
_shellShimRepositoryMock = new ShellShimRepositoryMock(new DirectoryPath(ShimsDirectory), _fileSystem);
_environmentPathInstructionMock = new EnvironmentPathInstructionMock(_reporter, ShimsDirectory);
}
public void GivenNuGetTrustCommandItDisplaysCompletions()
{
var expected = new[] {
"--algorithm",
"--allow-untrusted-root",
"--configfile",
"--owners",
"--verbosity",
"--help",
"-v",
"-?",
"-h",
"/?",
"/h",
"author",
"certificate",
"list",
"remove",
"repository",
"source",
"sync"
};
var reporter = new BufferedReporter();
CompleteCommand.RunWithReporter(new[] { "dotnet nuget trust " }, reporter).Should().Be(0);
reporter.Lines.OrderBy(c => c).Should().Equal(expected.OrderBy(c => c));
}
public void GivenNewCommandItDisplaysCompletions()
{
var expected = new[] {
"--columns",
"--dry-run",
"--force",
"--help",
"--install",
"--language",
"--list",
"--interactive",
"--name",
"--nuget-source",
"--output",
"--type",
"--uninstall",
"-?",
"-h",
"-i",
"-l",
"-lang",
"-n",
"-o",
"-u",
"/?",
"/h",
"--update-check",
"--update-apply"
};
var reporter = new BufferedReporter();
CompleteCommand.RunWithReporter(new[] { "dotnet new " }, reporter).Should().Be(0);
reporter.Lines.OrderBy(c => c).Should().Contain(expected.OrderBy(c => c));
}
public ToolInstallCommandTests()
{
_reporter = new BufferedReporter();
_fileSystem = new FileSystemMockBuilder().UseCurrentSystemTemporaryDirectory().Build();
_temporaryDirectory = _fileSystem.Directory.CreateTemporaryDirectory().DirectoryPath;
_pathToPlaceShim = Path.Combine(_temporaryDirectory, "pathToPlace");
_pathToPlacePackages = _pathToPlaceShim + "Packages";
var toolPackageStoreMock = new ToolPackageStoreMock(new DirectoryPath(_pathToPlacePackages), _fileSystem);
_toolPackageStore = toolPackageStoreMock;
_toolPackageStoreQuery = toolPackageStoreMock;
_createShellShimRepository =
(nonGlobalLocation) => new ShellShimRepository(
new DirectoryPath(_pathToPlaceShim),
fileSystem: _fileSystem,
appHostShellShimMaker: new AppHostShellShimMakerMock(_fileSystem),
filePermissionSetter: new NoOpFilePermissionSetter());
_environmentPathInstructionMock =
new EnvironmentPathInstructionMock(_reporter, _pathToPlaceShim);
_createToolPackageStoreAndInstaller = (_) => (_toolPackageStore, _toolPackageStoreQuery, CreateToolPackageInstaller());
ParseResult result = Parser.Instance.Parse($"dotnet tool install -g {PackageId}");
_appliedCommand = result["dotnet"]["tool"]["install"];
var parser = Parser.Instance;
_parseResult = parser.ParseFrom("dotnet tool", new[] { "install", "-g", PackageId });
}
public void GivenARootWithNonAsciiCharacterInstallSucceeds()
{
var nugetConfigPath = GenerateRandomNugetConfigFilePath();
var surrogate = char.ConvertFromUtf32(int.Parse("2A601", NumberStyles.HexNumber));
string nonAscii = "ab Ṱ̺̺̕o 田中さん åä," + surrogate;
var root = _testAssetsManager.CreateTestDirectory(testName: nonAscii, identifier: "root");
var reporter = new BufferedReporter();
var fileSystem = new FileSystemWrapper();
var store = new ToolPackageStoreAndQuery(new DirectoryPath(root.Path));
WriteNugetConfigFileToPointToTheFeed(fileSystem, nugetConfigPath);
var installer = new ToolPackageInstaller(
store: store,
projectRestorer: new Stage2ProjectRestorer(Log, reporter),
tempProject: GetUniqueTempProjectPathEachTest(),
offlineFeed: new DirectoryPath("does not exist"));
var package = installer.InstallPackage(new PackageLocation(nugetConfig: nugetConfigPath),
packageId: TestPackageId,
versionRange: VersionRange.Parse(TestPackageVersion),
targetFramework: _testTargetframework);
AssertPackageInstall(reporter, fileSystem, package, store, store);
new ToolPackageUninstaller(store).Uninstall(package.PackageDirectory);
}
public GivenDotnetWorkloadList(ITestOutputHelper log) : base(log)
{
_reporter = new BufferedReporter();
_machineReadableParseResult = Parser.Instance.Parse("dotnet workload list --machine-readable");
_parseResult = Parser.Instance.Parse("dotnet workload list");
_manifestPath = Path.Combine(_testAssetsManager.GetAndValidateTestProjectDirectory("SampleManifest"), "MockListSample.json");
}
public ToolUpdateCommandTests()
{
_reporter = new BufferedReporter();
_fileSystem = new FileSystemMockBuilder().UseCurrentSystemTemporaryDirectory().Build();
var tempDirectory = _fileSystem.Directory.CreateTemporaryDirectory().DirectoryPath;
_shimsDirectory = Path.Combine(tempDirectory, "shims");
_toolsDirectory = Path.Combine(tempDirectory, "tools");
_environmentPathInstructionMock = new EnvironmentPathInstructionMock(_reporter, _shimsDirectory);
_store = new ToolPackageStoreMock(new DirectoryPath(_toolsDirectory), _fileSystem);
_mockFeeds = new List <MockFeed>
{
new MockFeed
{
Type = MockFeedType.FeedFromGlobalNugetConfig,
Packages = new List <MockFeedPackage>
{
new MockFeedPackage
{
PackageId = _packageId.ToString(),
Version = LowerPackageVersion,
ToolCommandName = "SimulatorCommand"
},
new MockFeedPackage
{
PackageId = _packageId.ToString(),
Version = HigherPackageVersion,
ToolCommandName = "SimulatorCommand"
}
}
}
};
}
public ToolRestoreCommandWithMultipleNugetConfigTests()
{
_packageVersionA = NuGetVersion.Parse("1.0.4");
_packageVersionB = NuGetVersion.Parse("1.0.4");
_reporter = new BufferedReporter();
_fileSystem = new FileSystemMockBuilder().UseCurrentSystemTemporaryDirectory().Build();
_nugetGlobalPackagesFolder = new DirectoryPath(NuGetGlobalPackagesFolder.GetLocation());
string temporaryDirectory = _fileSystem.Directory.CreateTemporaryDirectory().DirectoryPath;
string pathToPlacePackages = Path.Combine(temporaryDirectory, "pathToPlacePackage");
ToolPackageStoreMock toolPackageStoreMock =
new ToolPackageStoreMock(new DirectoryPath(pathToPlacePackages), _fileSystem);
SetupFileLayoutAndFeed(temporaryDirectory, toolPackageStoreMock);
ParseResult result = Parser.Instance.Parse("dotnet tool restore");
_appliedCommand = result["dotnet"]["tool"]["restore"];
Cli.CommandLine.Parser parser = Parser.Instance;
_parseResult = parser.ParseFrom("dotnet tool", new[] { "restore" });
_localToolsResolverCache
= new LocalToolsResolverCache(
_fileSystem,
new DirectoryPath(Path.Combine(temporaryDirectory, "cache")),
1);
}
public void GivenPathNotSetInProcessItPrintsReopenNotice()
{
var reporter = new BufferedReporter();
var toolsPath = @"C:\Tools";
var pathValue = @"C:\Other";
var provider = new Mock <IEnvironmentProvider>(MockBehavior.Strict);
provider
.Setup(p => p.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Process))
.Returns(pathValue);
provider
.Setup(p => p.GetEnvironmentVariable(
"PATH",
It.Is <EnvironmentVariableTarget>(t =>
t == EnvironmentVariableTarget.User ||
t == EnvironmentVariableTarget.Machine)))
.Returns(pathValue + ";" + toolsPath);
var environmentPath = new WindowsEnvironmentPath(toolsPath, reporter, provider.Object);
environmentPath.PrintAddPathInstructionIfPathDoesNotExist();
reporter.Lines.Should().Equal(CommonLocalizableStrings.EnvironmentPathWindowsNeedReopen);
}
public void GivenSecurityExceptionItPrintsWarning()
{
var reporter = new BufferedReporter();
var toolsPath = @"C:\Tools";
var pathValue = @"C:\Other";
var provider = new Mock <IEnvironmentProvider>(MockBehavior.Strict);
provider
.Setup(p => p.GetEnvironmentVariable(
"PATH",
It.Is <EnvironmentVariableTarget>(t =>
t == EnvironmentVariableTarget.Process ||
t == EnvironmentVariableTarget.User ||
t == EnvironmentVariableTarget.Machine)))
.Returns(pathValue);
provider
.Setup(p => p.SetEnvironmentVariable("PATH", pathValue + ";" + toolsPath, EnvironmentVariableTarget.User))
.Throws(new System.Security.SecurityException());
var environmentPath = new WindowsEnvironmentPath(toolsPath, reporter, provider.Object);
environmentPath.AddPackageExecutablePathToUserPath();
reporter.Lines.Should().Equal(
string.Format(
CommonLocalizableStrings.FailedToSetToolsPathEnvironmentVariable,
toolsPath).Yellow());
}
public ToolInstallLocalCommandTests()
{
_packageVersionA = NuGetVersion.Parse("1.0.4");
_reporter = new BufferedReporter();
_fileSystem = new FileSystemMockBuilder().UseCurrentSystemTemporaryDirectory().Build();
_nugetGlobalPackagesFolder = new DirectoryPath(NuGetGlobalPackagesFolder.GetLocation());
_temporaryDirectory = _fileSystem.Directory.CreateTemporaryDirectory().DirectoryPath;
_pathToPlacePackages = Path.Combine(_temporaryDirectory, "pathToPlacePackage");
ToolPackageStoreMock toolPackageStoreMock =
new ToolPackageStoreMock(new DirectoryPath(_pathToPlacePackages), _fileSystem);
_toolPackageStore = toolPackageStoreMock;
_toolPackageInstallerMock = new ToolPackageInstallerMock(
_fileSystem,
_toolPackageStore,
new ProjectRestorerMock(
_fileSystem,
_reporter,
new[]
{
new MockFeed
{
Type = MockFeedType.ImplicitAdditionalFeed,
Packages = new List <MockFeedPackage>
{
new MockFeedPackage
{
PackageId = _packageIdA.ToString(),
Version = _packageVersionA.ToNormalizedString(),
ToolCommandName = _toolCommandNameA.ToString()
}
}
}
}));
_localToolsResolverCache
= new LocalToolsResolverCache(
_fileSystem,
new DirectoryPath(Path.Combine(_temporaryDirectory, "cache")),
1);
_manifestFilePath = Path.Combine(_temporaryDirectory, "dotnet-tools.json");
_fileSystem.File.WriteAllText(Path.Combine(_temporaryDirectory, _manifestFilePath), _jsonContent);
_toolManifestFinder = new ToolManifestFinder(new DirectoryPath(_temporaryDirectory), _fileSystem);
_toolManifestEditor = new ToolManifestEditor(_fileSystem);
ParseResult result = Parser.Instance.Parse($"dotnet tool install {_packageIdA.ToString()}");
_appliedCommand = result["dotnet"]["tool"]["install"];
Cli.CommandLine.Parser parser = Parser.Instance;
_parseResult = parser.ParseFrom("dotnet tool", new[] { "install", _packageIdA.ToString() });
_localToolsResolverCache
= new LocalToolsResolverCache(
_fileSystem,
new DirectoryPath(Path.Combine(_temporaryDirectory, "cache")),
1);
}
