public void Patching_System_SaveAndReload_SnPatch_SuccessfulBefore()
{
var snPatch = new SnPatch
{
ComponentId = "C7",
Version = new Version(2, 0),
Description = "C7 description",
ReleaseDate = new DateTime(2020, 07, 31),
Boundary = ParseBoundary("1.0 <= v < 2.0"),
};
var packages = PackageManager.Storage.LoadInstalledPackagesAsync(CancellationToken.None)
.ConfigureAwait(false).GetAwaiter().GetResult();
Assert.IsFalse(packages.Any());
// SAVE
PackageManager.SavePackage(Manifest.Create(snPatch), ExecutionResult.SuccessfulBefore, null);
// RELOAD
packages = PackageManager.Storage.LoadInstalledPackagesAsync(CancellationToken.None)
.ConfigureAwait(false).GetAwaiter().GetResult();
// ASSERT
var patches = packages.Select(PatchManager.CreatePatch).ToArray();
var patch = (SnPatch)patches[0];
Assert.AreEqual(1, patches.Length);
Assert.IsTrue(patch.Id > 0);
Assert.AreEqual("C7: 1.0 <= v < 2.0 --> 2.0", patch.ToString());
Assert.AreEqual(ExecutionResult.SuccessfulBefore, patch.ExecutionResult);
}
public void Patching_System_CreatePackageFromPatch_NoDep()
{
var patch = new SnPatch
{
ComponentId = "C7",
Version = new Version(2, 0),
Description = "C7 description",
ReleaseDate = new DateTime(2345, 07, 31),
Boundary = ParseBoundary("1.0 <= v < 2.0"),
};
var expectedManifest = @"<?xml version='1.0' encoding='utf-8'?>
<Package type='Patch'>
<Id>C7</Id>
<ReleaseDate>2345-07-31</ReleaseDate>
<Version>2.0</Version>
<Description>C7 description</Description>
<Dependencies>
<Dependency id='C7' minVersion='1.0' maxVersionExclusive='2.0' />
</Dependencies>
</Package>".Replace('\'', '"');
// ACTION
var pkg = PatchManager.CreatePackage(patch);
// ASSERT
Assert.AreEqual("C7", pkg.ComponentId);
Assert.AreEqual(new Version(2, 0), pkg.ComponentVersion);
Assert.AreEqual("C7 description", pkg.Description);
Assert.AreEqual(new DateTime(2345, 07, 31), pkg.ReleaseDate);
Assert.AreEqual(expectedManifest, pkg.Manifest);
}
public void PatchingSystem_SaveAndReloadSnPatch()
{
var snPatch = new SnPatch
{
ComponentId = "C7",
Version = new Version(2, 0),
Description = "C7 description",
ReleaseDate = new DateTime(2020, 07, 31),
Boundary = ParseBoundary("1.0 <= v < 2.0"),
Dependencies = new[]
{
Dep("C1", "1.0 <= v <= 1.0"),
Dep("C2", "1.0 <= v "),
Dep("C3", "1.0 < v "),
Dep("C4", " v <= 2.0"),
Dep("C5", " v < 2.0"),
Dep("C6", "1.0 <= v < 2.0"),
}
};
var packages = PackageManager.Storage.LoadInstalledPackagesAsync(CancellationToken.None)
.ConfigureAwait(false).GetAwaiter().GetResult();
Assert.IsFalse(packages.Any());
// SAVE
PackageManager.SavePackage(Manifest.Create(snPatch), null, true, null);
// RELOAD
packages = PackageManager.Storage.LoadInstalledPackagesAsync(CancellationToken.None)
.ConfigureAwait(false).GetAwaiter().GetResult();
// ASSERT
var patches = packages.Select(PatchManager.CreatePatch).ToArray();
var patch = (SnPatch)patches[0];
Assert.AreEqual(1, patches.Length);
Assert.IsTrue(patch.Id > 0);
Assert.AreEqual(PackageType.Patch, patch.Type);
Assert.AreEqual("C7", patch.ComponentId);
Assert.AreEqual(new Version(2, 0), patch.Version);
Assert.AreEqual("1.0 <= v < 2.0", patch.Boundary.ToString());
Assert.AreEqual("C7 description", patch.Description);
Assert.AreEqual(new DateTime(2020, 07, 31), patch.ReleaseDate);
var dep = string.Join(",", patch.Dependencies).Replace(" ", "");
Assert.AreEqual("C1:1.0<=v<=1.0,C2:1.0<=v,C3:1.0<v,C4:v<=2.0,C5:v<2.0,C6:1.0<=v<2.0", dep);
Assert.IsTrue(patch.ExecutionDate > DateTime.UtcNow.AddMinutes(-1));
Assert.IsTrue(patch.ExecutionDate <= DateTime.UtcNow);
Assert.AreEqual(ExecutionResult.Successful, patch.ExecutionResult);
Assert.IsNull(patch.ExecutionError);
}
protected void ValidatePatches(SnPatch patch1, SnPatch patch2)
{
if (patch1.Version == patch2.Version)
{
throw new InvalidPackageException(
$"Target versions are the same. ComponentId: {patch1.ComponentId}, version: {patch1.Version}",
PackagingExceptionType.TargetVersionsAreTheSame);
}
if (patch1.Boundary.MinVersion == patch1.Boundary.MaxVersion &&
patch2.Boundary.MinVersion == patch2.Boundary.MaxVersion &&
patch1.Boundary.MinVersion == patch2.Boundary.MinVersion)
{
throw new InvalidPackageException(
$"Target versions are the same. ComponentId: {patch1.ComponentId}, version: {patch1.Boundary.MinVersion}",
PackagingExceptionType.SourceVersionsAreTheSame);
}
// Ordering: the patch2 need to be higher
if (patch1.Version > patch2.Version)
{
var temp = patch1;
patch1 = patch2;
patch2 = temp;
}
// (C1: 1.0 <= v < 2.0, v2.0) (C1: 1.9 <= v < 3.0, v3.0) Overlapped
if (patch1.Boundary.MaxVersion > patch2.Boundary.MinVersion)
{
throw new InvalidPackageException(
$"Overlapped intervals. Id: {patch1.ComponentId}, versions: {patch1.Version}, {patch2.Version}",
PackagingExceptionType.OverlappedIntervals);
}
// (C1: v <= 2.0, v2.0) (C1: 2.0 <= v, v3.0) Overlapped
if (patch1.Boundary.MaxVersion == patch2.Boundary.MinVersion &&
!patch1.Boundary.MaxVersionIsExclusive && !patch2.Boundary.MinVersionIsExclusive)
{
throw new InvalidPackageException(
$"Overlapped intervals. Id: {patch1.ComponentId}, versions: {patch1.Version}, {patch2.Version}",
PackagingExceptionType.OverlappedIntervals);
}
}
public void PatchingSystem_InstalledComponents_Descriptions()
{
var installer = new ComponentInstaller
{
ComponentId = "C1",
Version = new Version(1, 0),
Description = "C1 component",
ReleaseDate = new DateTime(2020, 07, 30),
Dependencies = null
};
var patch = new SnPatch
{
ComponentId = "C1",
Version = new Version(2, 0),
Description = "C1 patch",
ReleaseDate = new DateTime(2020, 07, 31),
Boundary = new VersionBoundary
{
MinVersion = new Version(1, 0)
},
Dependencies = new[]
{
Dep("C2", "1.0 <= v <= 1.0"),
}
};
PackageManager.SavePackage(Manifest.Create(installer), null, true, null);
PackageManager.SavePackage(Manifest.Create(patch), null, true, null);
var verInfo = RepositoryVersionInfo.Create(CancellationToken.None);
var components = verInfo.Components.ToArray();
Assert.AreEqual(1, components.Length);
Assert.AreEqual("C1", components[0].ComponentId);
Assert.AreEqual("2.0", components[0].Version.ToString());
Assert.AreEqual("C1 component", components[0].Description);
Assert.AreEqual(1, components[0].Dependencies.Length);
Assert.AreEqual("C2: 1.0 <= v <= 1.0", components[0].Dependencies[0].ToString());
}
/* ================================================================= Steps of Packaging logic algorithms */
protected void ValidatePatch(SnPatch patch)
{
if (patch.ComponentId == null)
{
throw new InvalidPackageException("The Id cannot be null.",
PackagingExceptionType.MissingComponentId);
}
if (patch.ComponentId.Length == 0)
{
throw new InvalidPackageException("The Id cannot be empty.",
PackagingExceptionType.MissingComponentId);
}
if (patch.Version == null)
{
throw new InvalidPackageException("Missing Version.",
PackagingExceptionType.MissingVersion);
}
// If MaxVersion is not defined, it need to be less than the target version
var boundary = patch.Boundary;
var maxVer = boundary.MaxVersion;
if (maxVer.Major == int.MaxValue && maxVer.Minor == int.MaxValue)
{
boundary.MaxVersion = patch.Version;
boundary.MaxVersionIsExclusive = true;
}
if (boundary.MaxVersionIsExclusive && patch.Version < boundary.MaxVersion)
{
throw new InvalidPackageException("Version too small.",
PackagingExceptionType.TargetVersionTooSmall);
}
if (!boundary.MaxVersionIsExclusive && patch.Version <= boundary.MaxVersion)
{
throw new InvalidPackageException("Version too small.",
PackagingExceptionType.TargetVersionTooSmall);
}
if (boundary.MaxVersion < boundary.MinVersion)
{
throw new InvalidPackageException("Maximum version is less than minimum version.",
PackagingExceptionType.MaxLessThanMin);
}
if (boundary.MinVersion == boundary.MaxVersion &&
boundary.MinVersionIsExclusive && boundary.MaxVersionIsExclusive)
{
throw new InvalidPackageException("Maximum and minimum versions are equal but both versions are exclusive.",
PackagingExceptionType.InvalidInterval);
}
if (boundary.MinVersion == boundary.MaxVersion && boundary.MinVersionIsExclusive)
{
throw new InvalidPackageException("Maximum and minimum versions are equal but the minimum version is exclusive.",
PackagingExceptionType.InvalidInterval);
}
if (boundary.MinVersion == boundary.MaxVersion && boundary.MaxVersionIsExclusive)
{
throw new InvalidPackageException("Maximum and minimum versions are equal but the maximum version is exclusive.",
PackagingExceptionType.InvalidInterval);
}
if (patch.Dependencies != null)
{
if (patch.Dependencies.Any(x => x.Id == patch.ComponentId))
{
throw new InvalidPackageException("Patch and dependency id are the same.",
PackagingExceptionType.PatchIdAndDependencyIdAreTheSame);
}
}
}
