public ContentItem Get(int id, VersionOptions options) { var record = _contentStorageManager .Query<ContentItemVersionRecord>(x => _query(x, id, options)) .OrderBy(x => x.Number) .LastOrDefault(); return new ContentItem { VersionRecord = record }; }
public static IApplicationBuilder UseDatabaseInstaller(this IApplicationBuilder app, Action<VersionOptions> options) { if (app == null) { throw new ArgumentNullException(nameof(app)); } if (options == null) { throw new ArgumentNullException(nameof(options)); } var versionOptions = new VersionOptions(); options.Invoke(versionOptions); return app.UseMiddleware<DatabaseInstallerMiddleware>(versionOptions); }
public void Equality() { var vo1a = new VersionOptions { Version = new SemanticVersion("1.2"), AssemblyVersion = new VersionOptions.AssemblyVersionOptions(new Version("1.3")), BuildNumberOffset = 2, }; var vo1b = new VersionOptions { Version = new SemanticVersion("1.2"), AssemblyVersion = new VersionOptions.AssemblyVersionOptions(new Version("1.3")), BuildNumberOffset = 2, }; var vo2VaryAV = new VersionOptions { Version = new SemanticVersion("1.2"), AssemblyVersion = new VersionOptions.AssemblyVersionOptions(new Version("1.4")), }; var vo2VaryV = new VersionOptions { Version = new SemanticVersion("1.4"), AssemblyVersion = new VersionOptions.AssemblyVersionOptions(new Version("1.3")), }; var vo2VaryO = new VersionOptions { Version = new SemanticVersion("1.2"), AssemblyVersion = new VersionOptions.AssemblyVersionOptions(new Version("1.3")), BuildNumberOffset = 3, }; Assert.Equal(vo1a, vo1b); Assert.NotEqual(vo2VaryAV, vo1a); Assert.NotEqual(vo2VaryV, vo1a); Assert.NotEqual(vo2VaryO, vo1a); }
public async Task GetBuildVersion_In_Git_With_Version_File_In_Root_And_Project_In_Root_Works() { var rootVersionSpec = new VersionOptions { Version = SemanticVersion.Parse("14.1"), AssemblyVersion = new VersionOptions.AssemblyVersionOptions(new Version(14, 0)), }; this.WriteVersionFile(rootVersionSpec); this.InitializeSourceControl(); this.AddCommits(this.random.Next(15)); var buildResult = await this.BuildAsync(this.testProjectInRoot); this.AssertStandardProperties(rootVersionSpec, buildResult); }
public ContentItem Restore(ContentItem contentItem, VersionOptions options) { return(_decoratedService.Restore(contentItem, options)); }
/// <summary> /// Encodes a commit from history in a <see cref="Version"/> /// so that the original commit can be found later. /// </summary> /// <param name="commit">The commit whose ID and position in history is to be encoded.</param> /// <param name="versionOptions">The version options applicable at this point (either from commit or working copy).</param> /// <param name="repoRelativeProjectDirectory">The repo-relative project directory for which to calculate the version.</param> /// <param name="versionHeight"> /// The version height, previously calculated by a call to <see cref="GetVersionHeight(Commit, string)"/> /// with the same value for <paramref name="repoRelativeProjectDirectory"/>. /// </param> /// <returns> /// A version whose <see cref="Version.Build"/> and /// <see cref="Version.Revision"/> components are calculated based on the commit. /// </returns> /// <remarks> /// In the returned version, the <see cref="Version.Build"/> component is /// the height of the git commit while the <see cref="Version.Revision"/> /// component is the first four bytes of the git commit id (forced to be a positive integer). /// </remarks> /// <returns></returns> private static Version GetIdAsVersionHelper(Commit commit, VersionOptions versionOptions, string repoRelativeProjectDirectory, int? versionHeight) { var baseVersion = versionOptions?.Version?.Version ?? Version0; // The compiler (due to WinPE header requirements) only allows 16-bit version components, // and forbids 0xffff as a value. // The build number is set to the git height. This helps ensure that // within a major.minor release, each patch has an incrementing integer. // The revision is set to the first two bytes of the git commit ID. if (!versionHeight.HasValue) { versionHeight = commit != null ? commit.GetHeight(c => CommitMatchesMajorMinorVersion(c, baseVersion, repoRelativeProjectDirectory)) : 0; } int build = versionHeight.Value + (versionOptions?.BuildNumberOffset ?? 0); Verify.Operation(build <= MaximumBuildNumberOrRevisionComponent, "Git height is {0}, which is greater than the maximum allowed {0}.", build, MaximumBuildNumberOrRevisionComponent); int revision = commit != null ? Math.Min(MaximumBuildNumberOrRevisionComponent, commit.GetTruncatedCommitIdAsUInt16()) : 0; return new Version(baseVersion.Major, baseVersion.Minor, build, revision); }
private void AssertPathHasVersion(Commit commit, string absolutePath, VersionOptions expected) { var actual = VersionFile.GetVersion(absolutePath); Assert.Equal(expected, actual); // Pass in the repo-relative path to ensure the commit is used as the data source. string relativePath = absolutePath.Substring(this.RepoPath.Length).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); actual = VersionFile.GetVersion(commit, relativePath); Assert.Equal(expected, actual); }
public async Task PublicRelease_RegEx_SatisfiedByCheckedOutBranch() { var versionOptions = new VersionOptions { Version = SemanticVersion.Parse("1.0"), PublicReleaseRefSpec = new string[] { "^refs/heads/release$" }, }; this.WriteVersionFile(versionOptions); this.InitializeSourceControl(); // Check out a branch that conforms. var releaseBranch = this.Repo.CreateBranch("release"); this.Repo.Checkout(releaseBranch); var buildResult = await this.BuildAsync(); Assert.True(buildResult.PublicRelease); AssertStandardProperties(versionOptions, buildResult); }
public ContentItem Get(int id, VersionOptions options, QueryHints hints) { return(_decoratedService.Get(id, options, hints)); }
private static Version GetExpectedAssemblyVersion(VersionOptions versionOptions, Version version) { var assemblyVersionPrecision = versionOptions.AssemblyVersion?.Precision ?? VersionOptions.VersionPrecision.Minor; int assemblyVersionBuild = assemblyVersionPrecision >= VersionOptions.VersionPrecision.Build ? version.Build : 0; int assemblyVersionRevision = assemblyVersionPrecision >= VersionOptions.VersionPrecision.Revision ? version.Revision : 0; Version assemblyVersion = (versionOptions.AssemblyVersion?.Version ?? versionOptions.Version.Version).EnsureNonNegativeComponents(); assemblyVersion = new Version(assemblyVersion.Major, assemblyVersion.Minor, assemblyVersionBuild, assemblyVersionRevision); return assemblyVersion; }
public ShippingProviderPart GetProvider(int ProviderId, int?VersionRecordId = null) { return(_contentManager.Get <ShippingProviderPart>(ProviderId, VersionRecordId.HasValue ? VersionOptions.VersionRecord(VersionRecordId.Value) : VersionOptions.Published)); }
private static int OnInstallCommand(string path, string version, IReadOnlyList <string> source) { if (!SemanticVersion.TryParse(string.IsNullOrEmpty(version) ? DefaultVersionSpec : version, out var semver)) { Console.Error.WriteLine($"\"{version}\" is not a semver-compliant version spec."); return((int)ExitCodes.InvalidVersionSpec); } var options = new VersionOptions { Version = semver, PublicReleaseRefSpec = new string[] { @"^refs/heads/master$", @"^refs/heads/v\d+(?:\.\d+)?$", }, CloudBuild = new VersionOptions.CloudBuildOptions { BuildNumber = new VersionOptions.CloudBuildNumberOptions { Enabled = true, }, }, }; string searchPath = GetSpecifiedOrCurrentDirectoryPath(path); if (!Directory.Exists(searchPath)) { Console.Error.WriteLine("\"{0}\" is not an existing directory.", searchPath); return((int)ExitCodes.NoGitRepo); } using var context = GitContext.Create(searchPath, writable: true); if (!context.IsRepository) { Console.Error.WriteLine("No git repo found at or above: \"{0}\"", searchPath); return((int)ExitCodes.NoGitRepo); } if (string.IsNullOrEmpty(path)) { path = context.WorkingTreePath; } var existingOptions = context.VersionFile.GetVersion(); if (existingOptions != null) { if (!string.IsNullOrEmpty(version)) { var setVersionExitCode = OnSetVersionCommand(path, version); if (setVersionExitCode != (int)ExitCodes.OK) { return(setVersionExitCode); } } } else { string versionJsonPath = context.VersionFile.SetVersion(path, options); context.Stage(versionJsonPath); } // Create/update the Directory.Build.props file in the directory of the version.json file to add the NB.GV package. string directoryBuildPropsPath = Path.Combine(path, "Directory.Build.props"); ProjectRootElement propsFile = File.Exists(directoryBuildPropsPath) ? ProjectRootElement.Open(directoryBuildPropsPath) : ProjectRootElement.Create(directoryBuildPropsPath); const string PackageReferenceItemType = "PackageReference"; if (!propsFile.Items.Any(i => i.ItemType == PackageReferenceItemType && i.Include == PackageId)) { // Validate given sources foreach (var src in source) { // TODO: Can declare Option<Uri> to validate argument during parsing. if (!Uri.TryCreate(src, UriKind.Absolute, out var _)) { Console.Error.WriteLine($"\"{src}\" is not a valid NuGet package source."); return((int)ExitCodes.InvalidNuGetPackageSource); } } string packageVersion = GetLatestPackageVersionAsync(PackageId, path, source).GetAwaiter().GetResult(); if (string.IsNullOrEmpty(packageVersion)) { string verifyPhrase = source.Any() ? "Please verify the given 'source' option(s)." : "Please verify the package sources in the NuGet.Config files."; Console.Error.WriteLine($"Latest stable version of the {PackageId} package could not be determined. " + verifyPhrase); return((int)ExitCodes.PackageIdNotFound); } var item = propsFile.AddItem( PackageReferenceItemType, PackageId, new Dictionary <string, string> { { "Version", packageVersion }, { "PrivateAssets", "all" }, }); item.Condition = "!Exists('packages.config')"; propsFile.Save(directoryBuildPropsPath); } context.Stage(directoryBuildPropsPath); return((int)ExitCodes.OK); }
public int Count(ForumPart forumPart, VersionOptions versionOptions) { return(GetParentQuery(forumPart, versionOptions).Count()); }
public IEnumerable <ThreadPart> Get(ForumPart forumPart, int skip, int count, VersionOptions versionOptions) { return(GetParentQuery(forumPart, versionOptions) .Join <ThreadPartRecord>() .OrderByDescending(o => o.IsSticky) .Join <CommonPartRecord>() .OrderByDescending(o => o.ModifiedUtc) .ForPart <ThreadPart>() .Slice(skip, count) .ToList()); }
public IEnumerable <ThreadPart> Get(ForumPart forumPart, VersionOptions versionOptions) { return(Get(forumPart, 0, 0, versionOptions)); }
public async Task GetBuildVersion_CustomAssemblyVersionPrecision(VersionOptions.VersionPrecision precision) { var versionOptions = new VersionOptions { Version = new SemanticVersion("14.1"), AssemblyVersion = new VersionOptions.AssemblyVersionOptions { Precision = precision, }, }; this.WriteVersionFile(versionOptions); this.InitializeSourceControl(); var buildResult = await this.BuildAsync(this.testProject); this.AssertStandardProperties(versionOptions, buildResult); }
public Task CreateAsync(ContentItem contentItem, VersionOptions options, bool invokeUpdateCallbacks = false) => throw new System.NotImplementedException();
public async Task BuildNumber_SetInCI(VersionOptions versionOptions, IReadOnlyDictionary<string, string> properties, string expectedBuildNumberMessage) { this.WriteVersionFile(versionOptions); this.InitializeSourceControl(); foreach (var property in properties) { this.globalProperties[property.Key] = property.Value; } var buildResult = await this.BuildAsync(this.testProject); AssertStandardProperties(versionOptions, buildResult); expectedBuildNumberMessage = expectedBuildNumberMessage.Replace("{CLOUDBUILDNUMBER}", buildResult.CloudBuildNumber); Assert.Contains(expectedBuildNumberMessage, buildResult.LoggedEvents.Select(e => e.Message.TrimEnd())); }
public Task CreateAsync(ContentItem contentItem, VersionOptions options) => throw new NotImplementedException();
protected Commit WriteVersionFile(VersionOptions versionData, string relativeDirectory = null) { Requires.NotNull(versionData, nameof(versionData)); if (relativeDirectory == null) { relativeDirectory = string.Empty; } string versionFilePath = VersionFile.SetVersion(Path.Combine(this.RepoPath, relativeDirectory), versionData); return this.CommitVersionFile(versionFilePath, versionData.Version.ToString()); }
public Task <ContentItem> GetAsync(string id, VersionOptions options) => throw new NotImplementedException();
private IContentQuery <CommonPart, CommonPartRecord> GetParentQuery(IContent parentPart, VersionOptions versionOptions) { return(_contentManager.Query <CommonPart, CommonPartRecord>(versionOptions) .Where(cpr => cpr.Container == parentPart.ContentItem.Record)); }
/// <summary> /// Indexes a batch of content items /// </summary> /// <returns> /// <c>true</c> if there are more items to process; otherwise, <c>false</c>. /// </returns> private bool BatchIndex(string indexName, string settingsFilename, IndexSettings indexSettings) { var addToIndex = new List <IDocumentIndex>(); var deleteFromIndex = new List <int>(); // Rebuilding the index ? if (indexSettings.Mode == IndexingMode.Rebuild) { Logger.Information("Rebuilding index"); _indexingStatus = IndexingStatus.Rebuilding; // load all content items var contentItems = _contentRepository .Fetch( versionRecord => versionRecord.Published && versionRecord.Id > indexSettings.LastContentId, order => order.Asc(versionRecord => versionRecord.Id)) .Take(ContentItemsPerLoop) .Select(versionRecord => _contentManager.Get(versionRecord.ContentItemRecord.Id, VersionOptions.VersionRecord(versionRecord.Id))) .Distinct() .ToList(); // if no more elements to index, switch to update mode if (contentItems.Count == 0) { indexSettings.Mode = IndexingMode.Update; } foreach (var item in contentItems) { try { IDocumentIndex documentIndex = ExtractDocumentIndex(item); if (documentIndex != null && documentIndex.IsDirty) { addToIndex.Add(documentIndex); } indexSettings.LastContentId = item.VersionRecord.Id; } catch (Exception ex) { Logger.Warning(ex, "Unable to index content item #{0} during rebuild", item.Id); } } } if (indexSettings.Mode == IndexingMode.Update) { Logger.Information("Updating index"); _indexingStatus = IndexingStatus.Updating; var indexingTasks = _taskRepository .Fetch(x => x.Id > indexSettings.LastIndexedId) .OrderBy(x => x.Id) .Take(ContentItemsPerLoop) .GroupBy(x => x.ContentItemRecord.Id) .Select(group => new { TaskId = group.Max(task => task.Id), Delete = group.Last().Action == IndexingTaskRecord.Delete, Id = group.Key, ContentItem = _contentManager.Get(group.Key, VersionOptions.Published) }) .OrderBy(x => x.TaskId) .ToArray(); foreach (var item in indexingTasks) { try { // item.ContentItem can be null if the content item has been deleted IDocumentIndex documentIndex = ExtractDocumentIndex(item.ContentItem); if (documentIndex == null || item.Delete) { deleteFromIndex.Add(item.Id); } else if (documentIndex.IsDirty) { addToIndex.Add(documentIndex); } indexSettings.LastIndexedId = item.TaskId; } catch (Exception ex) { Logger.Warning(ex, "Unable to index content item #{0} during update", item.Id); } } } // save current state of the index indexSettings.LastIndexedUtc = _clock.UtcNow; _appDataFolder.CreateFile(settingsFilename, indexSettings.ToXml()); if (deleteFromIndex.Count == 0 && addToIndex.Count == 0) { // nothing more to do _indexingStatus = IndexingStatus.Idle; return(false); } // save new and updated documents to the index try { if (addToIndex.Count > 0) { _indexProvider.Store(indexName, addToIndex); Logger.Information("Added content items to index: {0}", addToIndex.Count); } } catch (Exception ex) { Logger.Warning(ex, "An error occured while adding a document to the index"); } // removing documents from the index try { if (deleteFromIndex.Count > 0) { _indexProvider.Delete(indexName, deleteFromIndex); Logger.Information("Added content items to index: {0}", addToIndex.Count); } } catch (Exception ex) { Logger.Warning(ex, "An error occured while removing a document from the index"); } return(true); }
public void SetVersion_WritesSimplestFile(string version, string assemblyVersion, VersionOptions.VersionPrecision precision, int buildNumberOffset, string expectedJson) { var versionOptions = new VersionOptions { Version = SemanticVersion.Parse(version), AssemblyVersion = new VersionOptions.AssemblyVersionOptions(assemblyVersion != null ? new Version(assemblyVersion) : null, precision), BuildNumberOffset = buildNumberOffset, }; string pathWritten = VersionFile.SetVersion(this.RepoPath, versionOptions); string actualFileContent = File.ReadAllText(pathWritten); this.Logger.WriteLine(actualFileContent); string normalizedFileContent = JsonConvert.SerializeObject(JsonConvert.DeserializeObject(actualFileContent)); Assert.Equal(expectedJson, normalizedFileContent); }
public IEnumerable <TermPart> GetTermsForContentItem(int contentItemId, string field = null, VersionOptions versionOptions = null) { var termIds = String.IsNullOrEmpty(field) ? _termContentItemRepository.Fetch(x => x.TermsPartRecord.ContentItemRecord.Id == contentItemId).Select(t => t.TermRecord.Id).ToArray() : _termContentItemRepository.Fetch(x => x.TermsPartRecord.Id == contentItemId && x.Field == field).Select(t => t.TermRecord.Id).ToArray(); return(_contentManager.GetMany <TermPart>(termIds, versionOptions ?? VersionOptions.Published, QueryHints.Empty)); }
public RestoreContentContext(ContentItem contentItem, VersionOptions versionOptions) : base(contentItem) { VersionOptions = versionOptions; }
public new virtual ContentItem Get(int id, VersionOptions options) { return(Get(id, options, QueryHints.Empty)); }
public void VersionJson_Inheritance(bool commitInSourceControl) { if (commitInSourceControl) { this.InitializeSourceControl(); } VersionOptions level1, level2, level3, level2NoInherit, level2InheritButResetVersion; this.WriteVersionFile( level1 = new VersionOptions { Version = SemanticVersion.Parse("14.2"), AssemblyVersion = new VersionOptions.AssemblyVersionOptions { Precision = VersionOptions.VersionPrecision.Major }, }); this.WriteVersionFile( level2 = new VersionOptions { Inherit = true, AssemblyVersion = new VersionOptions.AssemblyVersionOptions { Precision = VersionOptions.VersionPrecision.Minor }, }, "foo"); this.WriteVersionFile( level3 = new VersionOptions { Inherit = true, VersionHeightOffset = 1, }, "foo/bar"); this.WriteVersionFile( level2NoInherit = new VersionOptions { Version = SemanticVersion.Parse("10.1"), }, "noInherit"); this.WriteVersionFile( level2InheritButResetVersion = new VersionOptions { Inherit = true, Version = SemanticVersion.Parse("8.2"), }, "inheritWithVersion"); VersionOptions GetOption(string path) { using var context = this.CreateGitContext(Path.Combine(this.RepoPath, path)); return context.VersionFile.GetVersion(); } var level1Options = GetOption(string.Empty); Assert.False(level1Options.Inherit); var level2Options = GetOption("foo"); Assert.Equal(level1.Version.Version.Major, level2Options.Version.Version.Major); Assert.Equal(level1.Version.Version.Minor, level2Options.Version.Version.Minor); Assert.Equal(level2.AssemblyVersion.Precision, level2Options.AssemblyVersion.Precision); Assert.True(level2Options.Inherit); var level3Options = GetOption("foo/bar"); Assert.Equal(level1.Version.Version.Major, level3Options.Version.Version.Major); Assert.Equal(level1.Version.Version.Minor, level3Options.Version.Version.Minor); Assert.Equal(level2.AssemblyVersion.Precision, level3Options.AssemblyVersion.Precision); Assert.Equal(level2.AssemblyVersion.Precision, level3Options.AssemblyVersion.Precision); Assert.Equal(level3.VersionHeightOffset, level3Options.VersionHeightOffset); Assert.True(level3Options.Inherit); var level2NoInheritOptions = GetOption("noInherit"); Assert.Equal(level2NoInherit.Version, level2NoInheritOptions.Version); Assert.Equal(VersionOptions.DefaultVersionPrecision, level2NoInheritOptions.AssemblyVersionOrDefault.PrecisionOrDefault); Assert.False(level2NoInheritOptions.Inherit); var level2InheritButResetVersionOptions = GetOption("inheritWithVersion"); Assert.Equal(level2InheritButResetVersion.Version, level2InheritButResetVersionOptions.Version); Assert.True(level2InheritButResetVersionOptions.Inherit); if (commitInSourceControl) { int totalCommits = this.LibGit2Repository.Head.Commits.Count(); // The version height should be the same for all those that inherit the version from the base, // even though the inheriting files were introduced in successive commits. Assert.Equal(totalCommits, this.GetVersionHeight()); Assert.Equal(totalCommits, this.GetVersionHeight("foo")); Assert.Equal(totalCommits, this.GetVersionHeight("foo/bar")); // These either don't inherit, or inherit but reset versions, so the commits were reset. Assert.Equal(2, this.GetVersionHeight("noInherit")); Assert.Equal(1, this.GetVersionHeight("inheritWithVersion")); } }
public ContentItem Get(int id, VersionOptions versionOptions) { var blogPart = _contentManager.Get <BlogPart>(id, versionOptions); return(blogPart == null ? null : blogPart.ContentItem); }
public IEnumerable <T> GetMany <T>(IEnumerable <int> ids, VersionOptions options, QueryHints hints) where T : class, IContent { return(_decoratedService.GetMany <T>(ids, options, hints)); }
public new IContentQuery <TPart, TRecord> ForVersion(VersionOptions options) { throw new NotImplementedException(); }
public async Task GetBuildVersion_CustomAssemblyVersion() { this.WriteVersionFile("14.0"); this.InitializeSourceControl(); var versionOptions = new VersionOptions { Version = new SemanticVersion(new Version(14, 1)), AssemblyVersion = new VersionOptions.AssemblyVersionOptions(new Version(14, 0)), }; this.WriteVersionFile(versionOptions); var buildResult = await this.BuildAsync(this.testProject); this.AssertStandardProperties(versionOptions, buildResult); }
private static Version GetAssemblyVersion(Version version, VersionOptions versionOptions) { var assemblyVersion = versionOptions?.AssemblyVersion?.Version ?? new System.Version(version.Major, version.Minor); assemblyVersion = new System.Version( assemblyVersion.Major, assemblyVersion.Minor, versionOptions?.AssemblyVersion?.Precision >= VersionOptions.VersionPrecision.Build ? version.Build : 0, versionOptions?.AssemblyVersion?.Precision >= VersionOptions.VersionPrecision.Revision ? version.Revision : 0); return assemblyVersion; }
public async Task CloudBuildVariables_SetInCI(IReadOnlyDictionary<string, string> properties, string expectedMessage) { foreach (var property in properties) { this.globalProperties[property.Key] = property.Value; } string keyName = "n1"; string value = "v1"; this.testProject.AddItem("CloudBuildVersionVars", keyName, new Dictionary<string, string> { { "Value", value } }); string alwaysExpectedMessage = expectedMessage .Replace("{NAME}", keyName) .Replace("{VALUE}", value); var versionOptions = new VersionOptions { Version = SemanticVersion.Parse("1.0"), CloudBuild = new VersionOptions.CloudBuildOptions { SetVersionVariables = true }, }; this.WriteVersionFile(versionOptions); this.InitializeSourceControl(); var buildResult = await this.BuildAsync(this.testProject); AssertStandardProperties(versionOptions, buildResult); string conditionallyExpectedMessage = expectedMessage .Replace("{NAME}", "GitBuildVersion") .Replace("{VALUE}", buildResult.BuildVersion); Assert.Contains(alwaysExpectedMessage, buildResult.LoggedEvents.Select(e => e.Message.TrimEnd())); Assert.Contains(conditionallyExpectedMessage, buildResult.LoggedEvents.Select(e => e.Message.TrimEnd())); versionOptions.CloudBuild.SetVersionVariables = false; this.WriteVersionFile(versionOptions); buildResult = await this.BuildAsync(this.testProject); AssertStandardProperties(versionOptions, buildResult); conditionallyExpectedMessage = expectedMessage .Replace("{NAME}", "GitBuildVersion") .Replace("{VALUE}", buildResult.BuildVersion); Assert.Contains(alwaysExpectedMessage, buildResult.LoggedEvents.Select(e => e.Message.TrimEnd())); Assert.DoesNotContain(conditionallyExpectedMessage, buildResult.LoggedEvents.Select(e => e.Message.TrimEnd())); }
public IEnumerable <LayoutPart> GetTemplateClients(int templateId, VersionOptions versionOptions) { return(_contentManager.Query <LayoutPart, LayoutPartRecord>(versionOptions).Where(x => x.TemplateId == templateId).List().ToArray()); }
public async Task BuildNumber_VariousOptions(bool isPublic, VersionOptions.CloudBuildNumberCommitWhere where, VersionOptions.CloudBuildNumberCommitWhen when, [CombinatorialValues(0, 1, 2)] int extraBuildMetadataCount) { var versionOptions = BuildNumberVersionOptionsBasis; versionOptions.CloudBuild.BuildNumber.IncludeCommitId.Where = where; versionOptions.CloudBuild.BuildNumber.IncludeCommitId.When = when; this.WriteVersionFile(versionOptions); this.InitializeSourceControl(); this.globalProperties["PublicRelease"] = isPublic.ToString(); for (int i = 0; i < extraBuildMetadataCount; i++) { this.testProject.AddItem("BuildMetadata", $"A{i}"); } var buildResult = await this.BuildAsync(this.testProject); AssertStandardProperties(versionOptions, buildResult); }
private IEnumerable <LocalizationPart> GetDisplayLocalizations(LocalizationPart part, VersionOptions versionOptions) { return(_localizationService.GetLocalizations(part.ContentItem, versionOptions) .Select(c => { var localized = c.ContentItem.As <LocalizationPart>(); if (localized.Culture == null) { localized.Culture = _cultureManager.GetCultureByName(_cultureManager.GetSiteCulture()); } return c; }).ToList()); }
private void AssertStandardProperties(VersionOptions versionOptions, BuildResults buildResult, string relativeProjectDirectory = null) { int versionHeight = this.Repo.GetVersionHeight(relativeProjectDirectory); Version idAsVersion = this.Repo.GetIdAsVersion(relativeProjectDirectory); string commitIdShort = this.Repo.Head.Commits.First().Id.Sha.Substring(0, 10); Version version = this.Repo.GetIdAsVersion(relativeProjectDirectory); Version assemblyVersion = GetExpectedAssemblyVersion(versionOptions, version); var additionalBuildMetadata = from item in buildResult.BuildResult.ProjectStateAfterBuild.GetItems("BuildMetadata") select item.EvaluatedInclude; var expectedBuildMetadata = $"+g{commitIdShort}"; if (additionalBuildMetadata.Any()) { expectedBuildMetadata += "." + string.Join(".", additionalBuildMetadata); } Assert.Equal($"{version}", buildResult.AssemblyFileVersion); Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}{versionOptions.Version.Prerelease}{expectedBuildMetadata}", buildResult.AssemblyInformationalVersion); // The assembly version property should always have four integer components to it, // per bug https://github.com/AArnott/Nerdbank.GitVersioning/issues/26 Assert.Equal($"{assemblyVersion.Major}.{assemblyVersion.Minor}.{assemblyVersion.Build}.{assemblyVersion.Revision}", buildResult.AssemblyVersion); Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumber); Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumberFirstAndSecondComponentsIfApplicable); Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumberFirstComponent); Assert.Equal(string.Empty, buildResult.BuildNumberSecondComponent); Assert.Equal($"{version}", buildResult.BuildVersion); Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}", buildResult.BuildVersion3Components); Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildVersionNumberComponent); Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}", buildResult.BuildVersionSimple); Assert.Equal(this.Repo.Head.Commits.First().Id.Sha, buildResult.GitCommitId); Assert.Equal(commitIdShort, buildResult.GitCommitIdShort); Assert.Equal(versionHeight.ToString(), buildResult.GitVersionHeight); Assert.Equal($"{version.Major}.{version.Minor}", buildResult.MajorMinorVersion); Assert.Equal(versionOptions.Version.Prerelease, buildResult.PrereleaseVersion); Assert.Equal(expectedBuildMetadata, buildResult.SemVerBuildSuffix); string pkgVersionSuffix = buildResult.PublicRelease ? string.Empty : $"-g{commitIdShort}"; Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}{versionOptions.Version.Prerelease}{pkgVersionSuffix}", buildResult.NuGetPackageVersion); var buildNumberOptions = versionOptions.CloudBuild?.BuildNumber ?? new VersionOptions.CloudBuildNumberOptions(); if (buildNumberOptions.Enabled) { var commitIdOptions = buildNumberOptions.IncludeCommitId ?? new VersionOptions.CloudBuildNumberCommitIdOptions(); var buildNumberSemVer = SemanticVersion.Parse(buildResult.CloudBuildNumber); bool hasCommitData = commitIdOptions.When == VersionOptions.CloudBuildNumberCommitWhen.Always || (commitIdOptions.When == VersionOptions.CloudBuildNumberCommitWhen.NonPublicReleaseOnly && !buildResult.PublicRelease); Version expectedVersion = hasCommitData && commitIdOptions.Where == VersionOptions.CloudBuildNumberCommitWhere.FourthVersionComponent ? idAsVersion : new Version(version.Major, version.Minor, version.Build); Assert.Equal(expectedVersion, buildNumberSemVer.Version); Assert.Equal(buildResult.PrereleaseVersion, buildNumberSemVer.Prerelease); string expectedBuildNumberMetadata = hasCommitData && commitIdOptions.Where == VersionOptions.CloudBuildNumberCommitWhere.BuildMetadata ? $"+g{commitIdShort}" : string.Empty; if (additionalBuildMetadata.Any()) { expectedBuildNumberMetadata = expectedBuildNumberMetadata.Length == 0 ? "+" + string.Join(".", additionalBuildMetadata) : expectedBuildNumberMetadata + "." + string.Join(".", additionalBuildMetadata); } Assert.Equal(expectedBuildNumberMetadata, buildNumberSemVer.BuildMetadata); } else { Assert.Equal(string.Empty, buildResult.CloudBuildNumber); } }
public async Task GetBuildVersion_In_Git_With_Version_File_In_Root_And_Subdirectory_Works() { var rootVersionSpec = new VersionOptions { Version = SemanticVersion.Parse("14.1"), AssemblyVersion = new Version(14, 0) }; var subdirVersionSpec = new VersionOptions { Version = SemanticVersion.Parse("11.0") }; const string subdirectory = "projdir"; this.WriteVersionFile(rootVersionSpec); this.WriteVersionFile(subdirVersionSpec, subdirectory); this.InitializeSourceControl(); this.AddCommits(this.random.Next(15)); var buildResult = await this.BuildAsync(); this.AssertStandardProperties(subdirVersionSpec, buildResult, subdirectory); }
[InlineData(50, -2, true)] // force many build number collisions. generally revision will still make them unique, but it *might* collide on occasion. public void GetIdAsVersion_Roundtrip_UnstableOffset(int startingOffset, int offsetStepChange, bool allowCollisions) { var versionOptions = new VersionOptions { Version = SemanticVersion.Parse("1.2"), AssemblyVersion = null, BuildNumberOffset = startingOffset, }; this.WriteVersionFile(versionOptions); Commit[] commits = new Commit[16]; // create enough that statistically we'll likely hit interesting bits as MSB and LSB Version[] versions = new Version[commits.Length]; for (int i = 0; i < commits.Length; i += 2) { versionOptions.BuildNumberOffset += offsetStepChange; commits[i] = this.WriteVersionFile(versionOptions); versions[i] = commits[i].GetIdAsVersion(); commits[i + 1] = this.Repo.Commit($"Commit {i + 1}", this.Signer, this.Signer, new CommitOptions { AllowEmptyCommit = true }); versions[i + 1] = commits[i + 1].GetIdAsVersion(); this.Logger.WriteLine($"Commit {commits[i].Id.Sha.Substring(0, 8)} as version: {versions[i]}"); this.Logger.WriteLine($"Commit {commits[i + 1].Id.Sha.Substring(0, 8)} as version: {versions[i + 1]}"); // Find the commits we just wrote while they are still at the tip of the branch. var matchingCommits = this.Repo.GetCommitsFromVersion(versions[i]); Assert.Contains(commits[i], matchingCommits); matchingCommits = this.Repo.GetCommitsFromVersion(versions[i + 1]); Assert.Contains(commits[i + 1], matchingCommits); } // Find all commits (again) now that history has been written. for (int i = 0; i < commits.Length; i++) { var matchingCommits = this.Repo.GetCommitsFromVersion(versions[i]).ToList(); Assert.Contains(commits[i], matchingCommits); if (!allowCollisions) { Assert.Equal(1, matchingCommits.Count); } } }
public async Task PublicRelease_RegEx_Unsatisfied() { var versionOptions = new VersionOptions { Version = SemanticVersion.Parse("1.0"), PublicReleaseRefSpec = new string[] { "^refs/heads/release$" }, }; this.WriteVersionFile(versionOptions); this.InitializeSourceControl(); // Just build "master", which doesn't conform to the regex. var buildResult = await this.BuildAsync(); Assert.False(buildResult.PublicRelease); AssertStandardProperties(versionOptions, buildResult); }
public int?GetHomePageId(VersionOptions version = null) { var homePage = GetHomePage(version); return(homePage != null ? homePage.Id : default(int?)); }
private void AssertPathHasVersion(string committish, string absolutePath, VersionOptions expected) { var actual = this.GetVersionOptions(absolutePath, committish); Assert.Equal(expected, this.GetVersionOptions(absolutePath, committish)); }
public async Task GetBuildVersion_CustomBuildNumberOffset() { this.WriteVersionFile("14.0"); this.InitializeSourceControl(); var versionOptions = new VersionOptions { Version = new SemanticVersion(new Version(14, 1)), BuildNumberOffset = 5, }; this.WriteVersionFile(versionOptions); var buildResult = await this.BuildAsync(); this.AssertStandardProperties(versionOptions, buildResult); }
public bool IsHomePage(IContent content, VersionOptions homePageVersion = null) { var homePageId = GetHomePageId(homePageVersion); return(content.Id == homePageId); }
public async Task PublicRelease_RegEx_SatisfiedByCI(IReadOnlyDictionary<string, string> serverProperties) { var versionOptions = new VersionOptions { Version = SemanticVersion.Parse("1.0"), PublicReleaseRefSpec = new string[] { "^refs/heads/release$" }, }; this.WriteVersionFile(versionOptions); this.InitializeSourceControl(); // Don't actually switch the checked out branch in git. CI environment variables // should take precedence over actual git configuration. (Why? because these variables may // retain information about which tag was checked out on a detached head). foreach (var property in serverProperties) { this.globalProperties[property.Key] = property.Value; } var buildResult = await this.BuildAsync(); Assert.True(buildResult.PublicRelease); AssertStandardProperties(versionOptions, buildResult); }
/// <summary> /// Queries the database for the given container and returns a list of the container contents with the specified Part. /// </summary> public static IEnumerable <TPart> GetContainerContentsOfType <TPart, TRecord>(this IContentManager contentManager, int containerId, VersionOptions versionOptions = null) where TPart : ContentPart <TRecord> where TRecord : ContentPartRecord { return(contentManager .Query <TPart, TRecord>(versionOptions ?? VersionOptions.Published) .Join <CommonPartRecord>() .Where(x => x.Container != null && x.Container.Id == containerId) .Join <ContainablePartRecord>() .OrderByDescending(x => x.Position) .List()); }
private void AssertStandardProperties(VersionOptions versionOptions, BuildResults buildResult, string relativeProjectDirectory = null) { int versionHeight = this.Repo.GetVersionHeight(relativeProjectDirectory); Version idAsVersion = this.Repo.GetIdAsVersion(relativeProjectDirectory); string commitIdShort = this.Repo.Head.Commits.First().Id.Sha.Substring(0, 10); Version version = this.Repo.GetIdAsVersion(relativeProjectDirectory); Version assemblyVersion = (versionOptions.AssemblyVersion ?? versionOptions.Version.Version).EnsureNonNegativeComponents(); Assert.Equal($"{version}", buildResult.AssemblyFileVersion); Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}{versionOptions.Version.Prerelease}+g{commitIdShort}", buildResult.AssemblyInformationalVersion); // The assembly version property should always have four integer components to it, // per bug https://github.com/AArnott/Nerdbank.GitVersioning/issues/26 Assert.Equal($"{assemblyVersion.Major}.{assemblyVersion.Minor}.{assemblyVersion.Build}.{assemblyVersion.Revision}", buildResult.AssemblyVersion); Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumber); Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumberFirstAndSecondComponentsIfApplicable); Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumberFirstComponent); Assert.Equal(string.Empty, buildResult.BuildNumberSecondComponent); Assert.Equal($"{version}", buildResult.BuildVersion); Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}", buildResult.BuildVersion3Components); Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildVersionNumberComponent); Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}", buildResult.BuildVersionSimple); Assert.Equal(this.Repo.Head.Commits.First().Id.Sha, buildResult.GitCommitId); Assert.Equal(commitIdShort, buildResult.GitCommitIdShort); Assert.Equal(versionHeight.ToString(), buildResult.GitVersionHeight); Assert.Equal($"{version.Major}.{version.Minor}", buildResult.MajorMinorVersion); Assert.Equal(versionOptions.Version.Prerelease, buildResult.PrereleaseVersion); Assert.Equal($"+g{commitIdShort}", buildResult.SemVerBuildSuffix); string pkgVersionSuffix = buildResult.PublicRelease ? string.Empty : $"-g{commitIdShort}"; Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}{versionOptions.Version.Prerelease}{pkgVersionSuffix}", buildResult.NuGetPackageVersion); }
protected Commit WriteVersionFile(string version = "1.2", string prerelease = "", string relativeDirectory = null) { var versionData = VersionOptions.FromVersion(new System.Version(version), prerelease); return(this.WriteVersionFile(versionData, relativeDirectory)); }
public void GetVersion_String_FindsNearestFileInAncestorDirectories_WithAssemblyVersion() { // Construct a repo where versions are defined like this: /* root <- 14.0 a (inherits 14.0) b <- 11.0 c (inherits 11.0) */ var rootVersionSpec = new VersionOptions { Version = SemanticVersion.Parse("14.1"), AssemblyVersion = new VersionOptions.AssemblyVersionOptions(new Version(14, 0)), }; var subdirVersionSpec = new VersionOptions { Version = SemanticVersion.Parse("11.0") }; VersionFile.SetVersion(this.RepoPath, rootVersionSpec); string subDirA = Path.Combine(this.RepoPath, "a"); string subDirAB = Path.Combine(subDirA, "b"); string subDirABC = Path.Combine(subDirAB, "c"); Directory.CreateDirectory(subDirABC); VersionFile.SetVersion(subDirAB, subdirVersionSpec); this.InitializeSourceControl(); var commit = this.Repo.Head.Commits.First(); AssertPathHasVersion(commit, subDirABC, subdirVersionSpec); AssertPathHasVersion(commit, subDirAB, subdirVersionSpec); AssertPathHasVersion(commit, subDirA, rootVersionSpec); AssertPathHasVersion(commit, this.RepoPath, rootVersionSpec); }
public async Task <IActionResult> Handle(string workflowDefinitionId, VersionOptions versionOptions, CancellationToken cancellationToken = default) { var workflowDefinition = await _workflowDefinitionStore.FindAsync(new WorkflowDefinitionIdSpecification(workflowDefinitionId, versionOptions), cancellationToken); return(workflowDefinition == null?NotFound() : Json(workflowDefinition, SerializationHelper.GetSettingsForWorkflowDefinition())); }
public override async ValueTask <IWorkflowBlueprint?> FindByTagAsync(string tag, VersionOptions versionOptions, string?tenantId = default, CancellationToken cancellationToken = default) { var workflowDefinition = await _workflowDefinitionStore.FindAsync(new WorkflowDefinitionTagSpecification(tag, versionOptions), cancellationToken); return(workflowDefinition == null ? null : await TryMaterializeBlueprintAsync(workflowDefinition, cancellationToken)); }
private IEnumerable <TermPart> GetAppliedTerms(ContentPart part, TaxonomyField field = null, VersionOptions versionOptions = null) { string fieldName = field != null ? field.Name : string.Empty; return(_taxonomyService.GetTermsForContentItem(part.ContentItem.Id, fieldName, versionOptions ?? VersionOptions.Published).Distinct(new TermPartComparer())); }
/// <summary> /// Writes the version.txt file to a directory within a repo with the specified version information. /// </summary> /// <param name="projectDirectory"> /// The path to the directory in which to write the version.txt file. /// The file's impact will be all descendent projects and directories from this specified directory, /// except where any of those directories have their own version.txt file. /// </param> /// <param name="version">The version information to write to the file.</param> /// <returns>The path to the file written.</returns> public static string SetVersion(string projectDirectory, VersionOptions version) { Requires.NotNullOrEmpty(projectDirectory, nameof(projectDirectory)); Requires.NotNull(version, nameof(version)); Requires.Argument(version.Version != null, nameof(version), $"{nameof(VersionOptions.Version)} must be set."); Directory.CreateDirectory(projectDirectory); string versionTxtPath = Path.Combine(projectDirectory, TxtFileName); if (File.Exists(versionTxtPath)) { if (version.IsDefaultVersionTheOnlyPropertySet) { File.WriteAllLines( versionTxtPath, new[] { version.Version.Version.ToString(), version.Version.Prerelease }); return versionTxtPath; } else { // The file must be upgraded to use the more descriptive JSON format. File.Delete(versionTxtPath); } } string versionJsonPath = Path.Combine(projectDirectory, JsonFileName); var jsonContent = JsonConvert.SerializeObject(version, JsonSettings); File.WriteAllText(versionJsonPath, jsonContent); return versionJsonPath; }
public void Create(ContentItem contentItem, VersionOptions options) { _decoratedService.Create(contentItem, options); }
/// <summary> /// Gets the version options from HEAD and the working copy (if applicable), /// and tests their equality. /// </summary> /// <param name="repo">The repo to scan for version info.</param> /// <param name="repoRelativeProjectDirectory">The path to the directory of the project whose version is being queried, relative to the repo root.</param> /// <param name="committedVersion">Receives the version options from the HEAD commit.</param> /// <param name="workingCopyVersion">Receives the version options from the working copy, when applicable.</param> /// <returns><c>true</c> if <paramref name="committedVersion"/> and <paramref name="workingCopyVersion"/> are not equal.</returns> private static bool IsVersionFileChangedInWorkingCopy(Repository repo, string repoRelativeProjectDirectory, out VersionOptions committedVersion, out VersionOptions workingCopyVersion) { Requires.NotNull(repo, nameof(repo)); Commit headCommit = repo.Head.Commits.FirstOrDefault(); committedVersion = VersionFile.GetVersion(headCommit, repoRelativeProjectDirectory); if (!repo.Info.IsBare) { string fullDirectory = Path.Combine(repo.Info.WorkingDirectory, repoRelativeProjectDirectory ?? string.Empty); workingCopyVersion = VersionFile.GetVersion(fullDirectory); return !EqualityComparer<VersionOptions>.Default.Equals(workingCopyVersion, committedVersion); } workingCopyVersion = null; return false; }
public ObjectivePart Get(int id, VersionOptions versionOptions) { return(_contentManager.Get <ObjectivePart>(id, versionOptions)); }