public async Task<Hash> PutAsync(long id, SemanticVersion version, IPackage package) { #region Preconditions if (package == null) throw new ArgumentNullException(nameof(package)); #endregion var key = id.ToString() + "/" + version.ToString(); using (var ms = new MemoryStream()) { await package.ZipToStreamAsync(ms).ConfigureAwait(false); var hash = Hash.ComputeSHA256(ms, leaveOpen: true); var blob = new Blob(ms) { ContentType = "application/zip" }; await bucket.PutAsync(key, blob).ConfigureAwait(false); return hash; } }
private void AttemptToGetPackageFromCache(string packageId, SemanticVersion version, string feedId, string cacheDirectory, out IPackage downloaded, out string downloadedTo) { downloaded = null; downloadedTo = null; Log.VerboseFormat("Checking package cache for package {0} {1}", packageId, version.ToString()); var name = GetNameOfPackage(packageId, version.ToString()); fileSystem.EnsureDirectoryExists(cacheDirectory); var files = fileSystem.EnumerateFilesRecursively(cacheDirectory, name + "*.nupkg"); foreach (var file in files) { var package = ReadPackageFile(file); if (package == null) continue; if (!string.Equals(package.Id, packageId, StringComparison.OrdinalIgnoreCase) || !string.Equals(package.Version.ToString(), version.ToString(), StringComparison.OrdinalIgnoreCase)) continue; downloaded = package; downloadedTo = file; } }
public void GeneralCtorTest() { SemanticVersion v = new SemanticVersion(0, 2, 1); Assert.Equal("0.2.1", v.ToString()); Assert.Equal("0.2.1", v.ToString("C")); Assert.Equal("0.2.1", v.ToString("G")); }
public void FullCtorTest() { PreRelease pre = new PreRelease(PreReleaseStage.BETA, 5); SemanticVersion v = new SemanticVersion(0, 2, 1, pre, 1000); Assert.Equal("0.2.1-BETA.5+1000", v.ToString()); Assert.Equal("0.2.1-BETA.5", v.ToString("C")); Assert.Equal("0.2.1", v.ToString("G")); }
public void ComparableCtorTest() { PreRelease pre = new PreRelease(PreReleaseStage.ALPHA); SemanticVersion v = new SemanticVersion(0, 2, 1, pre); Assert.Equal("0.2.1-ALPHA", v.ToString("")); Assert.Equal("0.2.1-ALPHA", v.ToString("C")); Assert.Equal("0.2.1", v.ToString("G")); }
public void DownloadPackage(HttpContextBase context) { RouteData routeData = GetRouteData(context); // Get the package file name from the route string packageId = routeData.GetRequiredString("packageId"); var version = new SemanticVersion(routeData.GetRequiredString("version")); string filename = packageId + "." + version.ToString() + ".nupkg"; IPackage requestedPackage = _azureRepository.FindPackage(packageId, version); if (requestedPackage != null) { CloudBlockBlob blob = _azureRepository.GetBlob(requestedPackage); MemoryStream ms = new MemoryStream(); blob.DownloadToStream(ms); context.Response.Clear(); context.Response.AddHeader("content-disposition", String.Format("attachment; filename={0}", filename)); context.Response.ContentType = "application/octet-stream"; context.Response.BinaryWrite(ms.ToArray()); context.Response.End(); } else { // Package not found WritePackageNotFound(context, packageId, version); } }
public void WillReturnConflictIfAPackageWithTheIdAndSemanticVersionAlreadyExists() { var version = new SemanticVersion("1.0.42"); var nuGetPackage = new Mock<IPackage>(); nuGetPackage.Setup(x => x.Id).Returns("theId"); nuGetPackage.Setup(x => x.Version).Returns(version); var user = new User(); var packageRegistration = new PackageRegistration { Packages = new List<Package> { new Package { Version = version.ToString() } }, Owners = new List<User> { user } }; var packageSvc = new Mock<IPackageService>(); packageSvc.Setup(x => x.FindPackageRegistrationById(It.IsAny<string>())).Returns(packageRegistration); var userSvc = new Mock<IUserService>(); userSvc.Setup(x => x.FindByApiKey(It.IsAny<Guid>())).Returns(user); var controller = CreateController(userSvc: userSvc, packageSvc: packageSvc, packageFromInputStream: nuGetPackage.Object); // Act var result = controller.CreatePackagePut(Guid.NewGuid().ToString()); // Assert Assert.IsType<HttpStatusCodeWithBodyResult>(result); var statusCodeResult = (HttpStatusCodeWithBodyResult)result; Assert.Equal(409, statusCodeResult.StatusCode); Assert.Equal(String.Format(Strings.PackageExistsAndCannotBeModified, "theId", "1.0.42"), statusCodeResult.StatusDescription); }
private IEnumerable<NuDeployPackageInfo> GetAllPackages() { IEnumerable<PackageInfo> installedPackages = this.packageConfigurationAccessor.GetInstalledPackages(); foreach (PackageInfo package in installedPackages) { string packagePrefix = string.Format("{0}.", package.Id); var packageDirectories = this.filesystemAccessor.GetSubDirectories(this.applicationInformation.StartupFolder).Where( dir => dir.Name.StartsWith(packagePrefix, StringComparison.OrdinalIgnoreCase)); foreach (DirectoryInfo packageDirectory in packageDirectories) { string packageVersionString = packageDirectory.Name.Replace(string.Format("{0}.", package.Id), string.Empty); var packageVersion = new SemanticVersion(packageVersionString); var isInstalled = packageVersion.ToString().Equals(package.Version); yield return new NuDeployPackageInfo { Id = package.Id, Version = packageVersion, Folder = packageDirectory.FullName, IsInstalled = isInstalled }; } } }
public async Task<Package> GetAsync(long id, SemanticVersion version, Hash hash) { var key = prefix + id.ToString() + "/" + version.ToString(); var ms = new MemoryStream(); using (var blob = await bucket.GetAsync(key)) { using (var data = blob.Open()) { await data.CopyToAsync(ms).ConfigureAwait(false); } } ms.Position = 0; var secret = SecretKey.Derive(password, hash.Data); var protector = new AesProtector(secret); // dispose? var stream = protector.DecryptStream(ms); #region Verify the hash var computedHash = Hash.ComputeSHA256(stream, true); if (computedHash != hash) { throw new IntegrityException(hash.Data, computedHash.Data); } #endregion return ZipPackage.FromStream(stream, false); }
public async Task<Hash> PutAsync(long id, SemanticVersion version, IPackage package) { var key = prefix + id.ToString() + "/" + version.ToString(); using (var ms = new MemoryStream()) { await package.ZipToStreamAsync(ms).ConfigureAwait(false); ms.Position = 0; var hash = Hash.ComputeSHA256(ms, leaveOpen: true); var secret = SecretKey.Derive(password, hash.Data); using (var protector = new AesProtector(secret)) { using (var packageStream = protector.EncryptStream(ms)) { var blob = new Blob(packageStream) { ContentType = "application/zip" }; await bucket.PutAsync(key, blob).ConfigureAwait(false); } } return hash; } }
public static void MarkFixed(this Stack stack, SemanticVersion version = null) { stack.Status = StackStatus.Fixed; stack.DateFixed = SystemClock.UtcNow; stack.FixedInVersion = version?.ToString(); stack.SnoozeUntilUtc = null; }
public void BumpPatchVersion() { var semver = new SemanticVersion(Version); var newVer = new SemanticVersion(semver.Major, semver.Minor, semver.Patch+1,build:null, preRelease: null); Version = FileVersion = newVer.ToString(); }
static string GetVersion(SemanticVersion version) { if (version != null) { return version.ToString(); } return null; }
public virtual string GetPackageDirectory(string packageId, SemanticVersion version) { string directory = packageId; if (_useSideBySidePaths) { directory = Path.Combine(directory, version.ToString()); } return directory; }
void INuGet.SavePackageVersion(string path, Version version) { var manifest = Manifest.ReadFrom(null, false); var semanticVersion = new SemanticVersion(version); manifest.Metadata.Version = semanticVersion.ToString(); manifest.Save(null); }
/// <summary> /// Checks whether an IPackage exists within a PackageManager. By default, will use the UseSideBySide settings of the DefaultPackagePathProvider the PackageManager is instantiated with. /// If passed in TRUE for exhaustive, will check both with and without UseSideBySide set. /// </summary> /// <param name="packageManager"></param> /// <param name="packageId"> </param> /// <param name="version"> </param> /// <param name="exhaustive"></param> /// <returns></returns> public static bool IsPackageInstalled(this PackageManager packageManager, string packageId, SemanticVersion version, bool exhaustive = false) { IPackage package = new DataServicePackage { Version = version.ToString(), Id = packageId }; return(packageManager.IsPackageInstalled(package, exhaustive)); }
public bool IsNewerThan(string versionStrA, string versionStrB) { // arrange ISemanticVersion versionA = new SemanticVersion(versionStrA); ISemanticVersion versionB = new SemanticVersion(versionStrB); // assert Assert.AreEqual(versionA.IsNewerThan(versionB), versionA.IsNewerThan(versionB.ToString()), "The two signatures returned different results."); return(versionA.IsNewerThan(versionB)); }
public void StringConstructorParsesValuesCorrectly(string version, Version versionValue, string specialValue) { // Act SemanticVersion semanticVersion = new SemanticVersion(version); // Assert Assert.Equal(versionValue, semanticVersion.Version); Assert.Equal(specialValue, semanticVersion.SpecialVersion); Assert.Equal(version, semanticVersion.ToString()); }
/// <summary> /// Checks whether an IPackage exists within a PackageManager. By default, will use the UseSideBySide settings of the DefaultPackagePathProvider the PackageManager is instantiated with. /// If passed in TRUE for exhaustive, will check both with and without UseSideBySide set. /// </summary> /// <param name="packageManager"></param> /// <param name="packageId"> </param> /// <param name="version"> </param> /// <param name="exhaustive"></param> /// <returns></returns> public static bool IsPackageInstalled(this PackageManager packageManager, string packageId, SemanticVersion version, bool exhaustive = false) { IPackage package = new DataServicePackage { Version = version.ToString(), Id = packageId }; return packageManager.IsPackageInstalled(package, exhaustive); }
public void Serialisable(string versionStr) { // act string json = JsonConvert.SerializeObject(new SemanticVersion(versionStr)); SemanticVersion after = JsonConvert.DeserializeObject <SemanticVersion>(json); // assert Assert.IsNotNull(after, "The semantic version after deserialisation is unexpectedly null."); Assert.AreEqual(versionStr, after.ToString(), "The semantic version after deserialisation doesn't match the input version."); }
public void WriteVersion(SemanticVersion nextVersion) { var doc = ReadProject(ProjectFile); var versionElement = SelectVersionNode(doc); versionElement.InnerText = nextVersion.ToString(); doc.Save(ProjectFile); }
public static NuGetVersion SafeToNuGetVer(SemanticVersion semanticVersion) { if (semanticVersion == null) { return(null); } // Parse using the original version string to support non-normalized scenarios. return(NuGetVersion.Parse(semanticVersion.ToString())); }
public void AddPackageReference(string packageId, SemanticVersion version, bool ignoreDependencies, bool allowPrereleaseVersions) { string key = packageId + version.ToString(); if (addPackageReferenceCallbacks.ContainsKey(key)) { Action callback = addPackageReferenceCallbacks [key]; callback(); } }
public void CallToString() { // Setup var version1 = new SemanticVersion(1, 2, 3, "rc3"); // Execute var result = version1.ToString(); // Assert Assert.AreEqual("1.2.3-rc3", result); }
public SemanticVersionToken( int position, int consumedLength, SemanticVersion semanticVersion) : base( position, consumedLength, semanticVersion.ToString()) { this.SemanticVersion = semanticVersion; }
public static Version ToVersion(this SemanticVersion semanticVersion) { string versionString = semanticVersion.ToString(); if (!String.IsNullOrEmpty(semanticVersion.SpecialVersion)) { // Remove special version from string (-1 for the "-" added before the version) versionString = versionString.Substring(0, versionString.Length - semanticVersion.SpecialVersion.Length - 1); } return(new Version(versionString)); }
IEnumerable <IGrouping <string, string> > OverrideWithInputs(IEnumerable <IGrouping <string, string> > parameters) { var overrides = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); if (Configuration != null) { overrides.Add("Configuration", Configuration); } if (Incremental) { overrides.Add("Incremental", "True"); } overrides.Add("OpenWrap-CurrentBuildVersion", _generatedVersion.ToString()); if (_sharedAssemblyInfoFile != null) { overrides.Add("OpenWrap-SharedAssemblyInfoFile", _sharedAssemblyInfoFile.Path.FullPath); } return(overrides.GroupBy(x => x.Key, x => x.Value).Concat(_wildcards.Concat(parameters).Where(param => !overrides.ContainsKey(param.Key)))); }
/// <summary> /// Returns the latest stable version string for the given package. /// </summary> /// <param name="packageId"></param> /// <returns></returns> public static string GetLatestStableVersion(string packageId) { IPackageRepository repo = PackageRepositoryFactory.Default.CreateRepository(sourceUrl) as IPackageRepository; List <IPackage> packages = repo.FindPackagesById(packageId).ToList(); packages = packages.Where(item => item.IsListed()).ToList(); packages = packages.Where(item => item.IsReleaseVersion()).ToList(); SemanticVersion version = packages.Max(item => item.Version); return(version.ToString()); }
public bool IsBetween(string versionStr, string lowerStr, string upperStr) { // arrange ISemanticVersion lower = new SemanticVersion(lowerStr); ISemanticVersion upper = new SemanticVersion(upperStr); ISemanticVersion version = new SemanticVersion(versionStr); // assert Assert.AreEqual(version.IsBetween(lower, upper), version.IsBetween(lower.ToString(), upper.ToString()), "The two signatures returned different results."); return(version.IsBetween(lower, upper)); }
public void ParseSemanticVersionStrict(string versionString) { // Act SemanticVersion semVer = null; SemanticVersion.TryParseStrict(versionString, out semVer); // Assert Assert.Equal <string>(versionString, semVer.ToFullString()); Assert.Equal <string>(semVer.ToNormalizedString(), semVer.ToString()); }
private PackageFromBuiltInFeedResource TryFindPackage(string packageId, SemanticVersion version) { try { return(repository.BuiltInPackageRepository.GetPackage(packageId, version.ToString())); } catch (OctopusResourceNotFoundException) { return(null); } }
public string Constructor_FromAssemblyVersion(int major, int minor, int patch) { // act ISemanticVersion version = new SemanticVersion(new Version(major, minor, patch)); // assert Assert.AreEqual(major, version.MajorVersion, "The major version doesn't match the given value."); Assert.AreEqual(minor, version.MinorVersion, "The minor version doesn't match the given value."); Assert.AreEqual(patch, version.PatchVersion, "The patch version doesn't match the given value."); return(version.ToString()); }
public static SemanticVersion GetLimitingMajor(this SemanticVersion semanticVersion) { // do not modify the test below, due to SemanticVersion.NormalizeVersionValue() in SemanticVersion ctor if (semanticVersion.ToString().Count(c => c == '.') > 2) { return(new SemanticVersion(semanticVersion.Version.Major + 1, 0, 0, 0)); } else { return(new SemanticVersion(semanticVersion.Version.Major + 1, 0, 0, null)); } }
public override string ToString() { return("ControlResponsePoller{" + "controlSessionId=" + controlSessionId + ", correlationId=" + correlationId + ", relevantId=" + relevantId + ", code=" + code + ", version=" + SemanticVersion.ToString(version) + ", errorMessage='" + errorMessage + '\'' + ", isPollComplete=" + isPollComplete + '}'); }
public void ConstructSemanticVersionWithParts() { // Execute var version = new SemanticVersion(1, 2, 3, "alpha"); // Assert Assert.AreEqual(1, version.Major); Assert.AreEqual(2, version.Minor); Assert.AreEqual(3, version.Patch); Assert.AreEqual("alpha", version.Release); Assert.AreEqual("1.2.3-alpha", version.ToString()); }
public void ConstructSemanticVersionWithNoRelease() { // Execute var version = new SemanticVersion("2.1.0"); // Assert Assert.AreEqual(2, version.Major); Assert.AreEqual(1, version.Minor); Assert.AreEqual(0, version.Patch); Assert.AreEqual("", version.Release); Assert.AreEqual("2.1.0", version.ToString()); }
/// <summary> /// Returns the normalized version identity. This does not contain metadata since /// it is not part of the actual package identity. /// </summary> public static string ToIdentityString(this SemanticVersion version) { var formatter = new VersionFormatter(); var format = "V"; if (version.IsPrerelease) { format += "-R"; } return(version.ToString(format, formatter)); }
public void ConstructSemanticversionWithPartsAndNullRelease() { // Execute var version = new SemanticVersion(1, 2, 3, a_release: null); // Assert Assert.AreEqual(1, version.Major); Assert.AreEqual(2, version.Minor); Assert.AreEqual(3, version.Patch); Assert.AreEqual("", version.Release); Assert.AreEqual("1.2.3", version.ToString()); }
static PackageContent GenerateVersionFile(SemanticVersion generatedVersion) { var versionStream = generatedVersion.ToString().ToUTF8Stream(); return(new PackageContent { FileName = "version", RelativePath = ".", Stream = versionStream.ResetOnRead(), Size = versionStream.Length }); }
public string Constructor_FromParts(int major, int minor, int patch, string tag) { // act ISemanticVersion version = new SemanticVersion(major, minor, patch, tag); // assert Assert.AreEqual(major, version.MajorVersion, "The major version doesn't match the given value."); Assert.AreEqual(minor, version.MinorVersion, "The minor version doesn't match the given value."); Assert.AreEqual(patch, version.PatchVersion, "The patch version doesn't match the given value."); Assert.AreEqual(string.IsNullOrWhiteSpace(tag) ? null : tag.Trim(), version.Build, "The tag doesn't match the given value."); return(version.ToString()); }
/// <summary> /// Find the package files (.nupkg or .nuspec). /// </summary> /// <param name="packageId"></param> /// <param name="version"></param> /// <returns></returns> private IEnumerable <string> GetPackageLookupPaths(string packageId, SemanticVersion version) { // Files created by the path resolver. This would take into account the non-side-by-side scenario // and we do not need to match this for id and version. //var packageFileName = packageId + version + Constant.PackageExtension; var packageFileName = FileUtility.MakePackageFileName(false, packageId, version.ToString(), NuGetConstant.PackageExtension); // var packageFileName = PathResolver.GetPackageFileName(packageId, version); var manifestFileName = Path.ChangeExtension(packageFileName, NuGetConstant.ManifestExtension); var filesMatchingFullName = GetPackageFiles(packageFileName).Concat(GetPackageFiles(manifestFileName)); if (version.Version.Revision < 1) { // If the build or revision number is not set, we need to look for combinations of the format // * Foo.1.2.nupkg // * Foo.1.2.3.nupkg // * Foo.1.2.0.nupkg // * Foo.1.2.0.0.nupkg // To achieve this, we would look for files named 1.2*.nupkg if both build and revision are 0 and // 1.2.3*.nupkg if only the revision is set to 0. string partialName = version.Version.Build < 1 ? String.Join(".", packageId, version.Version.Major, version.Version.Minor) : String.Join(".", packageId, version.Version.Major, version.Version.Minor, version.Version.Build); string partialManifestName = partialName + "*" + NuGetConstant.ManifestExtension; partialName += "*" + NuGetConstant.PackageExtension; // Partial names would result is gathering package with matching major and minor but different build and revision. // Attempt to match the version in the path to the version we're interested in. var partialNameMatches = GetPackageFiles(partialName).Where(path => FileNameMatchesPattern(packageId, version, path)); var partialManifestNameMatches = GetPackageFiles(partialManifestName).Where( path => FileNameMatchesPattern(packageId, version, path)); filesMatchingFullName = filesMatchingFullName.Concat(partialNameMatches).Concat(partialManifestNameMatches); } // cannot find matching files, we should try to search for just packageid.nupkg if (filesMatchingFullName.Count() == 0) { // exclude version var packageWithoutVersionName = FileUtility.MakePackageFileName(true, packageId, null, NuGetConstant.PackageExtension); var packageWithoutVersionManifest = Path.ChangeExtension(packageWithoutVersionName, NuGetConstant.ManifestExtension); return(GetPackageFiles(packageWithoutVersionName).Concat(GetPackageFiles(packageWithoutVersionManifest))); } return(filesMatchingFullName); }
public void WriteIntegrationParameters(SemanticVersion semanticVersion, IEnumerable <IBuildServer> applicableBuildServers) { foreach (var buildServer in applicableBuildServers) { logger.LogInfo(string.Format("Executing GenerateSetVersionMessage for '{0}'.", buildServer.GetType().Name)); logger.LogInfo(buildServer.GenerateSetVersionMessage(semanticVersion.ToString())); logger.LogInfo(string.Format("Executing GenerateBuildLogOutput for '{0}'.", buildServer.GetType().Name)); foreach (var buildParameter in BuildOutputFormatter.GenerateBuildLogOutput(semanticVersion, buildServer)) { logger.LogInfo(buildParameter); } } }
public bool IsPackageInstalled(Project project, string packageId, SemanticVersion version) { NuGetVersion nugetVersion; if (NuGetVersion.TryParse(version.ToString(), out nugetVersion)) { return(IsPackageInstalled(project, packageId, nugetVersion)); } else { throw new ArgumentException(VsResources.InvalidNuGetVersionString, nameof(version)); } }
public void WriteIntegrationParameters(SemanticVersion semanticVersion, IEnumerable<IBuildServer> applicableBuildServers) { foreach (var buildServer in applicableBuildServers) { logger.LogInfo(string.Format("Executing GenerateSetVersionMessage for '{0}'.", buildServer.GetType().Name)); logger.LogInfo(buildServer.GenerateSetVersionMessage(semanticVersion.ToString())); logger.LogInfo(string.Format("Executing GenerateBuildLogOutput for '{0}'.", buildServer.GetType().Name)); foreach (var buildParameter in BuildOutputFormatter.GenerateBuildLogOutput(semanticVersion, buildServer)) { logger.LogInfo(buildParameter); } } }
// private methods private ConnectionDescription CreateConnectionDescription(SemanticVersion serverVersion) { var clusterId = new ClusterId(1); var serverId = new ServerId(clusterId, new DnsEndPoint("localhost", 27017)); var connectionId = new ConnectionId(serverId, 1); var isMasterResult = new IsMasterResult(new BsonDocument()); var buildInfoResult = new BuildInfoResult(new BsonDocument { { "version", serverVersion.ToString() } }); return(new ConnectionDescription(connectionId, isMasterResult, buildInfoResult)); }
public string Constructor_FromParts(int major, int minor, int patch, string prerelease, string build) { // act ISemanticVersion version = new SemanticVersion(major, minor, patch, prerelease, build); // assert Assert.AreEqual(major, version.MajorVersion, "The major version doesn't match the given value."); Assert.AreEqual(minor, version.MinorVersion, "The minor version doesn't match the given value."); Assert.AreEqual(patch, version.PatchVersion, "The patch version doesn't match the given value."); Assert.AreEqual(string.IsNullOrWhiteSpace(prerelease) ? null : prerelease.Trim(), version.PrereleaseTag, "The prerelease tag doesn't match the given value."); Assert.AreEqual(string.IsNullOrWhiteSpace(build) ? null : build.Trim(), version.BuildMetadata, "The build metadata doesn't match the given value."); return(version.ToString()); }
public void Save(SemanticVersion version, string name, DllReference parentAssembly) { var parser = new FileIniDataParser(); var versionsFileData = new IniData(); versionsFileData.Sections.AddSection("Dependency"); versionsFileData.Sections["Dependency"].AddKey("version", version.ToString()); versionsFileData.Sections["Dependency"].AddKey("name", name); if(!Directory.Exists("cache")) Directory.CreateDirectory("cache"); parser.WriteFile(@"cache\" + parentAssembly.Id.Item1 + _sectionSeparator + parentAssembly.Id.Item2 + _sectionSeparator + name + ".ini", versionsFileData); }
public void Save() { var id = "TestId"; var version = new SemanticVersion("0.1.0"); var authors = new string[] { "Alice", "Bob" }; var manifest = new Manifest(new ManifestMetadata { Id = id, Version = version, Authors = authors }); using (var mem = new MemoryStream()) { manifest.Save(mem); mem.Position = 0; var xdoc = XDocument.Load(mem); var ns = xdoc.Root.GetDefaultNamespace(); var xElemPackage = xdoc.Root; Assert.Equal("package", xElemPackage.Name.LocalName); Assert.Equal(1, xElemPackage.Elements().Count()); var xElemMetadata = xElemPackage.Elements().Single(); Assert.Equal("metadata", xElemMetadata.Name.LocalName); Assert.Equal(5, xElemMetadata.Elements().Count()); var xElemId = xElemMetadata.Element(ns + "id"); Assert.NotNull(xElemId); Assert.Equal(id, xElemId.Value); var xElemVersion = xElemMetadata.Element(ns + "version"); Assert.NotNull(xElemVersion); Assert.Equal(version.ToString(), xElemVersion.Value); var xElemRequireLicense = xElemMetadata.Element(ns + "requireLicenseAcceptance"); Assert.NotNull(xElemRequireLicense); Assert.Equal("false", xElemRequireLicense.Value); var xElemAuthors = xElemMetadata.Element(ns + "authors"); Assert.NotNull(xElemAuthors); Assert.Equal(string.Join(",", authors), xElemAuthors.Value); var xElemOwners = xElemMetadata.Element(ns + "owners"); Assert.NotNull(xElemOwners); Assert.Equal(string.Join(",", authors), xElemOwners.Value); } }
public void ComplexVersionByStringDecompositionResultEqualsInput() { const string preRelease = "alpha.2.abc.f-d"; const string build = "svn.a-4.12342"; var version = new SemanticVersion(1, 2, 3, preRelease, build); Assert.That(version.ToString(), Is.EqualTo("1.2.3-alpha.2.abc.f-d+svn.a-4.12342")); version = new SemanticVersion(1, 2, 3, preRelease, null); Assert.That(version.ToString(), Is.EqualTo("1.2.3-alpha.2.abc.f-d")); version = new SemanticVersion(1, 2, 3, null, build); Assert.That(version.ToString(), Is.EqualTo("1.2.3+svn.a-4.12342")); }
public override bool Exists(string packageId, SemanticVersion version) { if (version != null) { // optimization: if we find the sub-directory with the name "id.version", consider it exists string folderPath = packageId + "." + version.ToString(); if (FileSystem.DirectoryExists(folderPath)) { return true; } } return FindPackage(packageId, version) != null; }
public void ValidateInformationalVersionBuilder(BranchType branchType, string branchName, string sha, int major, int minor, int patch, string tag, int? suffix, string versionString) { var semanticVersion = new SemanticVersion { Major = major, Minor = minor, Patch = patch, PreReleaseTag = tag, BuildMetaData = new SemanticVersionBuildMetaData(suffix, branchName, new ReleaseDate{ CommitSha = sha }), }; var informationalVersion = semanticVersion.ToString("i"); Assert.AreEqual(versionString, informationalVersion); }
public void ValidateInformationalVersionBuilder(string branchName, string sha, int major, int minor, int patch, string tag, int? suffix, string versionString) { var semanticVersion = new SemanticVersion { Major = major, Minor = minor, Patch = patch, PreReleaseTag = tag, BuildMetaData = new SemanticVersionBuildMetaData(suffix, branchName,sha,DateTimeOffset.MinValue), }; var informationalVersion = semanticVersion.ToString("i"); Assert.AreEqual(versionString, informationalVersion); }
private void AttemptToDownload(string packageId, SemanticVersion version, Uri feedUri, string cacheDirectory, out string downloadedTo, out IPackage downloaded) { Console.WriteLine("Downloading NuGet package {0} {1} from feed: '{2}'", packageId, version, feedUri); Log.VerboseFormat("Downloaded package will be stored in: '{0}'", cacheDirectory); fileSystem.EnsureDirectoryExists(cacheDirectory); fileSystem.EnsureDiskHasEnoughFreeSpace(cacheDirectory); downloaded = null; downloadedTo = null; Exception downloadException = null; for (var i = 1; i <= NumberOfTimesToAttemptToDownloadPackage; i++) { try { AttemptToFindAndDownloadPackage(i, packageId, version.ToString(), feedUri.ToString(), cacheDirectory, out downloaded, out downloadedTo); break; } catch (Exception dataException) { Log.VerboseFormat("Attempt {0} of {1}: Unable to download package: {2}", i, NumberOfTimesToAttemptToDownloadPackage, dataException.Message); downloadException = dataException; Thread.Sleep(i*1000); } } if (downloaded == null || downloadedTo == null) { if (downloadException != null) { Log.ErrorFormat("Unable to download package: {0}", downloadException.Message); } throw new Exception( "The package could not be downloaded from NuGet. If you are getting a package verification error, try switching to a Windows File Share package repository to see if that helps."); } if (downloaded.Version != version) { throw new Exception(string.Format( "Octopus requested version {0} of {1}, but the NuGet server returned a package with version {2}", version, packageId, downloaded.Version)); } CheckWhetherThePackageHasDependencies(downloaded); }
public void ComplexVersionDecompositionResultEqualsInput() { var preRelease = new [] {"alpha", "2", "abc"}; var build = new[] { "svn", "12342" }; Contract.Assert(Contract.ForAll(preRelease, part => !String.IsNullOrEmpty(part) && part.All(Char.IsLetterOrDigit))); Contract.Assert(Contract.ForAll(build, part => !String.IsNullOrEmpty(part) && part.All(Char.IsLetterOrDigit))); var version = new SemanticVersion(1, 2, 3, preRelease, build); Assert.That(version.ToString(), Is.EqualTo("1.2.3-alpha.2.abc+svn.12342")); version = new SemanticVersion(1, 2, 3, preRelease, null); Assert.That(version.ToString(), Is.EqualTo("1.2.3-alpha.2.abc")); version = new SemanticVersion(1, 2, 3, null, build); Assert.That(version.ToString(), Is.EqualTo("1.2.3+svn.12342")); }
public static Dictionary<string, string> GetVariablesFor( SemanticVersion semanticVersion, AssemblyVersioningScheme assemblyVersioningScheme = AssemblyVersioningScheme.MajorMinorPatch, bool addNumberOfCommitsSinceTagOnMasterBranchToFileVersion = true) { var bmd = semanticVersion.BuildMetaData; var formatter = bmd.Branch == "develop" ? new CiFeedFormatter() : null; var assemblyMetaData = AssemblyVersionsGenerator.Process( semanticVersion, assemblyVersioningScheme, addNumberOfCommitsSinceTagOnMasterBranchToFileVersion); var variables = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase) { {Major, semanticVersion.Major.ToString()}, {Minor, semanticVersion.Minor.ToString()}, {Patch, semanticVersion.Patch.ToString()}, {PreReleaseTag, semanticVersion.PreReleaseTag}, {PreReleaseTagWithDash, semanticVersion.PreReleaseTag.HasTag() ? "-" + semanticVersion.PreReleaseTag : null}, {BuildMetaData, bmd}, {FullBuildMetaData, bmd.ToString("f")}, {MajorMinorPatch, string.Format("{0}.{1}.{2}", semanticVersion.Major, semanticVersion.Minor, semanticVersion.Patch)}, {SemVer, semanticVersion.ToString(null, formatter)}, {LegacySemVer, semanticVersion.ToString("l", formatter)}, {LegacySemVerPadded, semanticVersion.ToString("lp", formatter)}, {AssemblySemVer, semanticVersion.ToString("j") + ".0"}, {FullSemVer, semanticVersion.ToString("f", formatter)}, {InformationalVersion, semanticVersion.ToString("i", formatter)}, {ClassicVersion, string.Format("{0}.{1}", semanticVersion.ToString("j"), (bmd.CommitsSinceTag ?? 0))}, {ClassicVersionWithTag, string.Format("{0}.{1}{2}", semanticVersion.ToString("j"), bmd.CommitsSinceTag ?? 0, semanticVersion.PreReleaseTag.HasTag() ? "-" + semanticVersion.PreReleaseTag : null)}, {BranchName, bmd.Branch}, {Sha, bmd.Sha}, {AssemblyVersion, assemblyMetaData.Version}, {AssemblyFileVersion, assemblyMetaData.FileVersion}, {OriginalRelease, string.Format("{0}.{1}", bmd.ReleaseDate.OriginalCommitSha, bmd.ReleaseDate.OriginalDate.UtcDateTime.ToString("u"))}, }; return variables; }
public async Task<IPackage> GetAsync(long id, SemanticVersion version) { var key = id.ToString() + "/" + version.ToString(); var ms = new MemoryStream(); using (var blob = await bucket.GetAsync(key).ConfigureAwait(false)) { using (var channel = blob.Open()) { await channel.CopyToAsync(ms).ConfigureAwait(false); } } ms.Position = 1; return ZipPackage.FromStream(ms, stripFirstLevel: false); }
public static Dictionary<string, string> GetVariablesFor( SemanticVersion semanticVersion) { var bmd = semanticVersion.BuildMetaData; var formatter = bmd.Branch == "develop" ? new CiFeedFormatter() : null; var variables = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase) { {Major, semanticVersion.Major.ToString()}, {Minor, semanticVersion.Minor.ToString()}, {Patch, semanticVersion.Patch.ToString()}, {PreReleaseTag, semanticVersion.PreReleaseTag}, {PreReleaseTagWithDash, semanticVersion.PreReleaseTag.HasTag() ? "-" + semanticVersion.PreReleaseTag : null}, {BuildMetaData, bmd}, {FullBuildMetaData, bmd.ToString("f")}, {MajorMinorPatch, string.Format("{0}.{1}.{2}", semanticVersion.Major, semanticVersion.Minor, semanticVersion.Patch)}, {SemVer, semanticVersion.ToString(null, formatter)}, {LegacySemVer, semanticVersion.ToString("l", formatter)}, {LegacySemVerPadded, semanticVersion.ToString("lp", formatter)}, {AssemblySemVer, semanticVersion.ToString("j") + ".0"}, {FullSemVer, semanticVersion.ToString("f", formatter)}, {InformationalVersion, semanticVersion.ToString("i", formatter)}, {ClassicVersion, string.Format("{0}.{1}", semanticVersion.ToString("j"), (bmd.CommitsSinceTag ?? 0))}, {ClassicVersionWithTag, string.Format("{0}.{1}{2}", semanticVersion.ToString("j"), bmd.CommitsSinceTag ?? 0, semanticVersion.PreReleaseTag.HasTag() ? "-" + semanticVersion.PreReleaseTag : null)}, {BranchName, bmd.Branch}, {Sha, bmd.Sha}, {OriginalRelease, string.Format("{0}.{1}", bmd.ReleaseDate.OriginalCommitSha, bmd.ReleaseDate.OriginalDate.UtcDateTime.ToString("u"))}, }; // Use ToLower() to fix a bug where Beta and beta are different in NuGet variables[NuGetVersionV2] = variables[LegacySemVerPadded].ToLower(); //variables[NuGetVersionV3] = variables[LegacySemVerPadded].ToLower(); // TODO: when v3 is released, determine what to use variables[NuGetVersion] = variables[NuGetVersionV2]; return variables; }
public void ToStringJTests() { Assert.AreEqual("1.2.3", SemanticVersion.Parse("1.2.3", null).ToString("j")); Assert.AreEqual("1.2.3", SemanticVersion.Parse("1.2.3-beta.4", null).ToString("j")); var fullSemVer = new SemanticVersion { Major = 1, Minor = 2, Patch = 3, PreReleaseTag = new SemanticVersionPreReleaseTag("beta", 4), BuildMetaData = new SemanticVersionBuildMetaData { Sha = "theSha", Branch = "TheBranch", CommitsSinceTag = 5, OtherMetaData = "TheOtherMetaData" } }; Assert.AreEqual("1.2.3", fullSemVer.ToString("j")); }