public void WhenRunWithValidVersionWildcardItShouldSucceed()
{
ParseResult result = Parser.Instance.Parse($"dotnet install tool -g {PackageId} --version 1.0.*");
AppliedOption appliedCommand = result["dotnet"]["install"]["tool"];
var installToolCommand = new InstallToolCommand(
appliedCommand,
result,
_toolPackageStore,
CreateToolPackageInstaller(),
_shellShimRepositoryMock,
new EnvironmentPathInstructionMock(_reporter, PathToPlaceShim, true),
_reporter);
installToolCommand.Execute().Should().Be(0);
_reporter
.Lines
.Should()
.Equal(string.Format(
LocalizableStrings.InstallationSucceeded,
ProjectRestorerMock.FakeCommandName,
PackageId,
PackageVersion).Green());
}
public void GivenCreateShimItShouldHaveNoBrokenFolderOnDisk()
{
_fileSystem.File.CreateEmptyFile(ExpectedCommandPath()); // Create conflict shim
var installToolCommand = new InstallToolCommand(
_appliedCommand,
_parseResult,
_toolPackageStore,
CreateToolPackageInstaller(),
_shellShimRepositoryMock,
_environmentPathInstructionMock,
_reporter);
installToolCommand.Execute().Should().Be(1);
_reporter
.Lines[0]
.Should()
.Contain(
string.Format(
CommonLocalizableStrings.ShellShimConflict,
ProjectRestorerMock.FakeCommandName));
_fileSystem.Directory.Exists(Path.Combine(PathToPlacePackages, PackageId)).Should().BeFalse();
}
public void GivenInCorrectToolConfigurationWhenRunWithPackageIdItShouldFail()
{
var toolPackageObtainerSimulatorThatThrows
= new ToolPackageObtainerMock(
_fileSystemWrapper, true, null,
() => throw new ToolConfigurationException("Simulated error"));
var installToolCommand = new InstallToolCommand(
_appliedCommand,
_parseResult,
toolPackageObtainerSimulatorThatThrows,
_shellShimMakerMock,
_environmentPathInstructionMock,
_reporter);
installToolCommand.Execute().Should().Be(1);
_reporter.Lines.Count.Should().Be(2);
_reporter
.Lines[0]
.Should()
.Contain(
string.Format(
LocalizableStrings.InvalidToolConfiguration,
"Simulated error"));
_reporter
.Lines[1]
.Should()
.Contain(string.Format(LocalizableStrings.ToolInstallationFailedContactAuthor, "global.tool.console.demo"));
}
public void WhenRunWithPackageIdItShouldShowPathInstruction()
{
var installToolCommand = new InstallToolCommand(_appliedCommand,
_parseResult,
_toolPackageObtainerMock,
_shellShimMakerMock,
_environmentPathInstructionMock);
installToolCommand.Execute().Should().Be(0);
_reporter.Lines.Single().Should().NotBeEmpty();
}
public void WhenRunWithPackageIdItShouldShowPathInstruction()
{
var installToolCommand = new InstallToolCommand(_appliedCommand,
_parseResult,
_createToolPackageStoreAndInstaller,
_createShellShimRepository,
_environmentPathInstructionMock,
_reporter);
installToolCommand.Execute().Should().Be(0);
_reporter.Lines.First().Should().Be(EnvironmentPathInstructionMock.MockInstructionText);
}
public void WhenRunWithPackageIdItShouldShowPathInstruction()
{
var installToolCommand = new InstallToolCommand(_appliedCommand,
_parseResult,
_toolPackageStore,
CreateToolPackageInstaller(),
_shellShimRepositoryMock,
_environmentPathInstructionMock,
_reporter);
installToolCommand.Execute().Should().Be(0);
_reporter.Lines.First().Should().Be("INSTRUCTION");
}
public void WhenRunWithPackageIdPackageFormatIsNotFullySupportedItShouldShowPathInstruction()
{
var _toolPackageStore = new ToolPackageStoreMock(new DirectoryPath(PathToPlacePackages), _fileSystem);
var installToolCommand = new InstallToolCommand(_appliedCommand,
_parseResult,
_toolPackageStore,
CreateToolPackageInstaller(),
_shellShimRepositoryMock,
_environmentPathInstructionMock,
_reporter);
installToolCommand.Execute().Should().Be(0);
_reporter.Lines.First().Should().Be("WARNING");
_reporter.Lines.Skip(1).First().Should().Be("INSTRUCTION");
}
public void WhenRunWithPackageIdItShouldCreateValidShim()
{
var installToolCommand = new InstallToolCommand(_appliedCommand,
_parseResult,
_toolPackageObtainerMock,
_shellShimMakerMock,
_environmentPathInstructionMock);
installToolCommand.Execute().Should().Be(0);
// It is hard to simulate shell behavior. Only Assert shim can point to executable dll
_fileSystemWrapper.File.Exists(ExpectedCommandPath()).Should().BeTrue();
var deserializedFakeShim = JsonConvert.DeserializeObject <ShellShimMakerMock.FakeShim>(
_fileSystemWrapper.File.ReadAllText(ExpectedCommandPath()));
_fileSystemWrapper.File.Exists(deserializedFakeShim.ExecutablePath).Should().BeTrue();
}
public void WhenRunWithPackageIdItShouldShowSuccessMessage()
{
var installToolCommand = new InstallToolCommand(
_appliedCommand,
_parseResult,
_toolPackageObtainerMock,
_shellShimMakerMock,
new EnvironmentPathInstructionMock(_reporter, PathToPlaceShim, true),
_reporter);
installToolCommand.Execute().Should().Be(0);
_reporter
.Lines
.Single().Should()
.Contain(string.Format(LocalizableStrings.InstallationSucceeded, "SimulatorCommand"));
}
public void WhenRunWithPackageIdAndBinPathItShouldNoteHaveEnvironmentPathInstruction()
{
var result = Parser.Instance.Parse($"dotnet install tool --tool-path /tmp/folder {PackageId}");
var appliedCommand = result["dotnet"]["install"]["tool"];
var parser = Parser.Instance;
var parseResult = parser.ParseFrom("dotnet install", new[] { "tool", PackageId });
var installToolCommand = new InstallToolCommand(appliedCommand,
parseResult,
_createToolPackageStoreAndInstaller,
_createShellShimRepository,
new EnvironmentPathInstructionMock(_reporter, PathToPlaceShim),
_reporter);
installToolCommand.Execute().Should().Be(0);
_reporter.Lines.Should().NotContain(l => l.Contains(EnvironmentPathInstructionMock.MockInstructionText));
}
public void GivenFailedPackageObtainWhenRunWithPackageIdItShouldHaveNoBrokenFolderOnDisk()
{
var toolPackageObtainerSimulatorThatThrows
= new ToolPackageObtainerMock(
_fileSystemWrapper, true, null,
duringObtain: () => throw new PackageObtainException("Simulated error"),
toolsPath: PathToPlacePackages);
var installToolCommand = new InstallToolCommand(
_appliedCommand,
_parseResult,
toolPackageObtainerSimulatorThatThrows,
_shellShimMakerMock,
_environmentPathInstructionMock,
_reporter);
installToolCommand.Execute();
_fileSystemWrapper.Directory.Exists(Path.Combine(PathToPlacePackages, PackageId)).Should().BeFalse();
}
public void WhenRunWithPackageIdWithSourceItShouldCreateValidShim()
{
const string sourcePath = "http://mysouce.com";
ParseResult result = Parser.Instance.Parse($"dotnet install tool -g {PackageId} --source {sourcePath}");
AppliedOption appliedCommand = result["dotnet"]["install"]["tool"];
ParseResult parseResult =
Parser.Instance.ParseFrom("dotnet install", new[] { "tool", PackageId, "--source", sourcePath });
var installToolCommand = new InstallToolCommand(appliedCommand,
parseResult,
_toolPackageStore,
CreateToolPackageInstaller(
feeds: new MockFeed[] {
new MockFeed
{
Type = MockFeedType.Source,
Uri = sourcePath,
Packages = new List <MockFeedPackage>
{
new MockFeedPackage
{
PackageId = PackageId,
Version = PackageVersion
}
}
}
}),
_shellShimRepositoryMock,
_environmentPathInstructionMock,
_reporter);
installToolCommand.Execute().Should().Be(0);
// It is hard to simulate shell behavior. Only Assert shim can point to executable dll
_fileSystem.File.Exists(ExpectedCommandPath())
.Should().BeTrue();
var deserializedFakeShim =
JsonConvert.DeserializeObject <ShellShimRepositoryMock.FakeShim>(
_fileSystem.File.ReadAllText(ExpectedCommandPath()));
_fileSystem.File.Exists(deserializedFakeShim.ExecutablePath).Should().BeTrue();
}
public void WhenRunWithPackageIdWithSourceItShouldCreateValidShim()
{
const string sourcePath = "http://mysouce.com";
ParseResult result = Parser.Instance.Parse($"dotnet install tool -g global.tool.console.demo --source {sourcePath}");
AppliedOption appliedCommand = result["dotnet"]["install"]["tool"];
const string packageId = "global.tool.console.demo";
ParseResult parseResult =
Parser.Instance.ParseFrom("dotnet install", new[] { "tool", packageId, "--source", sourcePath });
var installToolCommand = new InstallToolCommand(appliedCommand,
parseResult,
new ToolPackageObtainerMock(_fileSystemWrapper, additionalFeeds: new List <MockFeed>
{
new MockFeed
{
Type = MockFeedType.Source,
Uri = sourcePath,
Packages = new List <MockFeedPackage>
{
new MockFeedPackage
{
PackageId = packageId,
Version = "1.0.4"
}
}
}
}),
_shellShimMakerMock,
_environmentPathInstructionMock);
installToolCommand.Execute();
// It is hard to simulate shell behavior. Only Assert shim can point to executable dll
_fileSystemWrapper.File.Exists(Path.Combine("pathToPlace", ToolPackageObtainerMock.FakeCommandName))
.Should().BeTrue();
ShellShimMakerMock.FakeShim deserializedFakeShim =
JsonConvert.DeserializeObject <ShellShimMakerMock.FakeShim>(
_fileSystemWrapper.File.ReadAllText(
Path.Combine("pathToPlace",
ToolPackageObtainerMock.FakeCommandName)));
_fileSystemWrapper.File.Exists(deserializedFakeShim.ExecutablePath).Should().BeTrue();
}
public void GivenInCorrectToolConfigurationWhenRunWithPackageIdItShouldThrow()
{
var toolPackageObtainerSimulatorThatThrows
= new ToolPackageObtainerMock(
_fileSystemWrapper, true, null,
() => throw new ToolConfigurationException("Simulated error"));
var installToolCommand = new InstallToolCommand(
_appliedCommand,
_parseResult,
toolPackageObtainerSimulatorThatThrows,
_shellShimMakerMock,
_environmentPathInstructionMock,
_fakeReporter);
Action a = () => installToolCommand.Execute();
a.ShouldThrow <GracefulException>()
.And.Message.Should()
.Contain(string.Format(LocalizableStrings.InstallFailedPackage, "Simulated error"));
}
public void WhenRunWithNeitherOfGlobalNorToolPathShowErrorMessage()
{
var result = Parser.Instance.Parse($"dotnet install tool {PackageId}");
var appliedCommand = result["dotnet"]["install"]["tool"];
var parser = Parser.Instance;
var parseResult = parser.ParseFrom("dotnet install", new[] { "tool", PackageId });
var installToolCommand = new InstallToolCommand(
appliedCommand,
parseResult,
_createToolPackageStoreAndInstaller,
_createShellShimRepository,
new EnvironmentPathInstructionMock(_reporter, PathToPlaceShim, true),
_reporter);
Action a = () => installToolCommand.Execute();
a.ShouldThrow <GracefulException>().And.Message
.Should().Contain(LocalizableStrings.InstallToolCommandNeedGlobalOrToolPath);
}
public void WhenRunWithPackageIdItShouldShowSuccessMessage()
{
var installToolCommand = new InstallToolCommand(
_appliedCommand,
_parseResult,
_createToolPackageStoreAndInstaller,
_createShellShimRepository,
new EnvironmentPathInstructionMock(_reporter, PathToPlaceShim, true),
_reporter);
installToolCommand.Execute().Should().Be(0);
_reporter
.Lines
.Should()
.Equal(string.Format(
LocalizableStrings.InstallationSucceeded,
ProjectRestorerMock.FakeCommandName,
PackageId,
PackageVersion).Green());
}
public void GivenCreateShimItShouldHaveNoBrokenFolderOnDisk()
{
_fileSystemWrapper.File.CreateEmptyFile(ExpectedCommandPath()); // Create conflict shim
var toolPackageObtainerSimulatorThatThrows
= new ToolPackageObtainerMock(
_fileSystemWrapper, true, null,
toolsPath: PathToPlacePackages);
var installToolCommand = new InstallToolCommand(
_appliedCommand,
_parseResult,
toolPackageObtainerSimulatorThatThrows,
_shellShimMakerMock,
_environmentPathInstructionMock,
_reporter);
Action a = () => installToolCommand.Execute();
a.ShouldThrow <GracefulException>();
_fileSystemWrapper.Directory.Exists(Path.Combine(PathToPlacePackages, PackageId)).Should().BeFalse();
}
public void WhenRunWithoutAMatchingRangeItShouldFail()
{
ParseResult result = Parser.Instance.Parse($"dotnet install tool -g {PackageId} --version [5.0,10.0]");
AppliedOption appliedCommand = result["dotnet"]["install"]["tool"];
var installToolCommand = new InstallToolCommand(
appliedCommand,
result,
_createToolPackageStoreAndInstaller,
_createShellShimRepository,
new EnvironmentPathInstructionMock(_reporter, PathToPlaceShim, true),
_reporter);
Action a = () => installToolCommand.Execute();
a.ShouldThrow <GracefulException>().And.Message
.Should().Contain(
LocalizableStrings.ToolInstallationRestoreFailed +
Environment.NewLine + string.Format(LocalizableStrings.ToolInstallationFailed, PackageId));
_fileSystem.Directory.Exists(Path.Combine(PathToPlacePackages, PackageId)).Should().BeFalse();
}
public void WhenRunWithInvalidVersionItShouldThrow()
{
const string invalidVersion = "!NotValidVersion!";
ParseResult result = Parser.Instance.Parse($"dotnet install tool -g {PackageId} --version {invalidVersion}");
AppliedOption appliedCommand = result["dotnet"]["install"]["tool"];
var installToolCommand = new InstallToolCommand(
appliedCommand,
result,
_createToolPackageStoreAndInstaller,
_createShellShimRepository,
new EnvironmentPathInstructionMock(_reporter, PathToPlaceShim, true),
_reporter);
Action action = () => installToolCommand.Execute();
action
.ShouldThrow <GracefulException>()
.WithMessage(string.Format(
LocalizableStrings.InvalidNuGetVersionRange,
invalidVersion));
}
public void WhenRunWithoutAMatchingRangeItShouldFail()
{
ParseResult result = Parser.Instance.Parse($"dotnet install tool -g {PackageId} --version [5.0,10.0]");
AppliedOption appliedCommand = result["dotnet"]["install"]["tool"];
var installToolCommand = new InstallToolCommand(
appliedCommand,
result,
_createToolPackageStoreAndInstaller,
_createShellShimRepository,
new EnvironmentPathInstructionMock(_reporter, PathToPlaceShim, true),
_reporter);
installToolCommand.Execute().Should().Be(1);
_reporter
.Lines
.Should()
.Equal(
$"Error: failed to restore package {PackageId}.", // From mock implementation, not localized
LocalizableStrings.ToolInstallationRestoreFailed.Red(),
string.Format(LocalizableStrings.ToolInstallationFailed, PackageId).Red());
}
