public void WhenRunWithPackageIdPackageFormatIsNotFullySupportedItShouldShowPathInstruction()
{
const string Warning = "WARNING";
var injectedWarnings = new Dictionary <PackageId, IEnumerable <string> >()
{
[new PackageId(PackageId)] = new List <string>()
{
Warning
}
};
var toolPackageInstaller = new ToolPackageInstallerMock(
fileSystem: _fileSystem,
store: _toolPackageStore,
projectRestorer: new ProjectRestorerMock(
fileSystem: _fileSystem,
reporter: _reporter),
warningsMap: injectedWarnings);
var installToolCommand = new ToolInstallCommand(
_appliedCommand,
_parseResult,
(_) => (_toolPackageStore, _toolPackageStoreQuery, toolPackageInstaller),
_createShellShimRepository,
_environmentPathInstructionMock,
_reporter);
installToolCommand.Execute().Should().Be(0);
_reporter.Lines.First().Should().Be(Warning.Yellow());
_reporter.Lines.Skip(1).First().Should().Be(EnvironmentPathInstructionMock.MockInstructionText);
}
) 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 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);
}
public ToolRestoreCommandTests()
{
_packageVersionA = NuGetVersion.Parse("1.0.4");
_packageVersionWithCommandNameCollisionWithA = NuGetVersion.Parse("1.0.9");
_packageVersionB = 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 List <MockFeed>
{
new MockFeed
{
Type = MockFeedType.ImplicitAdditionalFeed,
Packages = new List <MockFeedPackage>
{
new MockFeedPackage
{
PackageId = _packageIdA.ToString(),
Version = _packageVersionA.ToNormalizedString(),
ToolCommandName = _toolCommandNameA.ToString()
},
new MockFeedPackage
{
PackageId = _packageIdB.ToString(),
Version = _packageVersionB.ToNormalizedString(),
ToolCommandName = _toolCommandNameB.ToString()
},
new MockFeedPackage
{
PackageId = _packageIdWithCommandNameCollisionWithA.ToString(),
Version = _packageVersionWithCommandNameCollisionWithA.ToNormalizedString(),
ToolCommandName = "A"
}
}
}
}),
installCallback: () => _installCalledCount++);
_parseResult = Parser.Instance.Parse("dotnet tool restore");
_localToolsResolverCache
= new LocalToolsResolverCache(
_fileSystem,
new DirectoryPath(Path.Combine(_temporaryDirectory, "cache")),
1);
}
) Setup(
bool useMock,
List <MockFeed> feeds = null,
FilePath?tempProject = null,
DirectoryPath?offlineFeed = null,
[CallerMemberName] string testName = "",
string identifier = null)
{
var root = new DirectoryPath(_testAssetsManager.CreateTestDirectory(testName, identifier).Path);
var reporter = new BufferedReporter();
IFileSystem fileSystem;
IToolPackageStore store;
IToolPackageStoreQuery storeQuery;
IToolPackageInstaller installer;
IToolPackageUninstaller uninstaller;
if (useMock)
{
var packagedShimsMap = new Dictionary <PackageId, IReadOnlyList <FilePath> >
{
[TestPackageId] = new FilePath[] { new FilePath("path/demo.exe") }
};
fileSystem = new FileSystemMockBuilder().Build();
var toolPackageStoreMock = new ToolPackageStoreMock(root, fileSystem);
store = toolPackageStoreMock;
storeQuery = toolPackageStoreMock;
installer = new ToolPackageInstallerMock(
fileSystem: fileSystem,
store: toolPackageStoreMock,
projectRestorer: new ProjectRestorerMock(
fileSystem: fileSystem,
reporter: reporter,
feeds: feeds),
packagedShimsMap: packagedShimsMap);
uninstaller = new ToolPackageUninstallerMock(fileSystem, toolPackageStoreMock);
}
else
{
fileSystem = new FileSystemWrapper();
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);
}
) Setup(
bool useMock,
IEnumerable <MockFeed> feeds = null,
FilePath?tempProject = null,
DirectoryPath?offlineFeed = null)
{
var root = new DirectoryPath(Path.Combine(TempRoot.Root, Path.GetRandomFileName()));
var reporter = new BufferedReporter();
IFileSystem fileSystem;
IToolPackageStore store;
IToolPackageStoreQuery storeQuery;
IToolPackageInstaller installer;
IToolPackageUninstaller uninstaller;
if (useMock)
{
var packagedShimsMap = new Dictionary <PackageId, IReadOnlyList <FilePath> >
{
[TestPackageId] = new FilePath[] { new FilePath("path/demo.exe") }
};
fileSystem = new FileSystemMockBuilder().Build();
var toolPackageStoreMock = new ToolPackageStoreMock(root, fileSystem);
store = toolPackageStoreMock;
storeQuery = toolPackageStoreMock;
installer = new ToolPackageInstallerMock(
fileSystem: fileSystem,
store: toolPackageStoreMock,
projectRestorer: new ProjectRestorerMock(
fileSystem: fileSystem,
reporter: reporter,
feeds: feeds),
packagedShimsMap: packagedShimsMap);
uninstaller = new ToolPackageUninstallerMock(fileSystem, toolPackageStoreMock);
}
else
{
fileSystem = new FileSystemWrapper();
var toolPackageStore = new ToolPackageStoreAndQuery(root);
store = toolPackageStore;
storeQuery = toolPackageStore;
installer = new ToolPackageInstaller(
store: store,
projectRestorer: new ProjectRestorer(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);
}
) Setup(
bool useMock,
List <MockFeed> feeds = null,
FilePath?tempProject = null,
DirectoryPath?offlineFeed = null,
FilePath?writeLocalFeedToNugetConfig = null)
{
var root = new DirectoryPath(Path.Combine(TempRoot.Root, Path.GetRandomFileName()));
var reporter = new BufferedReporter();
IFileSystem fileSystem;
IToolPackageStore store;
IToolPackageStoreQuery storeQuery;
IToolPackageInstaller installer;
IToolPackageUninstaller uninstaller;
if (useMock)
{
fileSystem = new FileSystemMockBuilder().Build();
WriteNugetConfigFileToPointToTheFeed(fileSystem, writeLocalFeedToNugetConfig);
var toolPackageStoreMock = new ToolPackageStoreMock(root, fileSystem);
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()));
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 ProjectRestorer(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);
}
private void SetupFileLayoutAndFeed(string temporaryDirectory, ToolPackageStoreMock toolPackageStoreMock)
{
var testRoot = Path.Combine(temporaryDirectory, "testRoot");
_fileSystem.Directory.CreateDirectory(testRoot);
_nugetConfigUnderTestRoot = Path.Combine(testRoot, "nuget.config");
_fileSystem.File.CreateEmptyFile(_nugetConfigUnderTestRoot);
var subDir = Path.Combine(testRoot, "sub");
_fileSystem.Directory.CreateDirectory(subDir);
_nugetConfigUnderSubDir = Path.Combine(subDir, "nuget.config");
_fileSystem.File.CreateEmptyFile(_nugetConfigUnderSubDir);
_toolPackageInstallerMock = new ToolPackageInstallerMock(
_fileSystem,
toolPackageStoreMock,
new ProjectRestorerMock(
_fileSystem,
_reporter,
new[]
{
new MockFeed
{
Type = MockFeedType.FeedFromLookUpNugetConfig,
Uri = _nugetConfigUnderTestRoot,
Packages = new List <MockFeedPackage>
{
new MockFeedPackage
{
PackageId = _packageIdA.ToString(),
Version = _packageVersionA.ToNormalizedString(),
ToolCommandName = _toolCommandNameA.ToString()
},
}
},
new MockFeed
{
Type = MockFeedType.FeedFromLookUpNugetConfig,
Uri = _nugetConfigUnderSubDir,
Packages = new List <MockFeedPackage>
{
new MockFeedPackage
{
PackageId = _packageIdB.ToString(),
Version = _packageVersionB.ToNormalizedString(),
ToolCommandName = _toolCommandNameB.ToString()
},
}
}
}));
}
private ToolInstallCommand CreateInstallCommand(string options)
{
ParseResult result = Parser.Instance.Parse("dotnet tool install " + options);
var store = new ToolPackageStoreMock(new DirectoryPath(ToolsDirectory), _fileSystem);
var packageInstallerMock = new ToolPackageInstallerMock(
_fileSystem,
store,
new ProjectRestorerMock(
_fileSystem,
_reporter));
return(new ToolInstallCommand(
result["dotnet"]["tool"]["install"],
result,
(_) => (store, packageInstallerMock),
(_) => new ShellShimRepositoryMock(new DirectoryPath(ShimsDirectory), _fileSystem),
_environmentPathInstructionMock,
_reporter));
}
private static (IToolPackageStore, IToolPackageInstaller, BufferedReporter, IFileSystem) Setup(
bool useMock,
IEnumerable <MockFeed> feeds = null,
FilePath?tempProject = null,
DirectoryPath?offlineFeed = null)
{
var root = new DirectoryPath(Path.Combine(TempRoot.Root, Path.GetRandomFileName()));
var reporter = new BufferedReporter();
IFileSystem fileSystem;
IToolPackageStore store;
IToolPackageInstaller installer;
if (useMock)
{
fileSystem = new FileSystemMockBuilder().Build();
store = new ToolPackageStoreMock(root, fileSystem);
installer = new ToolPackageInstallerMock(
fileSystem: fileSystem,
store: store,
projectRestorer: new ProjectRestorerMock(
fileSystem: fileSystem,
reporter: reporter,
feeds: feeds));
}
else
{
fileSystem = new FileSystemWrapper();
store = new ToolPackageStore(root);
installer = new ToolPackageInstaller(
store: store,
projectRestorer: new ProjectRestorer(reporter),
tempProject: tempProject ?? GetUniqueTempProjectPathEachTest(),
offlineFeed: offlineFeed ?? new DirectoryPath("does not exist"));
}
store.Root.Value.Should().Be(Path.GetFullPath(root.Value));
return(store, installer, reporter, fileSystem);
}
private ToolInstallGlobalOrToolPathCommand CreateInstallCommand(string options)
{
ParseResult result = Parser.Instance.Parse("dotnet tool install " + options);
var store = new ToolPackageStoreMock(new DirectoryPath(_toolsDirectory), _fileSystem);
var packageInstallerMock = new ToolPackageInstallerMock(
_fileSystem,
store,
new ProjectRestorerMock(
_fileSystem,
_reporter));
return(new ToolInstallGlobalOrToolPathCommand(
result,
(location, forwardArguments) => (store, store, packageInstallerMock),
(_) => new ShellShimRepository(
new DirectoryPath(_shimsDirectory),
fileSystem: _fileSystem,
appHostShellShimMaker: new AppHostShellShimMakerMock(_fileSystem)),
_environmentPathInstructionMock,
_reporter));
}
private (IToolPackageStore, IToolPackageInstaller, BufferedReporter, IFileSystem) Setup(
bool useMock,
string testDirectory,
List <MockFeed> feeds = null,
FilePath?tempProject = null,
DirectoryPath?offlineFeed = null)
{
var root = new DirectoryPath(Path.Combine(Directory.GetCurrentDirectory(), Path.GetRandomFileName()));
var reporter = new BufferedReporter();
IFileSystem fileSystem;
IToolPackageStore store;
IToolPackageInstaller installer;
if (useMock)
{
fileSystem = new FileSystemMockBuilder().Build();
store = new ToolPackageStoreMock(root, fileSystem);
installer = new ToolPackageInstallerMock(
fileSystem: fileSystem,
store: store,
projectRestorer: new ProjectRestorerMock(
fileSystem: fileSystem,
reporter: reporter,
feeds: feeds));
}
else
{
fileSystem = new FileSystemWrapper();
store = new ToolPackageStoreAndQuery(root);
installer = new ToolPackageInstaller(
store: store,
projectRestorer: new Stage2ProjectRestorer(Log, reporter),
tempProject: tempProject ?? GetUniqueTempProjectPathEachTest(testDirectory),
offlineFeed: offlineFeed ?? new DirectoryPath("does not exist"));
}
return(store, installer, reporter, fileSystem);
}
public void GivenOfflineFeedInstallWhenCallWithprereleaseItSucceeds(bool testMockBehaviorIsInSync)
{
IToolPackageInstaller installer = null;
IToolPackageUninstaller uninstaller = null;
if (testMockBehaviorIsInSync == false)
{
var testFeedWithOnlyPreviewPackages =
Path.Combine(Path.GetTempPath(),
Path.GetRandomFileName());
Directory.CreateDirectory(testFeedWithOnlyPreviewPackages);
var tempFeed = GetTestLocalFeedPath();
File.Copy(Path.Combine(GetTestLocalFeedPath(), "global.tool.console.demo.1.0.4.nupkg"),
Path.Combine(testFeedWithOnlyPreviewPackages, "global.tool.console.demo.1.0.4.nupkg"));
File.Copy(Path.Combine(GetTestLocalFeedPath(), "global.tool.console.demo.2.0.1-preview1.nupkg"),
Path.Combine(testFeedWithOnlyPreviewPackages, "global.tool.console.demo.2.0.1-preview1.nupkg"));
var(store, storeQuery, realInstaller, realUninstaller, reporter, fileSystem) = Setup(
useMock: testMockBehaviorIsInSync,
offlineFeed: new DirectoryPath(testFeedWithOnlyPreviewPackages),
feeds: GetOfflineMockFeed());
installer = realInstaller;
uninstaller = realUninstaller;
}
else
{
var fileSystem = new FileSystemMockBuilder().Build();
var root = new DirectoryPath(_testAssetsManager
.CreateTestDirectory(nameof(GivenOfflineFeedInstallWhenCallWithprereleaseItSucceeds) +
testMockBehaviorIsInSync).Path);
var toolPackageStoreMock = new ToolPackageStoreMock(root, fileSystem);
var store = toolPackageStoreMock;
var storeQuery = toolPackageStoreMock;
installer = new ToolPackageInstallerMock(
fileSystem: fileSystem,
store: toolPackageStoreMock,
projectRestorer: new ProjectRestorerMock(
fileSystem: fileSystem,
reporter: new BufferedReporter(),
feeds: new List <MockFeed>
{
new MockFeed
{
Type = MockFeedType.ImplicitAdditionalFeed,
Packages = new List <MockFeedPackage>
{
new MockFeedPackage
{
PackageId = TestPackageId.ToString(),
Version = "1.0.4",
ToolCommandName = "SimulatorCommand"
},
new MockFeedPackage
{
PackageId = TestPackageId.ToString(),
Version = "2.0.1-preview1",
ToolCommandName = "SimulatorCommand"
}
}
}
}));
uninstaller = new ToolPackageUninstallerMock(fileSystem, toolPackageStoreMock);
}
var package = installer.InstallPackage(new PackageLocation(), packageId: TestPackageId,
versionRange: VersionRange.Parse("*-*"), targetFramework: _testTargetframework);
package.Version.ToNormalizedString().Should().Be("2.0.1-preview1");
uninstaller.Uninstall(package.PackageDirectory);
var package2 = installer.InstallPackage(new PackageLocation(), packageId: TestPackageId,
versionRange: VersionRange.Parse("2.0*-*"), targetFramework: _testTargetframework);
package2.Version.ToNormalizedString().Should().Be("2.0.1-preview1");
uninstaller.Uninstall(package.PackageDirectory);
}
public ToolUpdateLocalCommandTests()
{
_reporter = new BufferedReporter();
_fileSystem = new FileSystemMockBuilder().UseCurrentSystemTemporaryDirectory().Build();
_temporaryDirectoryParent = _fileSystem.Directory.CreateTemporaryDirectory().DirectoryPath;
_temporaryDirectory = Path.Combine(_temporaryDirectoryParent, "sub");
_fileSystem.Directory.CreateDirectory(_temporaryDirectory);
_pathToPlacePackages = Path.Combine(_temporaryDirectory, "pathToPlacePackage");
_packageOriginalVersionA = NuGetVersion.Parse("1.0.0");
_packageNewVersionA = NuGetVersion.Parse("2.0.0");
ToolPackageStoreMock toolPackageStoreMock =
new ToolPackageStoreMock(new DirectoryPath(_pathToPlacePackages), _fileSystem);
_toolPackageStore = toolPackageStoreMock;
_mockFeed = new MockFeed
{
Type = MockFeedType.ImplicitAdditionalFeed,
Packages = new List <MockFeedPackage>
{
new MockFeedPackage
{
PackageId = _packageIdA.ToString(),
Version = _packageOriginalVersionA.ToNormalizedString(),
ToolCommandName = _toolCommandNameA.ToString()
}
}
};
_toolPackageInstallerMock = new ToolPackageInstallerMock(
_fileSystem,
_toolPackageStore,
new ProjectRestorerMock(
_fileSystem,
_reporter,
new List <MockFeed>
{
_mockFeed
}));
_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,
new FakeDangerousFileDetector());
_toolManifestEditor = new ToolManifestEditor(_fileSystem, new FakeDangerousFileDetector());
_parseResult = Parser.Instance.Parse($"dotnet tool update {_packageIdA.ToString()}");
_toolRestoreCommand = new ToolRestoreCommand(
_parseResult,
_toolPackageInstallerMock,
_toolManifestFinder,
_localToolsResolverCache,
_fileSystem,
_reporter
);
_defaultToolUpdateLocalCommand = new ToolUpdateLocalCommand(
_parseResult,
_toolPackageInstallerMock,
_toolManifestFinder,
_toolManifestEditor,
_localToolsResolverCache,
_reporter);
}
