public void ShouldFindTheCorrectPackageWhenSimilarPackageExist()
{
using (var acmeWeb = new TemporaryFile(PackageBuilder.BuildSamplePackage(packageId, packageVersion)))
using (var acmeWebTest = new TemporaryFile(PackageBuilder.BuildSamplePackage(packageId + ".Tests", packageVersion)))
{
var destinationFilePath = Path.Combine(downloadPath, PackageName.ToCachedFileName(packageId, VersionFactory.CreateVersion(packageVersion, VersionFormat.Semver), ".nupkg"));
File.Copy(acmeWeb.FilePath, destinationFilePath);
var destinationFilePathTest = Path.Combine(downloadPath, PackageName.ToCachedFileName(packageId + ".Tests", VersionFactory.CreateVersion(packageVersion, VersionFormat.Semver), ".nupkg"));
File.Copy(acmeWebTest.FilePath, destinationFilePathTest);
using (var newAcmeWeb =
new TemporaryFile(PackageBuilder.BuildSamplePackage(packageId, newpackageVersion)))
{
var result = FindPackages(packageId, newpackageVersion, newAcmeWeb.Hash);
result.AssertSuccess();
result.AssertOutput("Package {0} version {1} hash {2} has not been uploaded.", packageId,
newpackageVersion,
newAcmeWeb.Hash);
result.AssertOutput("Finding earlier packages that have been uploaded to this Tentacle");
result.AssertOutput("Found 1 earlier version of {0} on this Tentacle", packageId);
result.AssertOutput(" - {0}: {1}", packageVersion, destinationFilePath);
result.AssertServiceMessage(ServiceMessageNames.FoundPackage.Name, Is.True);
var foundPackage = result.CapturedOutput.FoundPackage;
Assert.AreEqual(VersionFactory.CreateSemanticVersion(packageVersion), foundPackage.Version);
Assert.AreEqual(acmeWeb.Hash, foundPackage.Hash);
Assert.AreEqual(destinationFilePath, foundPackage.RemotePath);
Assert.AreEqual(".nupkg", foundPackage.FileExtension);
Assert.AreEqual(packageId, foundPackage.PackageId);
}
}
}
public static void DownloadPackage(string packageId, IVersion version, Uri feedUri, string targetFilePath)
{
if (!Directory.Exists(feedUri.LocalPath))
{
throw new Exception($"Path does not exist: '{feedUri}'");
}
// Lookup files which start with the name "<Id>." and attempt to match it with all possible version string combinations (e.g. 1.2.0, 1.2.0.0)
// before opening the package. To avoid creating file name strings, we attempt to specifically match everything after the last path separator
// which would be the file name and extension.
var package = (from path in GetPackageLookupPaths(packageId, version, feedUri)
let pkg = new LocalNuGetPackage(path)
where pkg.Metadata.Id.Equals(packageId, StringComparison.OrdinalIgnoreCase) &&
VersionFactory.CreateSemanticVersion(pkg.Metadata.Version.ToString()).Equals(version)
select path
).FirstOrDefault();
if (package == null)
{
throw new Exception($"Could not find package {packageId} v{version} in feed: '{feedUri}'");
}
Log.VerboseFormat("Found package {0} v{1}", packageId, version);
Log.Verbose("Downloading to: " + targetFilePath);
using (var targetFile = File.Open(targetFilePath, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
using (var fileStream = File.OpenRead(package))
{
fileStream.CopyTo(targetFile);
}
}
}
public void ShouldFindTheCorrectMavenPackageWhenSimilarPackageExist()
{
var destinationFilePath = Path.Combine(downloadPath, PackageName.ToCachedFileName(mavenPackageId, VersionFactory.CreateMavenVersion(packageVersion), ".jar"));
File.Copy(mavenPackage, destinationFilePath);
var destination2FilePath = Path.Combine(downloadPath, PackageName.ToCachedFileName(mavenPackageId + ".Test", VersionFactory.CreateMavenVersion(packageVersion), ".jar"));
File.Copy(mavenPackage, destination2FilePath);
var result = FindPackages(mavenPackageId, newpackageVersion, mavenPackageHash, VersionFormat.Maven);
result.AssertSuccess();
result.AssertOutput("Package {0} version {1} hash {2} has not been uploaded.",
mavenPackageId,
newpackageVersion,
mavenPackageHash);
result.AssertOutput("Finding earlier packages that have been uploaded to this Tentacle");
result.AssertOutput("Found 1 earlier version of {0} on this Tentacle", mavenPackageId);
result.AssertOutput(" - {0}: {1}", packageVersion, destinationFilePath);
result.AssertServiceMessage(ServiceMessageNames.FoundPackage.Name, Is.True);
var foundPackage = result.CapturedOutput.FoundPackage;
Assert.AreEqual(VersionFactory.CreateMavenVersion(packageVersion), foundPackage.Version);
Assert.AreEqual(mavenPackageHash, foundPackage.Hash);
Assert.AreEqual(destinationFilePath, foundPackage.RemotePath);
Assert.AreEqual(".jar", foundPackage.FileExtension);
Assert.AreEqual(mavenPackageId, foundPackage.PackageId);
}
public void VersionFactory_GetVersion()
{
var versionNumber = "1.0.0.0";
var versionSplit = versionNumber.Split('.');
var major = Convert.ToInt32(versionSplit[0]);
var minor = Convert.ToInt32(versionSplit[1]);
var increment = Convert.ToInt32(versionSplit[2]);
var refDataVersion = "1.1.8.202003231000";
var refDataVersionSplit = refDataVersion.Split('.');
var refDataMajor = Convert.ToInt32(refDataVersionSplit[0]);
var refDataMinor = Convert.ToInt32(refDataVersionSplit[1]);
var refDataIncrement = Convert.ToInt32(refDataVersionSplit[2]);
var refDataDate = new DateTime(2020, 03, 23, 10, 0, 0);
var factory = new VersionFactory();
var result = factory.GetVersion(versionNumber, refDataVersion);
result.VersionName.Should().Be(versionNumber);
result.Major.Should().Be(major);
result.Minor.Should().Be(minor);
result.Increment.Should().Be(increment);
result.ReferenceDataVersion.VersionName.Should().Be(refDataVersion);
result.ReferenceDataVersion.Major.Should().Be(refDataMajor);
result.ReferenceDataVersion.Minor.Should().Be(refDataMinor);
result.ReferenceDataVersion.Increment.Should().Be(refDataIncrement);
result.ReferenceDataVersion.ReleaseDateTime.Should().Be(refDataDate);
}
public void ShouldFindMavenPackageAlreadyUploaded()
{
var destinationFilePath = Path.Combine(downloadPath, PackageName.ToCachedFileName(mavenPackageId, VersionFactory.CreateMavenVersion(packageVersion), ".jar"));
File.Copy(mavenPackage, destinationFilePath);
var result = FindPackages(mavenPackageId, packageVersion, mavenPackageHash, VersionFormat.Maven);
result.AssertSuccess();
result.AssertServiceMessage(
ServiceMessageNames.CalamariFoundPackage.Name,
Is.True,
message: "Expected service message '{0}' to be True",
args: ServiceMessageNames.CalamariFoundPackage.Name);
result.AssertOutput(
"Package {0} {1} hash {2} has already been uploaded",
mavenPackageId,
packageVersion,
mavenPackageHash);
var foundPackage = result.CapturedOutput.FoundPackage;
Assert.AreEqual(VersionFactory.CreateMavenVersion(packageVersion), foundPackage.Version);
Assert.AreEqual(mavenPackageHash, foundPackage.Hash);
Assert.AreEqual(destinationFilePath, foundPackage.RemotePath);
Assert.AreEqual(".jar", foundPackage.FileExtension);
Assert.AreEqual(mavenPackageId, foundPackage.PackageId);
}
PackageIdentity CreatePackageIdentity(string packageId, string packageVersion)
{
var version = VersionFactory.CreateSemanticVersion(packageVersion);
var path = new PackagePath($"C:\\{packageId}.{packageVersion}.zip");
return(new PackageIdentity(new PackageId(packageId), version, path));
}
/// <summary>
/// Old school parser for those file not yet sourced directly from the cache.
/// Expects pattern {PackageId}.{Version}.{Extension}
/// Issue with extension parser if pre-release tag is present where two part extendsions are incorrectly split.
/// e.g. MyApp.1.0.0-beta.tar.gz => .tar forms part of pre-release tag and not extension
/// </summary>
/// <param name="fileName"></param>
/// <param name="packageId"></param>
/// <param name="version"></param>
/// <param name="extension"></param>
/// <returns></returns>
static bool TryParseUnsafeFileName(string fileName, out string packageId, out IVersion version, out string extension)
{
packageId = null;
version = null;
extension = null;
const string packageIdPattern = @"(?<packageId>(\w+([_.-]\w+)*?))";
const string semanticVersionPattern = @"(?<semanticVersion>(\d+(\.\d+){0,3}" // Major Minor Patch
+ @"(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?)" // Pre-release identifiers
+ @"(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?)"; // Build Metadata
const string extensionPattern = @"(?<extension>(\.([a-zA-Z0-9])+)+)"; //Extension (wont catch two part extensions like .tar.gz if there is a pre-release tag)
var match = Regex.Match(fileName, $@"^{packageIdPattern}\.{semanticVersionPattern}{extensionPattern}$", RegexOptions.IgnoreCase);
var packageIdMatch = match.Groups["packageId"];
var versionMatch = match.Groups["semanticVersion"];
var extensionMatch = match.Groups["extension"];
if (!packageIdMatch.Success || !versionMatch.Success || !extensionMatch.Success)
{
return(false);
}
if (!VersionFactory.TryCreateSemanticVersion(versionMatch.Value, out version, true))
{
return(false);
}
packageId = packageIdMatch.Value;
extension = extensionMatch.Value;
return(true);
}
public async Task CanDownloadPackage()
{
string filename = "Acme.Core.1.0.0.0-bugfix.zip";
string packageId = $"{bucketName}/Acme.Core";
var version = VersionFactory.CreateVersion("1.0.0.0-bugfix", VersionFormat.Semver);
File.Copy(GetFixtureResource("Samples", filename), Path.Combine(rootDir, filename));
await Validate(async client => await client.PutObjectAsync(new PutObjectRequest
{
BucketName = bucketName,
Key = filename,
InputStream = File.OpenRead(Path.Combine(rootDir, filename))
},
CancellationToken.None));
var downloader = GetDownloader();
var package = downloader.DownloadPackage(packageId,
version,
"s3-feed",
new Uri("http://please-ignore.com"),
ExternalVariables.Get(ExternalVariable.AwsAcessKey),
ExternalVariables.Get(ExternalVariable.AwsSecretKey),
true,
3,
TimeSpan.FromSeconds(3));
package.PackageId.Should().Be(packageId);
package.Size.Should().Be(new FileInfo(Path.Combine(rootDir, filename)).Length);
}
public int AttemptsTheRightNumberOfTimesOnError(int maxDownloadAttempts)
{
var packageId = "FakePackageId";
var version = VersionFactory.CreateSemanticVersion(1, 2, 3);
var feedUri = new Uri("http://www.myget.org");
var feedCredentials = new CredentialCache();
var targetFilePath = "FakeTargetFilePath";
var filesystem = Substitute.For <ICalamariFileSystem>();
var variables = new CalamariVariables();
var calledCount = 0;
Assert.Throws <Exception>(() =>
{
var downloader = new InternalNuGetPackageDownloader(filesystem, variables);
downloader.DownloadPackage(packageId, version, feedUri, feedCredentials, targetFilePath, maxDownloadAttempts: maxDownloadAttempts, downloadAttemptBackoff: TimeSpan.Zero,
action: (arg1, arg2, arg3, arg4, arg5) =>
{
calledCount++;
throw new Exception("Expected exception from test: simulate download failing");
});
});
return(calledCount);
}
public void ShouldFindPackageAlreadyUploaded()
{
using (var acmeWeb = new TemporaryFile(PackageBuilder.BuildSamplePackage(packageId, packageVersion)))
{
var destinationFilePath = Path.Combine(downloadPath, PackageName.ToCachedFileName(packageId, VersionFactory.CreateSemanticVersion(packageVersion), ".nupkg"));
File.Copy(acmeWeb.FilePath, destinationFilePath);
var result = FindPackages(packageId, packageVersion, acmeWeb.Hash);
result.AssertSuccess();
result.AssertServiceMessage(
ServiceMessageNames.CalamariFoundPackage.Name,
Is.True,
message: "Expected service message '{0}' to be True",
args: ServiceMessageNames.CalamariFoundPackage.Name);
result.AssertOutput("Package {0} {1} hash {2} has already been uploaded", packageId, packageVersion,
acmeWeb.Hash);
result.AssertServiceMessage(ServiceMessageNames.FoundPackage.Name, Is.True);
var foundPackage = result.CapturedOutput.FoundPackage;
Assert.AreEqual(VersionFactory.CreateSemanticVersion(packageVersion), foundPackage.Version);
Assert.AreEqual(acmeWeb.Hash, foundPackage.Hash);
Assert.AreEqual(destinationFilePath, foundPackage.RemotePath);
Assert.AreEqual(".nupkg", foundPackage.FileExtension);
Assert.AreEqual(packageId, foundPackage.PackageId);
}
}
// ReSharper disable UnusedParameter.Local
void CheckArguments(
string packageId,
string packageVersion,
string feedId,
string feedUri,
string feedUsername,
string feedPassword,
string maxDownloadAttempts,
string attemptBackoffSeconds,
out IVersion version,
out Uri uri,
out int parsedMaxDownloadAttempts,
out TimeSpan parsedAttemptBackoff)
{
Guard.NotNullOrWhiteSpace(packageId, "No package ID was specified. Please pass --packageId YourPackage");
Guard.NotNullOrWhiteSpace(packageVersion, "No package version was specified. Please pass --packageVersion 1.0.0.0");
Guard.NotNullOrWhiteSpace(feedId, "No feed ID was specified. Please pass --feedId feed-id");
Guard.NotNullOrWhiteSpace(feedUri, "No feed URI was specified. Please pass --feedUri https://url/to/nuget/feed");
version = VersionFactory.TryCreateVersion(packageVersion, versionFormat);
if (version == null)
{
throw new CommandException($"Package version '{packageVersion}' specified is not a valid {versionFormat.ToString()} version string");
}
if (!Uri.TryCreate(feedUri, UriKind.Absolute, out uri))
{
throw new CommandException($"URI specified '{feedUri}' is not a valid URI");
}
if (!String.IsNullOrWhiteSpace(feedUsername) && String.IsNullOrWhiteSpace(feedPassword))
{
throw new CommandException("A username was specified but no password was provided. Please pass --feedPassword \"FeedPassword\"");
}
if (!int.TryParse(maxDownloadAttempts, out parsedMaxDownloadAttempts))
{
throw new CommandException($"The requested number of download attempts '{maxDownloadAttempts}' is not a valid integer number");
}
if (parsedMaxDownloadAttempts <= 0)
{
throw new CommandException("The requested number of download attempts should be more than zero");
}
int parsedAttemptBackoffSeconds;
if (!int.TryParse(attemptBackoffSeconds, out parsedAttemptBackoffSeconds))
{
throw new CommandException($"Retry requested download attempt retry backoff '{attemptBackoffSeconds}' is not a valid integer number of seconds");
}
if (parsedAttemptBackoffSeconds < 0)
{
throw new CommandException("The requested download attempt retry backoff should be a positive integer number of seconds");
}
parsedAttemptBackoff = TimeSpan.FromSeconds(parsedAttemptBackoffSeconds);
}
public void CreateVersion_can_create_an_empty_version_from_a_null_string(VersionFactory sut)
{
// Act
var result = sut.CreateVersion(null);
// Assert
Assert.That(result, Is.EqualTo(EmptyBrowserVersion.Singleton));
}
public void DownloadMavenPackage()
{
var downloader = new MavenPackageDownloader(CalamariPhysicalFileSystem.GetPhysicalFileSystem(), new FreeSpaceChecker(CalamariPhysicalFileSystem.GetPhysicalFileSystem(), new CalamariVariables()));
var pkg = downloader.DownloadPackage("com.google.guava:guava", VersionFactory.CreateMavenVersion("22.0"), "feed-maven",
new Uri("https://repo.maven.apache.org/maven2/"), new NetworkCredential("", ""), true, 3, TimeSpan.FromSeconds(3));
Assert.AreEqual("com.google.guava:guava", pkg.PackageId);
}
public void FromFile_MavenVersion()
{
var details = PackageName.FromFile("blah/[email protected]%[email protected]");
Assert.AreEqual("pkg", details.PackageId);
Assert.AreEqual(VersionFactory.CreateMavenVersion("1.0.0+CAT"), details.Version);
Assert.AreEqual(".jar", details.Extension);
}
public void ToCachedFileName_MavenEncodedChars()
{
var filename = PackageName.ToCachedFileName("My/Package", VersionFactory.CreateMavenVersion("12:8"), ".jar");
var scrubbedFilename = Regex.Replace(filename, "[0-9A-F]{32}", "<CACHE-GUID>");
Assert.AreEqual("My%2FPackage@M12%3A8@<CACHE-GUID>.jar", scrubbedFilename);
}
public void DownloadMavenPackage()
{
var downloader = GetDownloader();
var pkg = downloader.DownloadPackage("com.google.guava:guava", VersionFactory.CreateMavenVersion("22.0"), "feed-maven",
new Uri("https://repo.maven.apache.org/maven2/"), "", "", true, 3, TimeSpan.FromSeconds(3));
Assert.AreEqual("com.google.guava:guava", pkg.PackageId);
}
public void CreateAssemblyVersion_ForInvalidAssemblyVersion_ReturnNone()
{
var versionString = "invalid";
var version = VersionFactory.CreateAssemblyVersion(versionString);
version.IsNone.ShouldBeTrue();
}
public void FromFile_OldSchoolFileType()
{
var details = PackageName.FromFile("blah/MyPackage.1.0.8-cat+jat.jar");
Assert.AreEqual("MyPackage", details.PackageId);
Assert.AreEqual(VersionFactory.CreateSemanticVersion("1.0.8-cat+jat"), details.Version);
Assert.AreEqual(".jar", details.Extension);
}
public void ToCachedFileName_Semver()
{
var filename = PackageName.ToCachedFileName("My/Package", VersionFactory.CreateSemanticVersion("12.32.1-meta+data"), ".zip");
var scrubbedFilename = Regex.Replace(filename, "[0-9A-F]{32}", "<CACHE-GUID>");
Assert.AreEqual("My%[email protected]+data@<CACHE-GUID>.zip", scrubbedFilename);
}
static bool FileNameMatchesPattern(string packageId, IVersion version, string path)
{
var name = Path.GetFileNameWithoutExtension(path);
// When matching by pattern, we will always have a version token. Packages without versions would be matched early on by the version-less path resolver
// when doing an exact match.
return(name.Length > packageId.Length &&
(VersionFactory.TryCreateSemanticVersion(name.Substring(packageId.Length + 1))?.Equals(version) ?? false));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jsonObject = JObject.Load(reader);
var versionString = jsonObject["Version"].Value <string>();
var versionFormat = (VersionFormat)Enum.Parse(typeof(VersionFormat), jsonObject["Format"].Value <string>());
var version = VersionFactory.CreateVersion(versionString, versionFormat);
return(version);
}
public void CreateVersion_can_create_an_unrecognised_version(VersionFactory sut)
{
// Arrange
var versionString = "version 55.20";
// Act
var result = sut.CreateVersion(versionString);
// Assert
Assert.That(result, Is.EqualTo(new UnrecognisedVersion(versionString)));
}
public void CreateVersion_ForValidVersionWithLabel_ReturnVersionWithLabel()
{
var versionString = "1.2.3-pre12";
var version = VersionFactory.CreateVersion(versionString).ValueUnsafe();
version.Major.ShouldBe(1);
version.Minor.ShouldBe(2);
version.Patch.ShouldBe(3);
version.Label.ShouldBe("-pre12");
}
public void CreateAssemblyVersion_ForValidVersionWithoutRevision_ReturnAssemblyVersionWithZeroRevision()
{
var versionString = "1.2.3";
var version = VersionFactory.CreateAssemblyVersion(versionString).ValueUnsafe();
version.Major.ShouldBe(1);
version.Minor.ShouldBe(2);
version.BuildNumber.ShouldBe(3);
version.Revision.ShouldBe(0);
}
public void CreateVersion_can_create_a_semantic_version(VersionFactory sut)
{
// Arrange
var versionString = "v1.2.3";
// Act
var result = sut.CreateVersion(versionString);
// Assert
Assert.That(result, Is.EqualTo(SemanticVersion.Parse(versionString)));
}
static IVersion DecodeVersion(string input)
{
switch (input[0])
{
case 'S':
return(VersionFactory.CreateSemanticVersion(Decode(input.Substring(1)), true));
case 'M':
return(VersionFactory.CreateMavenVersion(Decode(input.Substring(1))));
}
throw new Exception($"Unrecognised Version format `{input}`");
}
public void CreateVersion_can_create_versions_for_all_supported_browsers(string browserName, string browserVersion)
{
// Arrange
var sut = new VersionFactory();
// Act
var result = sut.CreateVersion(browserVersion, browserName);
// Assert
Assert.That(result,
Is.Not.InstanceOf <UnrecognisedVersion>(),
$"{nameof(VersionFactory)} created an unrecognised version for {browserName}: '{browserVersion}'.");
}
void RunNugetV3TimeoutTest(string timeoutInVariables, TimeSpan serverResponseTime, TimeSpan estimatedTimeout)
{
using (var server = new TestHttpServer(9001, serverResponseTime))
{
var packageId = "FakePackageId";
var version = VersionFactory.CreateSemanticVersion(1, 2, 3);
var feedCredentials = new CredentialCache();
var targetFilePath = "FakeTargetFilePath";
var filesystem = Substitute.For <ICalamariFileSystem>();
var v3NugetUri = new Uri(server.BaseUrl + "/index.json");
var variables = new CalamariVariables();
if (timeoutInVariables != null)
{
variables[KnownVariables.NugetHttpTimeout] = timeoutInVariables;
}
var downloader = new InternalNuGetPackageDownloader(filesystem, variables);
var stopwatch = new Stopwatch();
Action invocation = () =>
{
stopwatch.Start();
try
{
downloader.DownloadPackage(
packageId,
version,
v3NugetUri,
feedCredentials,
targetFilePath,
maxDownloadAttempts: 1,
downloadAttemptBackoff: TimeSpan.Zero
);
}
finally
{
stopwatch.Stop();
}
};
invocation.Should()
.ThrowExactly <Exception>();
stopwatch.Elapsed
.Should()
.BeCloseTo(estimatedTimeout, TimeSpan.FromSeconds(0.5));
}
}
static IVersion?TryParseVersion(string input)
{
if (input == null)
{
return(null);
}
if (input[0].Equals('v') || input[0].Equals('V'))
{
input = input.Substring(1);
}
return(VersionFactory.TryCreateVersion(input, VersionFormat.Semver));
}
static bool TryParseVersion(string input, out IVersion version)
{
if (input == null)
{
version = null;
return(false);
}
if (input[0].Equals('v') || input[0].Equals('V'))
{
input = input.Substring(1);
}
return(VersionFactory.TryCreateVersion(input, out version, VersionFormat.Semver));
}
