public void GivenWorkloadManifestUpdateItCanUpdateAdvertisingManifests()
{
var testDir = _testAssetsManager.CreateTestDirectory().Path;
var featureBand = "6.0.100";
var dotnetRoot = Path.Combine(testDir, "dotnet");
var installedManifests = new ManifestId[] { new ManifestId("test-manifest-1"), new ManifestId("test-manifest-2"), new ManifestId("test-manifest-3") };
// Write mock manifests
var installedManifestDir = Path.Combine(testDir, "dotnet", "sdk-manifests", featureBand);
var adManifestDir = Path.Combine(testDir, ".dotnet", "sdk-advertising", featureBand);
Directory.CreateDirectory(installedManifestDir);
Directory.CreateDirectory(adManifestDir);
foreach (var manifest in installedManifests)
{
Directory.CreateDirectory(Path.Combine(installedManifestDir, manifest.ToString()));
File.WriteAllText(Path.Combine(installedManifestDir, manifest.ToString(), _manifestFileName), GetManifestContent(new ManifestVersion("1.0.0")));
}
var manifestDirs = installedManifests
.Select(manifest => Path.Combine(installedManifestDir, manifest.ToString(), _manifestFileName))
.ToArray();
var workloadManifestProvider = new MockManifestProvider(manifestDirs);
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot, manifestDownload: true);
var manifestUpdater = new WorkloadManifestUpdater(_reporter, workloadManifestProvider, nugetDownloader, testDir, testDir);
manifestUpdater.UpdateAdvertisingManifestsAsync(true).Wait();
var expectedDownloadedPackages = installedManifests
.Select(id => ((PackageId, NuGetVersion, DirectoryPath?, PackageSourceLocation))(new PackageId($"{id}.manifest-{featureBand}"), null, null, null));
nugetDownloader.DownloadCallParams.Should().BeEquivalentTo(expectedDownloadedPackages);
}
public void GivenWorkloadUpdateAcrossFeatureBandsItUpdatesPacks(bool userLocal)
{
var testDirectory = _testAssetsManager.CreateTestDirectory(identifier: userLocal ? "userlocal" : "default").Path;
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
var userProfileDir = Path.Combine(testDirectory, "user-profile");
var manifestPath = Path.Combine(_testAssetsManager.GetAndValidateTestProjectDirectory("SampleManifest"), "BasicSample.json");
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { manifestPath }), dotnetRoot, userLocal, userProfileDir);
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot);
var manifestUpdater = new MockWorkloadManifestUpdater();
var sdkFeatureVersion = "6.0.100";
var installingWorkload = "simple-workload";
string installRoot = userLocal ? userProfileDir : dotnetRoot;
if (userLocal)
{
WorkloadFileBasedInstall.SetUserLocal(dotnetRoot, sdkFeatureVersion);
}
var workloadPacks = new List <PackInfo>()
{
CreatePackInfo("mock-pack-1", "1.0.0", WorkloadPackKind.Framework, Path.Combine(installRoot, "packs", "mock-pack-1", "1.0.0"), "mock-pack-1"),
CreatePackInfo("mock-pack-2", "2.0.0", WorkloadPackKind.Framework, Path.Combine(installRoot, "packs", "mock-pack-2", "2.0.0"), "mock-pack-2")
};
// Lay out workload installs for a previous feature band
var oldFeatureBand = "5.0.100";
var packRecordDir = Path.Combine(installRoot, "metadata", "workloads", "InstalledPacks", "v1");
foreach (var pack in workloadPacks)
{
Directory.CreateDirectory(Path.Combine(packRecordDir, pack.Id, pack.Version));
File.Create(Path.Combine(packRecordDir, pack.Id, pack.Version, oldFeatureBand));
}
Directory.CreateDirectory(Path.Combine(installRoot, "metadata", "workloads", oldFeatureBand, "InstalledWorkloads"));
Directory.CreateDirectory(Path.Combine(installRoot, "metadata", "workloads", sdkFeatureVersion, "InstalledWorkloads"));
File.Create(Path.Combine(installRoot, "metadata", "workloads", oldFeatureBand, "InstalledWorkloads", installingWorkload));
File.Create(Path.Combine(installRoot, "metadata", "workloads", sdkFeatureVersion, "InstalledWorkloads", installingWorkload));
// Update workload (without installing any workloads to this feature band)
var updateParseResult = Parser.Instance.Parse(new string[] { "dotnet", "workload", "update", "--from-previous-sdk" });
var updateCommand = new WorkloadUpdateCommand(updateParseResult, reporter: _reporter, workloadResolver: workloadResolver, nugetPackageDownloader: nugetDownloader,
workloadManifestUpdater: manifestUpdater, userProfileDir: userProfileDir, version: sdkFeatureVersion, dotnetDir: dotnetRoot, tempDirPath: testDirectory);
updateCommand.Execute();
foreach (var pack in workloadPacks)
{
Directory.Exists(pack.Path).Should().BeTrue(because: $"Pack should be installed {testDirectory}");
File.Exists(Path.Combine(packRecordDir, pack.Id, pack.Version, oldFeatureBand))
.Should().BeTrue(because: "Pack install record should still be present for old feature band");
}
File.Exists(Path.Combine(installRoot, "metadata", "workloads", oldFeatureBand, "InstalledWorkloads", installingWorkload))
.Should().BeTrue(because: "Workload install record should still be present for old feature band");
File.Exists(Path.Combine(installRoot, "metadata", "workloads", sdkFeatureVersion, "InstalledWorkloads", installingWorkload))
.Should().BeTrue(because: "Workload install record should be present for current feature band");
}
private void UninstallWorkload(string uninstallingWorkload, string testDirectory, string sdkFeatureVersion)
{
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { _manifestPath }), new string[] { dotnetRoot });
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot);
var uninstallParseResult = Parser.GetWorkloadsInstance.Parse(new string[] { "dotnet", "workload", "uninstall", uninstallingWorkload });
var uninstallCommand = new WorkloadUninstallCommand(uninstallParseResult, reporter: _reporter, workloadResolver, nugetDownloader, dotnetDir: dotnetRoot, version: sdkFeatureVersion);
uninstallCommand.Execute();
}
private void InstallWorkload(string installingWorkload, string testDirectory, string sdkFeatureVersion)
{
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { _manifestPath }), new string[] { dotnetRoot });
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot);
var manifestUpdater = new MockWorkloadManifestUpdater();
var installParseResult = Parser.Instance.Parse(new string[] { "dotnet", "workload", "install", installingWorkload });
var installCommand = new WorkloadInstallCommand(installParseResult, reporter: _reporter, workloadResolver: workloadResolver, nugetPackageDownloader: nugetDownloader,
workloadManifestUpdater: manifestUpdater, userHome: testDirectory, version: sdkFeatureVersion, dotnetDir: dotnetRoot, tempDirPath: testDirectory);
installCommand.Execute();
}
private void UninstallWorkload(string uninstallingWorkload, string testDirectory, string sdkFeatureVersion)
{
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
var userProfileDir = Path.Combine(testDirectory, "user-profile");
bool userLocal = WorkloadFileBasedInstall.IsUserLocal(dotnetRoot, sdkFeatureVersion);
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { _manifestPath }), dotnetRoot, userLocal, userProfileDir);
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot);
var uninstallParseResult = Parser.Instance.Parse(new string[] { "dotnet", "workload", "uninstall", uninstallingWorkload });
var uninstallCommand = new WorkloadUninstallCommand(uninstallParseResult, reporter: _reporter, workloadResolver, nugetDownloader,
dotnetDir: dotnetRoot, version: sdkFeatureVersion, userProfileDir: userProfileDir);
uninstallCommand.Execute();
}
public void GivenExtraPacksInstalledRepairGarbageCollects(bool userLocal)
{
var testDirectory = _testAssetsManager.CreateTestDirectory(identifier: userLocal ? "userlocal" : "default").Path;
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
var userProfileDir = Path.Combine(testDirectory, "user-profile");
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { _manifestPath }), dotnetRoot, userLocal, userProfileDir);
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot);
var manifestUpdater = new MockWorkloadManifestUpdater();
var sdkFeatureVersion = "6.0.100";
var installingWorkload = "xamarin-android";
string installRoot = userLocal ? userProfileDir : dotnetRoot;
if (userLocal)
{
WorkloadFileBasedInstall.SetUserLocal(dotnetRoot, sdkFeatureVersion);
}
// Install a workload
var installParseResult = Parser.Instance.Parse(new string[] { "dotnet", "workload", "install", installingWorkload });
var installCommand = new WorkloadInstallCommand(installParseResult, reporter: _reporter, workloadResolver: workloadResolver, nugetPackageDownloader: nugetDownloader,
workloadManifestUpdater: manifestUpdater, userProfileDir: userProfileDir, version: sdkFeatureVersion, dotnetDir: dotnetRoot, tempDirPath: testDirectory);
installCommand.Execute();
// Add extra pack dirs and records
var extraPackRecordPath = Path.Combine(installRoot, "metadata", "workloads", "InstalledPacks", "v1", "Test.Pack.A", "1.0.0", sdkFeatureVersion);
Directory.CreateDirectory(Path.GetDirectoryName(extraPackRecordPath));
File.WriteAllText(extraPackRecordPath, string.Empty);
var extraPackPath = Path.Combine(installRoot, "packs", "Test.Pack.A", "1.0.0");
Directory.CreateDirectory(extraPackPath);
var repairCommand = new WorkloadRepairCommand(_parseResult, reporter: _reporter, workloadResolver: workloadResolver, userProfileDir: userProfileDir,
nugetPackageDownloader: nugetDownloader, version: sdkFeatureVersion, dotnetDir: dotnetRoot, tempDirPath: testDirectory);
repairCommand.Execute();
// Check that pack dirs and records have been removed
File.Exists(extraPackRecordPath).Should().BeFalse();
Directory.Exists(Path.GetDirectoryName(Path.GetDirectoryName(extraPackRecordPath))).Should().BeFalse();
Directory.Exists(extraPackPath).Should().BeFalse();
// Expected packs are still present
Directory.GetDirectories(Path.Combine(installRoot, "packs")).Length.Should().Be(7);
Directory.GetDirectories(Path.Combine(installRoot, "metadata", "workloads", "InstalledPacks", "v1")).Length.Should().Be(8);
}
public void GivenNoWorkloadsAreInstalledRepairIsNoOp()
{
_reporter.Clear();
var testDirectory = _testAssetsManager.CreateTestDirectory().Path;
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot);
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { _manifestPath }), new string[] { dotnetRoot });
var sdkFeatureVersion = "6.0.100";
var repairCommand = new WorkloadRepairCommand(_parseResult, reporter: _reporter, workloadResolver: workloadResolver,
nugetPackageDownloader: nugetDownloader, version: sdkFeatureVersion, dotnetDir: dotnetRoot);
repairCommand.Execute();
_reporter.Lines.Should().Contain(string.Format(LocalizableStrings.RepairSucceeded, string.Empty));
}
public void GivenMissingPacksRepairFixesInstall(bool userLocal)
{
var testDirectory = _testAssetsManager.CreateTestDirectory(identifier: userLocal ? "userlocal" : "default").Path;
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
var userProfileDir = Path.Combine(testDirectory, "user-profile");
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { _manifestPath }), dotnetRoot, userLocal, userProfileDir);
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot);
var manifestUpdater = new MockWorkloadManifestUpdater();
var sdkFeatureVersion = "6.0.100";
var installingWorkload = "xamarin-android";
string installRoot = userLocal ? userProfileDir : dotnetRoot;
if (userLocal)
{
WorkloadFileBasedInstall.SetUserLocal(dotnetRoot, sdkFeatureVersion);
}
// Install a workload
var installParseResult = Parser.Instance.Parse(new string[] { "dotnet", "workload", "install", installingWorkload });
var installCommand = new WorkloadInstallCommand(installParseResult, reporter: _reporter, workloadResolver: workloadResolver, nugetPackageDownloader: nugetDownloader,
workloadManifestUpdater: manifestUpdater, userProfileDir: userProfileDir, version: sdkFeatureVersion, dotnetDir: dotnetRoot, tempDirPath: testDirectory);
installCommand.Execute();
// Delete pack dirs/ records
var deletedPackRecordPath = Path.Combine(installRoot, "metadata", "workloads", "InstalledPacks", "v1", "Xamarin.Android.Sdk", "8.4.7", sdkFeatureVersion);
File.Delete(deletedPackRecordPath);
var deletedPackPath = Path.Combine(installRoot, "packs", "Xamarin.Android.Sdk");
Directory.Delete(deletedPackPath, true);
var repairCommand = new WorkloadRepairCommand(_parseResult, reporter: _reporter, workloadResolver: workloadResolver, userProfileDir: userProfileDir,
nugetPackageDownloader: nugetDownloader, version: sdkFeatureVersion, dotnetDir: dotnetRoot, tempDirPath: testDirectory);
repairCommand.Execute();
// Check that pack dirs and records have been replaced
File.Exists(deletedPackRecordPath).Should().BeTrue();
Directory.Exists(deletedPackPath).Should().BeTrue();
// All expected packs are still present
Directory.GetDirectories(Path.Combine(installRoot, "packs")).Length.Should().Be(7);
Directory.GetDirectories(Path.Combine(installRoot, "metadata", "workloads", "InstalledPacks", "v1")).Length.Should().Be(8);
}
public void WhenRunWithArchOptionItDownloadsAppHostTemplate()
{
var nugetPackageDownloader = new MockNuGetPackageDownloader();
var parseResult = Parser.Instance.Parse($"dotnet tool install -g {PackageId} -a arm64");
var toolInstallGlobalOrToolPathCommand = new ToolInstallGlobalOrToolPathCommand(
parseResult,
_createToolPackageStoreAndInstaller,
_createShellShimRepository,
_environmentPathInstructionMock,
_reporter,
nugetPackageDownloader);
toolInstallGlobalOrToolPathCommand.Execute().Should().Be(0);
nugetPackageDownloader.DownloadCallParams.Count.Should().Be(1);
nugetPackageDownloader.ExtractCallParams.Count.Should().Be(1);
nugetPackageDownloader.DownloadCallParams.First().Item1.Should().Be(new PackageId("microsoft.netcore.app.host.win-arm64"));
}
public void GivenWorkloadManifestUpdateItCanCalculateUpdates()
{
var testDir = _testAssetsManager.CreateTestDirectory().Path;
var featureBand = "6.0.100";
var dotnetRoot = Path.Combine(testDir, "dotnet");
var expectedManifestUpdates = new ManifestVersionUpdate[] {
new ManifestVersionUpdate(new ManifestId("test-manifest-1"), new ManifestVersion("5.0.0"), featureBand, new ManifestVersion("7.0.0"), featureBand),
new ManifestVersionUpdate(new ManifestId("test-manifest-2"), new ManifestVersion("3.0.0"), featureBand, new ManifestVersion("4.0.0"), featureBand)
};
var expectedManifestNotUpdated = new ManifestId[] { new ManifestId("test-manifest-3"), new ManifestId("test-manifest-4") };
// Write mock manifests
var installedManifestDir = Path.Combine(testDir, "dotnet", "sdk-manifests", featureBand);
var adManifestDir = Path.Combine(testDir, ".dotnet", "sdk-advertising", featureBand);
Directory.CreateDirectory(installedManifestDir);
Directory.CreateDirectory(adManifestDir);
foreach (ManifestVersionUpdate manifestUpdate in expectedManifestUpdates)
{
Directory.CreateDirectory(Path.Combine(installedManifestDir, manifestUpdate.ManifestId.ToString()));
File.WriteAllText(Path.Combine(installedManifestDir, manifestUpdate.ManifestId.ToString(), _manifestFileName), GetManifestContent(manifestUpdate.ExistingVersion));
Directory.CreateDirectory(Path.Combine(adManifestDir, manifestUpdate.ManifestId.ToString()));
File.WriteAllText(Path.Combine(adManifestDir, manifestUpdate.ManifestId.ToString(), _manifestFileName), GetManifestContent(manifestUpdate.NewVersion));
}
foreach (var manifest in expectedManifestNotUpdated)
{
Directory.CreateDirectory(Path.Combine(installedManifestDir, manifest.ToString()));
File.WriteAllText(Path.Combine(installedManifestDir, manifest.ToString(), _manifestFileName), GetManifestContent(new ManifestVersion("5.0.0")));
Directory.CreateDirectory(Path.Combine(adManifestDir, manifest.ToString()));
File.WriteAllText(Path.Combine(adManifestDir, manifest.ToString(), _manifestFileName), GetManifestContent(new ManifestVersion("5.0.0")));
}
var manifestDirs = expectedManifestUpdates.Select(manifest => manifest.ManifestId)
.Concat(expectedManifestNotUpdated)
.Select(manifest => Path.Combine(installedManifestDir, manifest.ToString(), _manifestFileName))
.ToArray();
var workloadManifestProvider = new MockManifestProvider(manifestDirs);
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot);
var workloadResolver = WorkloadResolver.CreateForTests(workloadManifestProvider, dotnetRoot);
var installationRepo = new MockInstallationRecordRepository();
var manifestUpdater = new WorkloadManifestUpdater(_reporter, workloadResolver, nugetDownloader, userProfileDir: Path.Combine(testDir, ".dotnet"), testDir, installationRepo);
var manifestUpdates = manifestUpdater.CalculateManifestUpdates().Select(m => m.manifestUpdate);
manifestUpdates.Should().BeEquivalentTo(expectedManifestUpdates);
}
public void GivenWorkloadManifestRollbackItCanCalculateUpdates()
{
var testDir = _testAssetsManager.CreateTestDirectory().Path;
var currentFeatureBand = "6.0.100";
var dotnetRoot = Path.Combine(testDir, "dotnet");
var expectedManifestUpdates = new ManifestVersionUpdate[] {
new ManifestVersionUpdate(new ManifestId("test-manifest-1"), new ManifestVersion("5.0.0"), currentFeatureBand, new ManifestVersion("4.0.0"), currentFeatureBand),
new ManifestVersionUpdate(new ManifestId("test-manifest-2"), new ManifestVersion("3.0.0"), currentFeatureBand, new ManifestVersion("2.0.0"), currentFeatureBand)
};
// Write mock manifests
var installedManifestDir = Path.Combine(testDir, "dotnet", "sdk-manifests", currentFeatureBand);
var adManifestDir = Path.Combine(testDir, ".dotnet", "sdk-advertising", currentFeatureBand);
Directory.CreateDirectory(installedManifestDir);
Directory.CreateDirectory(adManifestDir);
foreach (var manifestUpdate in expectedManifestUpdates)
{
Directory.CreateDirectory(Path.Combine(installedManifestDir, manifestUpdate.ManifestId.ToString()));
File.WriteAllText(Path.Combine(installedManifestDir, manifestUpdate.ManifestId.ToString(), _manifestFileName), GetManifestContent(manifestUpdate.ExistingVersion));
}
var rollbackDefContent = JsonSerializer.Serialize(new Dictionary <string, string>()
{
{ "test-manifest-1", "4.0.0" }, { "test-manifest-2", "2.0.0" }
});
var rollbackDefPath = Path.Combine(testDir, "testRollbackDef.txt");
File.WriteAllText(rollbackDefPath, rollbackDefContent);
var manifestDirs = expectedManifestUpdates.Select(manifest => manifest.ManifestId)
.Select(manifest => Path.Combine(installedManifestDir, manifest.ToString(), _manifestFileName))
.ToArray();
var workloadManifestProvider = new MockManifestProvider(manifestDirs);
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot);
var workloadResolver = WorkloadResolver.CreateForTests(workloadManifestProvider, dotnetRoot);
var installationRepo = new MockInstallationRecordRepository();
var manifestUpdater = new WorkloadManifestUpdater(_reporter, workloadResolver, nugetDownloader, testDir, testDir, installationRepo);
var manifestUpdates = manifestUpdater.CalculateManifestRollbacks(rollbackDefPath);
manifestUpdates.Should().BeEquivalentTo(expectedManifestUpdates);
}
public void GivenNoWorkloadsAreInstalledRepairIsNoOp(bool userLocal)
{
_reporter.Clear();
var testDirectory = _testAssetsManager.CreateTestDirectory(identifier: userLocal ? "userlocal" : "default").Path;
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
var userProfileDir = Path.Combine(testDirectory, "user-profile");
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot);
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { _manifestPath }), dotnetRoot, userLocal, userProfileDir);
var sdkFeatureVersion = "6.0.100";
if (userLocal)
{
WorkloadFileBasedInstall.SetUserLocal(dotnetRoot, sdkFeatureVersion);
}
var repairCommand = new WorkloadRepairCommand(_parseResult, reporter: _reporter, workloadResolver: workloadResolver,
nugetPackageDownloader: nugetDownloader, version: sdkFeatureVersion, dotnetDir: dotnetRoot, userProfileDir: userProfileDir);
repairCommand.Execute();
_reporter.Lines.Should().Contain(LocalizableStrings.NoWorkloadsToRepair);
}
public void GivenWorkloadUpdateItRemovesOldPacksAfterInstall(bool userLocal)
{
var testDirectory = _testAssetsManager.CreateTestDirectory(identifier: userLocal ? "userlocal" : "default").Path;
var dotnetRoot = Path.Combine(testDirectory, "dotnet");
var userProfileDir = Path.Combine(testDirectory, "user-profile");
var workloadResolver = WorkloadResolver.CreateForTests(new MockManifestProvider(new[] { _manifestPath }), dotnetRoot, userLocal, userProfileDir);
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot);
var manifestUpdater = new MockWorkloadManifestUpdater();
var sdkFeatureVersion = "6.0.100";
var installingWorkload = "xamarin-android";
string installRoot = userLocal ? userProfileDir : dotnetRoot;
if (userLocal)
{
WorkloadFileBasedInstall.SetUserLocal(dotnetRoot, sdkFeatureVersion);
}
// Install a workload
var installParseResult = Parser.Instance.Parse(new string[] { "dotnet", "workload", "install", installingWorkload });
var installCommand = new WorkloadInstallCommand(installParseResult, reporter: _reporter, workloadResolver: workloadResolver, nugetPackageDownloader: nugetDownloader,
workloadManifestUpdater: manifestUpdater, userProfileDir: userProfileDir, version: sdkFeatureVersion, dotnetDir: dotnetRoot, tempDirPath: testDirectory);
installCommand.Execute();
// 7 packs in packs dir, 1 template pack
var installPacks = Directory.GetDirectories(Path.Combine(installRoot, "packs"));
installPacks.Count().Should().Be(7);
foreach (var packDir in installPacks)
{
Directory.GetDirectories(packDir).Count().Should().Be(1); // 1 version of each pack installed
}
File.Exists(Path.Combine(installRoot, "metadata", "workloads", "InstalledPacks", "v1", "Xamarin.Android.Sdk", "8.4.7", "6.0.100")) // Original pack version is installed
.Should().BeTrue();
File.Exists(Path.Combine(installRoot, "template-packs", "xamarin.android.templates.1.0.3.nupkg"))
.Should().BeTrue();
// Install records are correct
File.Exists(Path.Combine(installRoot, "metadata", "workloads", sdkFeatureVersion, "InstalledWorkloads", installingWorkload))
.Should().BeTrue();
var packRecordDirs = Directory.GetDirectories(Path.Combine(installRoot, "metadata", "workloads", "InstalledPacks", "v1"));
packRecordDirs.Count().Should().Be(8);
foreach (var packRecordDir in packRecordDirs)
{
var packVersionRecordDirs = Directory.GetDirectories(packRecordDir);
packVersionRecordDirs.Count().Should().Be(1); // 1 version of each pack installed
Directory.GetFiles(packVersionRecordDirs.First()).Count().Should().Be(1); // 1 feature band file for this pack id and version
}
// Mock updating the manifest
workloadResolver = WorkloadResolver.CreateForTests(
new MockManifestProvider(new[] { Path.Combine(_testAssetsManager.GetAndValidateTestProjectDirectory("SampleUpdatedManifest"), "Sample.json") }),
dotnetRoot, userLocal, userProfileDir);
// Update workload
var updateParseResult = Parser.Instance.Parse(new string[] { "dotnet", "workload", "update" });
var updateCommand = new WorkloadUpdateCommand(updateParseResult, reporter: _reporter, workloadResolver: workloadResolver, nugetPackageDownloader: nugetDownloader,
workloadManifestUpdater: manifestUpdater, userProfileDir: userProfileDir, version: sdkFeatureVersion, dotnetDir: dotnetRoot, tempDirPath: testDirectory);
updateCommand.Execute();
// 6 packs in packs dir, 1 template pack
var updatePacks = Directory.GetDirectories(Path.Combine(installRoot, "packs"));
updatePacks.Count().Should().Be(6);
foreach (var packDir in updatePacks)
{
Directory.GetDirectories(packDir).Count().Should().Be(1); // 1 version of each pack installed
}
File.Exists(Path.Combine(installRoot, "metadata", "workloads", "InstalledPacks", "v1", "Xamarin.Android.Sdk", "8.5.7", "6.0.100")) // New pack version is installed
.Should().BeTrue();
File.Exists(Path.Combine(installRoot, "template-packs", "xamarin.android.templates.2.1.3.nupkg"))
.Should().BeTrue();
// Install records are correct
File.Exists(Path.Combine(installRoot, "metadata", "workloads", sdkFeatureVersion, "InstalledWorkloads", installingWorkload))
.Should().BeTrue();
packRecordDirs = Directory.GetDirectories(Path.Combine(installRoot, "metadata", "workloads", "InstalledPacks", "v1"));
packRecordDirs.Count().Should().Be(7);
foreach (var packRecordDir in packRecordDirs)
{
var packVersionRecordDirs = Directory.GetDirectories(packRecordDir);
packVersionRecordDirs.Count().Should().Be(1); // 1 version of each pack installed
Directory.GetFiles(packVersionRecordDirs.First()).Count().Should().Be(1); // 1 feature band file for this pack id and version
}
}
public void GivenNoUpdatesAreAvailableAndNoRollbackItGivesAppropriateMessage(bool useOfflineCache)
{
// Currently installed - none
// Current SDK - 6.0.300
// Run update
// Should not find 6.0.300 manifest
// Should not rollback
// Manifest updater should give appropriate message
// Arrange
string sdkFeatureBand = "6.0.300";
var testDir = _testAssetsManager.CreateTestDirectory().Path;
var dotnetRoot = Path.Combine(testDir, "dotnet");
var emptyInstalledManifestsDir = Path.Combine(dotnetRoot, "sdk-manifests", "6.0.300");
Directory.CreateDirectory(emptyInstalledManifestsDir);
var adManifestDir = Path.Combine(testDir, ".dotnet", "sdk-advertising", sdkFeatureBand);
Directory.CreateDirectory(adManifestDir);
string testManifestName = "test-manifest";
Directory.CreateDirectory(Path.Combine(emptyInstalledManifestsDir, testManifestName));
File.WriteAllText(Path.Combine(emptyInstalledManifestsDir, testManifestName, _manifestFileName), GetManifestContent(new ManifestVersion("1.0.0")));
var workloadManifestProvider = new MockManifestProvider(Path.Combine(emptyInstalledManifestsDir, testManifestName, _manifestFileName))
{
SdkFeatureBand = new SdkFeatureBand(sdkFeatureBand)
};
var workloadResolver = WorkloadResolver.CreateForTests(workloadManifestProvider, dotnetRoot);
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot, manifestDownload: true);
var installationRepo = new MockInstallationRecordRepository();
var manifestUpdater = new WorkloadManifestUpdater(_reporter, workloadResolver, nugetDownloader, Path.Combine(testDir, ".dotnet"), testDir, installationRepo);
var offlineCacheDir = "";
if (useOfflineCache)
{
offlineCacheDir = Path.Combine(testDir, "offlineCache");
Directory.CreateDirectory(offlineCacheDir); // empty dir because it shouldn't find any manifests to update
manifestUpdater.UpdateAdvertisingManifestsAsync(includePreviews: true, offlineCache: new DirectoryPath(offlineCacheDir)).Wait();
}
else
{
nugetDownloader.PackageIdsToNotFind.Add($"{testManifestName}.Manifest-6.0.300");
manifestUpdater.UpdateAdvertisingManifestsAsync(includePreviews: true).Wait();
// only 6.0.300 manifest was requested
// we can't assert this for the offline cache
nugetDownloader.DownloadCallParams[0].id.ToString().Should().Be($"{testManifestName}.manifest-6.0.300");
nugetDownloader.DownloadCallParams[0].version.ShouldBeEquivalentTo(null);
}
// Assert
// Check nothing was written to advertising manifest folder
Directory.GetFiles(adManifestDir).Should().BeEmpty();
_reporter.Lines.Should().NotContain(l => l.ToLowerInvariant().Contains("fail"));
_reporter.Lines.Should().Contain(String.Format(Workloads.Workload.Install.LocalizableStrings.AdManifestPackageDoesNotExist, testManifestName));
}
public void ItCanFallbackAndAdvertiseCorrectUpdate(bool useOfflineCache)
{
// Currently installed - 6.0.200 workload manifest
// Current SDK - 6.0.300
// Run update
// Should not find 6.0.300 manifest
// Should fall back to 6.0.200 manifest and advertise it
// Arrange
string sdkFeatureBand = "6.0.300";
var testDir = _testAssetsManager.CreateTestDirectory(identifier: useOfflineCache.ToString()).Path;
var dotnetRoot = Path.Combine(testDir, "dotnet");
var installedManifestDir6_0_200 = Path.Combine(dotnetRoot, "sdk-manifests", "6.0.200");
Directory.CreateDirectory(installedManifestDir6_0_200);
var adManifestDir = Path.Combine(testDir, ".dotnet", "sdk-advertising", sdkFeatureBand);
Directory.CreateDirectory(adManifestDir);
// Write installed test-manifest with feature band 6.0.200
string testManifestName = "test-manifest";
Directory.CreateDirectory(Path.Combine(installedManifestDir6_0_200, testManifestName));
File.WriteAllText(Path.Combine(installedManifestDir6_0_200, testManifestName, _manifestFileName), GetManifestContent(new ManifestVersion("1.0.0")));
var workloadManifestProvider = new MockManifestProvider(Path.Combine(installedManifestDir6_0_200, testManifestName, _manifestFileName))
{
SdkFeatureBand = new SdkFeatureBand(sdkFeatureBand)
};
var workloadResolver = WorkloadResolver.CreateForTests(workloadManifestProvider, dotnetRoot);
var nugetDownloader = new MockNuGetPackageDownloader(dotnetRoot, manifestDownload: true);
nugetDownloader.PackageIdsToNotFind.Add($"{testManifestName}.Manifest-6.0.300");
var installationRepo = new MockInstallationRecordRepository();
var manifestUpdater = new WorkloadManifestUpdater(_reporter, workloadResolver, nugetDownloader, Path.Combine(testDir, ".dotnet"), testDir, installationRepo);
var offlineCacheDir = "";
if (useOfflineCache)
{
offlineCacheDir = Path.Combine(testDir, "offlineCache");
Directory.CreateDirectory(offlineCacheDir);
File.Create(Path.Combine(offlineCacheDir, $"{testManifestName}.Manifest-6.0.200.nupkg"));
manifestUpdater.UpdateAdvertisingManifestsAsync(includePreviews: true, offlineCache: new DirectoryPath(offlineCacheDir)).Wait();
}
else
{
nugetDownloader.PackageIdsToNotFind.Add($"{testManifestName}.Manifest-6.0.300");
manifestUpdater.UpdateAdvertisingManifestsAsync(includePreviews: true).Wait();
// Assert
// 6.0.300 manifest was requested and then 6.0.200 manifest was requested
// we can't assert this for the offline cache
nugetDownloader.DownloadCallParams[0].id.ToString().Should().Be($"{testManifestName}.manifest-6.0.300");
nugetDownloader.DownloadCallParams[0].version.ShouldBeEquivalentTo(null);
nugetDownloader.DownloadCallParams[1].id.ToString().Should().Be($"{testManifestName}.manifest-6.0.200");
nugetDownloader.DownloadCallParams[1].version.ShouldBeEquivalentTo(null);
nugetDownloader.DownloadCallParams.Count.Should().Be(2);
}
// 6.0.200 package was written to advertising manifest folder
var advertisedManifestContents = File.ReadAllText(Path.Combine(adManifestDir, testManifestName, "WorkloadManifest.json"));
advertisedManifestContents.Should().NotBeEmpty();
// AdvertisedManifestFeatureBand.txt file is set to 6.0.200
var savedFeatureBand = File.ReadAllText(Path.Combine(adManifestDir, testManifestName, "AdvertisedManifestFeatureBand.txt"));
savedFeatureBand.Should().Be("6.0.200");
// check that update did not fail
_reporter.Lines.Should().NotContain(l => l.ToLowerInvariant().Contains("fail"));
_reporter.Lines.Should().NotContain(String.Format(Workloads.Workload.Install.LocalizableStrings.AdManifestPackageDoesNotExist, testManifestName));
}
