public void TestStashingAndUnstashing(RepoConfig repoCfg) { using var helper = Clone(repoCfg); var file = helper.GetPath(@"src\files\changingFile.txt"); XAssert.FileExists(file); TestOutput.WriteLine("Modifying file: " + file); File.AppendAllText(file, "hi"); var modifiedContent = File.ReadAllText(file); var result = helper.TrackPath(file); XAssert.AreEqual(PathExistence.ExistsAsFile, result.Existence); // stash changes, assert that 'Change' or 'Delete' USN entry was recorded helper.Git("stash"); helper.SnapCheckPoint(); XAssert.AreNotEqual(modifiedContent, File.ReadAllText(file)); helper.AssertDeleteOrChangeFile(file); // unfortunately, GVFS projection seems to change even though it probably shoudn't // helper.AssertNoChange(helper.GetGvfsProjectionFilePath()); // must re-track the same path because now it could be a different physical file helper.TrackPath(file); // unstash changes, assert that 'Change' or 'Delete' USN entry was recorded and that GVFS projection hasn't changed helper.Git("stash pop"); helper.SnapCheckPoint(); XAssert.AreEqual(modifiedContent, File.ReadAllText(file)); helper.AssertDeleteOrChangeFile(file); // unfortunately, GVFS projection seems to change even though it probably shouldn't // helper.AssertNoChange(helper.GetGvfsProjectionFilePath()); }
public void ChangeFile(RepoConfig repoCfg) { using var helper = Clone(repoCfg); // track an existing file var file = helper.GetPath(@"src\files\changingFile.txt"); XAssert.FileExists(file); var oldContent = File.ReadAllText(file); helper.TrackPath(file); // switch to a new branch where that file is modified using var reseter = helper.GitCheckout("changingFile1"); // snap USN entries before doing any checks (because they can modify the journal too) helper.SnapCheckPoint(); // assert that the file exists and has different content in the new branch XAssert.FileExists(file); XAssert.AreNotEqual(oldContent, File.ReadAllText(file)); // assert that the journal recorded a change // (it doesn't matter to us whether that change is 'Delete' or 'Change') helper.AssertDeleteOrChangeFile(file); }
string CalcTargetBranch() { var repository = Branch.Repository; RepoConfig repoConfig = repository.RepoConfig; return(repoConfig?.TargetBranch); }
public void TestAbsentFileAndDir(RepoConfig repoCfg) { using var helper = Clone(repoCfg); // track a file that doesn't exist var dir = helper.GetPath(@"src\files"); var absentDir = helper.GetPath(@"src\files\newSubfolder"); var absentFile = helper.GetPath(@"src\files\newSubfolder\newSubfolderFile.txt"); var dirResult = helper.TrackDir(dir); var absentDirResult = helper.TrackDir(absentDir); var absentFileResult = helper.TrackPath(absentFile); XAssert.AreEqual(PathExistence.ExistsAsDirectory, dirResult.Existence); XAssert.AreEqual(PathExistence.Nonexistent, absentDirResult.Existence); XAssert.AreEqual(PathExistence.Nonexistent, absentFileResult.Existence); // switch to a new branch where that file does exist using var reseter = helper.GitCheckout("newFileInNewSubfolder"); // immediately snap changes helper.SnapCheckPoint(); XAssert.FileExists(absentFile); XAssert.DirectoryExists(absentDir); // assert directory membership changes helper.AssertAnyChange(dir, PathChanges.MembershipChanged); helper.AssertAnyChange(absentDir, PathChanges.NewlyPresentAsDirectory); helper.AssertAnyChange(absentFile, PathChanges.NewlyPresentAsFile); }
public void TestFileBecomesFolder(RepoConfig repoCfg) { using var helper = Clone(repoCfg); // track a folder and a file var dir = helper.GetPath(@"src\files\subfolder"); var file = helper.GetPath(@"src\files\subfolder\newFile.txt"); var dirResult = helper.TrackDir(dir); var fileResult = helper.TrackPath(file); XAssert.AreEqual(PathExistence.ExistsAsDirectory, dirResult.Existence); XAssert.AreEqual(PathExistence.ExistsAsFile, fileResult.Existence); // switch to a new branch where that file is now a folder using var reseter = helper.GitCheckout("fileBecomesFolder"); // immediately snap changes helper.SnapCheckPoint(); XAssert.DirectoryExists(file); // assert directory membership changes helper.AssertAnyChange(dir, PathChanges.MembershipChanged); helper.AssertAnyChange(file, PathChanges.Removed); }
public void TestFolderBecomesFile(RepoConfig repoCfg) { using var helper = Clone(repoCfg); // track two directories var dir = helper.GetPath(@"src\files"); var subdir = helper.GetPath(@"src\files\subfolder"); var dirResult = helper.TrackDir(dir); var subdirResult = helper.TrackDir(subdir); XAssert.AreEqual(PathExistence.ExistsAsDirectory, dirResult.Existence); XAssert.AreEqual(PathExistence.ExistsAsDirectory, subdirResult.Existence); // switch to a new branch where the subdirectory is now a file using var reseter = helper.GitCheckout("folderBecomesFile"); // immediately snap changes helper.SnapCheckPoint(); XAssert.FileExists(subdir); // assert directory membership changes helper.AssertAnyChange(dir, PathChanges.MembershipChanged); helper.AssertAnyChange(subdir, PathChanges.Removed); }
public static RepoVersion Build(Patchalyzer patchalyzer, SemVersion version, string path, string name, string changelog = "", long releaseDate = -1) { RepoConfig config = patchalyzer.GetRepoConfig(); string repoPath = patchalyzer.GetRepoPath(); // If releaseDate is missing then set it to the current time. if (releaseDate == -1) { releaseDate = DateTimeOffset.Now.ToUnixTimeSeconds(); } RepoVersion repoVersion = new RepoVersion { Name = name, ReleaseDate = releaseDate, Changelog = changelog }; bool isUpdate = false; // Check if a previous version exists if (config.LatestVersion != null && config.Versions.ContainsKey(config.LatestVersion)) { SemVersion latestVersion; if (SemVersion.TryParse(config.LatestVersion, out latestVersion)) { isUpdate = (latestVersion < version); } } repoVersion.Files = isUpdate ? AddFiles(repoPath, version, path, config.LatestVersion, config.Versions[config.LatestVersion]) : AddFiles(repoPath, version, path); repoVersion.DeletedFiles = isUpdate ? GetDeletedFiles(repoVersion.Files, config.Versions[config.LatestVersion].Files) : new List <string>(); return(repoVersion); }
private async Task <WebhookResponse> HandlePushOnPr(PushEvent payload, RepoConfig config) { var owner = payload.Repository.Owner.Login; var repo = payload.Repository.Name; var sha = payload.After; var branch = payload.Ref; var extraLogData = new { owner, repo, branch, sha }; var strippedBranchName = branch.Substring("refs/heads/".Length); var mergeRequest = await mergeRequestRepository.GetByBranchName(owner, repo, strippedBranchName); if (mergeRequest == null) { logger.WithExtraData(extraLogData).Information("Push on branch, does not exist in Miro DB, ignoring"); return(new WebhookResponse(false, "Push on branch, does not exist in Miro DB, ignoring")); } logger.WithMergeRequestData(mergeRequest).Information($"Push on branch found in DB, Clearing status checks and updating sha"); var updatedMergeRequest = await mergeRequestRepository.UpdateShaAndClearStatusChecks(mergeRequest.Owner, mergeRequest.Repo, mergeRequest.PrId, sha); if (config.IsWhitelistStrict() && updatedMergeRequest.ReceivedMergeCommand) { logger.WithMergeRequestData(updatedMergeRequest).Information("Repository has a whitelist-strict merge policy, resolving miro check on PR"); await miroMergeCheck.ResolveMiroMergeCheck(updatedMergeRequest); } return(new WebhookResponse(true, $"Push on branch is a known PR, updated sha to {sha} and cleared status checks")); }
public void ChangeFileWithMaterialization(RepoConfig repoCfg) { using var helper = Clone(repoCfg); // track an existing file var file = helper.GetPath(@"src\files\changingFile.txt"); var result = helper.TrackPath(file); XAssert.AreEqual(PathExistence.ExistsAsFile, result.Existence); var oldContent = File.ReadAllText(file); // switch to a new branch where that file is modified using var reseter = helper.GitCheckout("changingFile1"); // materialize the file (by probing it) before snapping USN entries helper.AssertFileOnDisk(file); helper.SnapCheckPoint(); // assert that the file exists and has different content in the new branch XAssert.FileExists(file); XAssert.AreNotEqual(oldContent, File.ReadAllText(file)); // assert that the journal recorded a change // (it doesn't matter to us whether that change is 'Delete' or 'Change') helper.AssertDeleteOrChangeFile(file); }
static void Main() { UnitOfWork.Configure(RepoConfig.GetConfiguration()); ObjectFactory.Configure(c => c.AddRegistry <DefaultRegistry>()); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1()); }
public void BuildTab(TabControl reposCatalogs, SelectRepo onSelectRepoEvent, RepoConfig repo) { var newTab = serviceProvider.GetService <TabReposControl>(); newTab.RepoConfiguration = repo; newTab.BackColor = Color.White; reposCatalogs.Controls.Add(newTab); CheckForGitRepo(newTab, onSelectRepoEvent); }
public void BuildTab(TabControl reposCatalogs, SelectRepo onSelectRepoEvent, string repoPath) { if (!Directory.Exists(repoPath)) { MessageBox.Show($"Path {repoPath} is not valid.", "Invalid repo path", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } var config = new RepoConfig { GitLookerPath = repoPath }; appConfiguration.Add(config); BuildTab(reposCatalogs, onSelectRepoEvent, config); }
/// <summary> /// Create a new Patchalyzer repo. /// </summary> /// <param name="repoPath">Path to create the repository in.</param> /// <param name="projectName">Name of the project.</param> /// <returns>The newly created Patchalyzer project.</returns> public static Patchalyzer InitRepo(string repoPath, string projectName) { // If the repo already exists then return that if (File.Exists(Path.Combine(Path.GetFullPath(repoPath), "patchalyzer.json"))) { return(new Patchalyzer(repoPath)); } RepoConfig config = new RepoConfig { Name = projectName, ConfigVersion = 1 }; return(new Patchalyzer(repoPath, config)); }
public GitJournalHelper Clone(RepoConfig cfg) { bool useGvfs = cfg.RepoKind == RepoKind.Gvfs; var helper = cfg.RepoInit == RepoInit.Clone ? GitJournalHelper.Clone(TestOutput, useGvfs) : GitJournalHelper.InitializeWithExistingRepo(TestOutput, GitRepoLocation(useGvfs)); if (useGvfs) { // tracking GVFS_projection file so that we can assert that this file indeed changed // whenever the actual file changes are not yet reflected in the filesystem helper.TrackGvfsProjectionFile(); } return(helper); }
public void EditFile(RepoConfig repoCfg) { using var helper = Clone(repoCfg); // track an existing file var filePath = helper.GetPath(@"src\files\changingFile.txt"); var result = helper.TrackPath(filePath); XAssert.AreEqual(PathExistence.ExistsAsFile, result.Existence); // modify that file File.AppendAllText(filePath, "new content"); // snap changes and assert that a 'ChangeFile' USN entry was recorded helper.SnapCheckPoint(); helper.AssertChangeFile(filePath); }
public void CreateFile(RepoConfig repoCfg) { using var helper = Clone(repoCfg); // track an absent file var filePath = helper.GetPath("a.txt"); var result = helper.TrackPath(filePath); XAssert.AreEqual(PathExistence.Nonexistent, result.Existence); // create that file File.WriteAllText(filePath, "hi"); // snap entries and assert that a 'CreateFile' entry is found helper.SnapCheckPoint(); helper.AssertCreateFile(filePath); }
private async Task <bool> UpdateNextPrByStrategy(PushEvent payload, RepoConfig repoConfig) { var owner = payload.Repository.Owner.Login; var repo = payload.Repository.Name; logger.WithExtraData(new { owner, repo, strategy = repoConfig.UpdateBranchStrategy }).Information("Updating next PR by strategy"); List <MergeRequest> prsToUpdate = null; switch (repoConfig.UpdateBranchStrategy) { case "oldest": var singlePr = await mergeRequestRepository.GetOldestPr(owner, repo); if (singlePr != null) { prsToUpdate = new List <MergeRequest> { singlePr } } ; break; case "all": var allPrs = await mergeRequestRepository.Get(owner, repo); if (allPrs != null && allPrs.Any()) { prsToUpdate = allPrs.Where(x => x.ReceivedMergeCommand).ToList(); } break; case "none": default: break; } if (prsToUpdate == null || !prsToUpdate.Any()) { logger.WithExtraData(new { owner, repo }).Warning($"Could not find next PRs to update based on after PR was merged"); return(false); } var tasks = prsToUpdate.Select(pr => UpdateSinglePr(pr, repoConfig)); var completions = await Task.WhenAll(tasks); return(completions.Any(x => x)); }
public Task <RepoConfig> Update(RepoConfig config) { config.UpdatedAt = DateTime.UtcNow; var options = new FindOneAndUpdateOptions <RepoConfig> { IsUpsert = true }; var update = Builders <RepoConfig> .Update .Set(r => r.UpdatedAt, DateTime.UtcNow) .Set(r => r.DeleteAfterMerge, config.DeleteAfterMerge) .Set(r => r.MergePolicy, config.MergePolicy) .Set(r => r.UpdateBranchStrategy, config.UpdateBranchStrategy) .Set(r => r.DefaultBranch, config.DefaultBranch); return(collection.FindOneAndUpdateAsync <RepoConfig>(r => r.Owner == config.Owner && r.Repo == config.Repo, update, options)); }
public void DeleteFile(RepoConfig repoCfg) { using var helper = Clone(repoCfg); // track an existing file var filePath = helper.GetPath(@"src\files\changingFile.txt"); var result = helper.TrackPath(filePath); XAssert.AreEqual(PathExistence.ExistsAsFile, result.Existence); // delete that file File.Delete(filePath); // snap changes and assert that a 'DeleteFile' USN entry was recorded helper.SnapCheckPoint(); helper.AssertDeleteFile(filePath); XAssert.FileDoesNotExist(filePath); }
void GenerateRepoConfig(string branch, string taskName, string watchTaskName, string defaultService, bool allowTesting = false, string[] testConfigs = null) { RepoConfig config = new RepoConfig() { Name = branch, FarmTaskName = watchTaskName, FarmSyncTaskName = taskName, DefaultServiceName = defaultService, SupportsTesting = allowTesting, }; SharpSerializerXmlSettings settings = new SharpSerializerXmlSettings(); settings.IncludeAssemblyVersionInTypeName = false; settings.IncludePublicKeyTokenInTypeName = false; SharpSerializer serializer = new SharpSerializer(settings); serializer.Serialize(config, @"z:\gitconfig.config"); }
public void TestDirMembership(RepoConfig repoCfg) { using var helper = Clone(repoCfg); // track a file that doesn't exist var dir = helper.GetPath(@"src\files\subfolder"); var result = helper.TrackDir(dir); XAssert.AreEqual(PathExistence.ExistsAsDirectory, result.Existence); // switch to a new branch where that file does exist using var reseter = helper.GitCheckout("newFileInSubfolder"); // immediately snap changes helper.SnapCheckPoint(); // assert directory membership changes helper.AssertAnyChange(dir, PathChanges.MembershipChanged); }
private async Task <bool> UpdateSinglePr(MergeRequest pullRequest, RepoConfig config) { var branch = pullRequest.Branch; var prId = pullRequest.PrId; logger.WithMergeRequestData(pullRequest).Information($"updating branch on next PullRequest"); try { await prUpdater.UpdateBranch(pullRequest.Owner, pullRequest.Repo, branch); return(true); } catch (Exception e) { logger.WithMergeRequestData(pullRequest).Warning(e, "Unable to update branch on next PR"); return(false); } }
public void NewFileWhenParentFolderIsNotMaterialzedBeforeOperation(RepoConfig repoCfg) { using var helper = Clone(repoCfg); // track a file that doesn't exist var file = helper.GetPath(@"src\files\subfolder\newfile2.txt"); var result = helper.TrackPath(file); XAssert.AreEqual(PathExistence.Nonexistent, result.Existence); // switch to a new branch where that file does exist using var reseter = helper.GitCheckout("newFileInSubfolder"); // immediately snap changes helper.SnapCheckPoint(); // assert that 'CreateFile' USN entry was recorded helper.AssertCreateFile(file); XAssert.FileExists(file); }
public void ChangeFileNoMaterialization(RepoConfig repoCfg) { using var helper = Clone(repoCfg); // track an existing file var file = helper.GetPath(@"src\files\changingFile.txt"); var result = helper.TrackPath(file); XAssert.AreEqual(PathExistence.ExistsAsFile, result.Existence); // switch to a new branch where that file is modified using var reseter = helper.GitCheckout("changingFile1"); // immediately snap changes helper.SnapCheckPoint(); // assert that the journal recorded a change // (it doesn't matter to us whether that change is 'Delete' or 'Change') helper.AssertDeleteOrChangeFile(file); }
public void NewFileWhenParentFolderIsMaterialzedBeforeOperation(RepoConfig repoCfg) { var helper = Clone(repoCfg); // track a file that doesn't exist var file = helper.GetPath(@"src\files\subfolder\newfile.txt"); var file2 = helper.GetPath(@"src\files\subfolder\newfile2.txt"); helper.TrackPath(file); helper.TrackPath(file2); // materialize files before git checkout helper.AssertFileOnDisk(file); helper.AssertFileOnDisk(file2, expectExists: false); using var reseter = helper.GitCheckout("newFileInSubfolder"); // snap changes helper.SnapCheckPoint(); helper.AssertCreateFile(file2); XAssert.FileExists(file2); }
public void NewFileWhenParentFolderIsMaterialzedAfterOperation(RepoConfig repoCfg) { using (var helper = Clone(repoCfg)) { // track one existing and one absent file var file = helper.GetPath(@"src\files\subfolder\newfile.txt"); var file2 = helper.GetPath(@"src\files\subfolder\newfile2.txt"); var existingFileResult = helper.TrackPath(file); var absentFileResult = helper.TrackPath(file2); XAssert.AreEqual(PathExistence.ExistsAsFile, existingFileResult.Existence); XAssert.AreEqual(PathExistence.Nonexistent, absentFileResult.Existence); // switch to a new branch where absent file exists using var reseter = helper.GitCheckout("newFileInSubfolder"); // materialize files helper.AssertFileOnDisk(file); helper.AssertFileOnDisk(file2); // the USN journal must be up to date at this point because of the previous materialization helper.SnapCheckPoint(); helper.AssertCreateFile(file2); } }
public JsonRepository(RepoConfig config) { path = config.path; }
public Task Create(RepoConfig config) { return(collection.InsertOneAsync(config)); }
private void LoadRepo(string repoPath, RepoConfig repoConfig) { RepoPath = repoPath; Config = repoConfig; }
/// <summary> /// Load an existing Patchalyzer project from an already loaded RepoConfig instance. /// </summary> /// <param name="repoPath">Path to the repository</param> /// <param name="repoConfig">Instance of the RepoConfig</param> public Patchalyzer(string repoPath, RepoConfig repoConfig) { LoadRepo(repoPath, repoConfig); }