public async Task FailedGetRepoTargetReturnsFailure(
IGitRepository repo,
GitPatcherVersioning patcherVersioning,
CancellationToken cancel,
ResetToTarget sut)
{
sut.GetRepoTarget.Get(default !, default !).ReturnsForAnyArgs(GetResponse <RepoTarget> .Failure);
public GetResponse <ResetResults> Reset(
IGitRepository repo,
GitPatcherVersioning patcherVersioning,
CancellationToken cancel)
{
CheckoutRunnerBranch.Checkout(repo);
var targets = GetRepoTarget.Get(
repo,
patcherVersioning);
if (targets.Failed)
{
return(targets.BubbleFailure <ResetResults>());
}
var commit = RetrieveCommit.TryGet(
repo,
targets.Value,
patcherVersioning,
cancel);
if (commit.Failed)
{
return(commit.BubbleFailure <ResetResults>());
}
cancel.ThrowIfCancellationRequested();
_logger.Information("Checking out {TargetSha}", targets.Value.TargetSha);
repo.ResetHard(commit.Value);
return(new ResetResults(targets.Value, commit.Value.CommitMessage, commit.Value.CommitDate));
}
public GetResponse <ICommit> TryGet(
IGitRepository repo,
RepoTarget targets,
GitPatcherVersioning patcherVersioning,
CancellationToken cancel)
{
var commit = repo.TryGetCommit(targets.TargetSha, out var validSha);
if (!validSha)
{
return(GetResponse <ICommit> .Fail("Malformed sha string"));
}
cancel.ThrowIfCancellationRequested();
if (commit == null)
{
bool fetchIfMissing = ShouldFetchIfMissing.Should(patcherVersioning);
if (!fetchIfMissing)
{
return(GetResponse <ICommit> .Fail("Could not locate commit with given sha"));
}
repo.Fetch();
commit = repo.TryGetCommit(targets.TargetSha, out _);
if (commit == null)
{
return(GetResponse <ICommit> .Fail("Could not locate commit with given sha"));
}
}
return(GetResponse <ICommit> .Succeed(commit));
}
public async Task BranchNewContent()
{
using var repoPath = GetRepository(out var remote, out var local);
string tipSha;
string commitSha;
var clonePath = Path.Combine(repoPath.Dir.Path, "Clone");
using var clone = new Repository(Repository.Clone(remote, clonePath));
{
using var repo = new Repository(local);
tipSha = repo.Head.Tip.Sha;
commitSha = AddACommit(local).Sha;
repo.Head.Tip.Sha.Should().NotBeEquivalentTo(tipSha);
repo.Network.Push(repo.Branches[DefaultBranch]);
}
var versioning = new GitPatcherVersioning(PatcherVersioningEnum.Branch, DefaultBranch);
var resp = await GitPatcherRun.CheckoutRunnerRepository(
proj : ProjPath,
localRepoDir : clonePath,
patcherVersioning : versioning,
nugetVersioning : TypicalNugetVersioning(),
logger : null,
cancel : CancellationToken.None,
compile : false);
resp.IsHaltingError.Should().BeFalse();
resp.RunnableState.Succeeded.Should().BeTrue();
clone.Head.Tip.Sha.Should().BeEquivalentTo(commitSha);
clone.Head.FriendlyName.Should().BeEquivalentTo(GitPatcherRun.RunnerBranch);
clone.Branches[DefaultBranch].Tip.Sha.Should().BeEquivalentTo(tipSha);
}
public bool Should(GitPatcherVersioning patcherVersioning)
{
return(patcherVersioning.Versioning switch
{
PatcherVersioningEnum.Commit => true,
_ => false
});
public async Task BranchTargetJumpback()
{
using var repoPath = GetRepository(out var remote, out var local);
using var repo = new Repository(local);
var tipSha = repo.Head.Tip.Sha;
var jbName = "Jumpback";
var jbBranch = repo.CreateBranch(jbName);
repo.Branches.Update(
jbBranch,
b => b.Remote = repo.Network.Remotes.First().Name,
b => b.UpstreamBranch = jbBranch.CanonicalName);
repo.Network.Push(jbBranch);
var commit = AddACommit(local);
repo.Head.Tip.Sha.Should().NotBeEquivalentTo(tipSha);
var versioning = new GitPatcherVersioning(PatcherVersioningEnum.Branch, jbName);
var resp = await GitPatcherRun.CheckoutRunnerRepository(
proj : ProjPath,
localRepoDir : local,
patcherVersioning : versioning,
nugetVersioning : TypicalNugetVersioning(),
logger : null,
cancel : CancellationToken.None,
compile : false);
resp.IsHaltingError.Should().BeFalse();
resp.RunnableState.Succeeded.Should().BeTrue();
repo.Head.Tip.Sha.Should().BeEquivalentTo(tipSha);
repo.Head.FriendlyName.Should().BeEquivalentTo(GitPatcherRun.RunnerBranch);
repo.Branches[jbName].Tip.Sha.Should().BeEquivalentTo(tipSha);
repo.Branches[DefaultBranch].Tip.Sha.Should().BeEquivalentTo(commit.Sha);
}
public async Task TagTargetNewContent()
{
using var repoPath = GetRepository(out var remote, out var local);
var clonePath = Path.Combine(repoPath.Dir.Path, "Clone");
using var clone = new Repository(Repository.Clone(remote, clonePath));
var tagStr = "1.3.4";
string commitSha;
{
using var repo = new Repository(local);
AddACommit(local);
commitSha = repo.Head.Tip.Sha;
var tag = repo.Tags.Add(tagStr, commitSha);
repo.Network.Push(repo.Network.Remotes.First(), tag.CanonicalName);
}
var versioning = new GitPatcherVersioning(PatcherVersioningEnum.Tag, tagStr);
var resp = await GitPatcherRun.CheckoutRunnerRepository(
proj : ProjPath,
localRepoDir : clonePath,
patcherVersioning : versioning,
nugetVersioning : TypicalNugetVersioning(),
logger : null,
cancel : CancellationToken.None,
compile : false);
resp.IsHaltingError.Should().BeFalse();
resp.RunnableState.Succeeded.Should().BeTrue();
clone.Head.Tip.Sha.Should().BeEquivalentTo(commitSha);
clone.Head.FriendlyName.Should().BeEquivalentTo(GitPatcherRun.RunnerBranch);
}
public async Task TagTargetJumpback()
{
using var repoPath = GetRepository(out var remote, out var local);
var tag = "1.3.4";
using var repo = new Repository(local);
var tipSha = repo.Head.Tip.Sha;
repo.Tags.Add("1.3.4", tipSha);
AddACommit(local);
repo.Head.Tip.Sha.Should().NotBeEquivalentTo(tipSha);
var versioning = new GitPatcherVersioning(PatcherVersioningEnum.Tag, tag);
var resp = await GitPatcherRun.CheckoutRunnerRepository(
proj : ProjPath,
localRepoDir : local,
patcherVersioning : versioning,
nugetVersioning : TypicalNugetVersioning(),
logger : null,
cancel : CancellationToken.None,
compile : false);
resp.IsHaltingError.Should().BeFalse();
resp.RunnableState.Succeeded.Should().BeTrue();
repo.Head.Tip.Sha.Should().BeEquivalentTo(tipSha);
repo.Head.FriendlyName.Should().BeEquivalentTo(GitPatcherRun.RunnerBranch);
}
public async Task GetRepoTargetCalled(
IGitRepository repo,
GitPatcherVersioning patcherVersioning,
CancellationToken cancel,
ResetToTarget sut)
{
sut.Reset(repo, patcherVersioning, cancel);
sut.GetRepoTarget.Received(1).Get(repo, patcherVersioning);
}
public void FailIfNotValidSha(
[Frozen] IGitRepository repo,
ICommit commit,
RepoTarget targets,
GitPatcherVersioning patcherVersioning,
CancellationToken cancel,
RetrieveCommit sut)
{
repo.TryGetCommit(default !, out _).ReturnsForAnyArgs(x =>
public async Task CheckoutPassedToRunnerBranchCheckout(
IGitRepository repo,
GitPatcherVersioning patcherVersioning,
CancellationToken cancel,
ResetToTarget sut)
{
sut.Reset(repo, patcherVersioning, cancel);
sut.CheckoutRunnerBranch.Received(1).Checkout(repo);
}
public void PassesShaToTryGetCommit(
[Frozen] IGitRepository repo,
RepoTarget targets,
GitPatcherVersioning patcherVersioning,
CancellationToken cancel,
RetrieveCommit sut)
{
sut.TryGet(repo, targets, patcherVersioning, cancel);
repo.Received(1).TryGetCommit(targets.TargetSha, out Arg.Any <bool>());
}
public GetResponse <RepoTarget> Get(
IGitRepository repo,
GitPatcherVersioning patcherVersioning)
{
string?targetSha;
string?target;
switch (patcherVersioning.Versioning)
{
case PatcherVersioningEnum.Tag:
if (string.IsNullOrWhiteSpace(patcherVersioning.Target))
{
return(GetResponse <RepoTarget> .Fail("No tag selected"));
}
repo.Fetch();
if (!repo.TryGetTagSha(patcherVersioning.Target, out targetSha))
{
return(GetResponse <RepoTarget> .Fail("Could not locate tag"));
}
target = patcherVersioning.Target;
break;
case PatcherVersioningEnum.Commit:
targetSha = patcherVersioning.Target;
if (string.IsNullOrWhiteSpace(targetSha))
{
return(GetResponse <RepoTarget> .Fail("Could not locate commit"));
}
target = patcherVersioning.Target;
break;
case PatcherVersioningEnum.Branch:
if (string.IsNullOrWhiteSpace(patcherVersioning.Target))
{
return(GetResponse <RepoTarget> .Fail($"Target branch had no name."));
}
repo.Fetch();
if (!repo.TryGetBranch(patcherVersioning.Target, out var targetBranch))
{
return(GetResponse <RepoTarget> .Fail($"Could not locate branch: {patcherVersioning.Target}"));
}
targetSha = targetBranch.Tip.Sha;
target = patcherVersioning.Target;
break;
default:
throw new NotImplementedException();
}
return(GetResponse <RepoTarget> .Succeed(
new RepoTarget(targetSha, target)));
}
public async Task UnknownSha()
{
using var repoPath = GetRepository(out var remote, out var local);
var versioning = new GitPatcherVersioning(PatcherVersioningEnum.Commit, "46c207318c1531de7dc2f8e8c2a91aced183bc30");
var resp = await GitPatcherRun.CheckoutRunnerRepository(
proj : ProjPath,
localRepoDir : local,
patcherVersioning : versioning,
nugetVersioning : TypicalNugetVersioning(),
logger : null,
cancel : CancellationToken.None,
compile : false);
resp.IsHaltingError.Should().BeTrue();
resp.RunnableState.Succeeded.Should().BeFalse();
resp.RunnableState.Reason.Should().Contain("Could not locate commit with given sha");
}
public void BranchVersioningWithoutAutoReturnsCommit(
bool autoTag,
string tag,
string commit,
string branch)
{
var ret = GitPatcherVersioning.Factory(
PatcherVersioningEnum.Branch,
tag,
commit,
branch,
autoTag: autoTag,
autoBranch: false);
ret.Versioning.Should().Be(PatcherVersioningEnum.Commit);
ret.Target.Should().Be(commit);
}
public void BranchVersioningWithAutoForwardsBranch(
bool autoTag,
string tag,
string commit,
string branch)
{
var ret = GitPatcherVersioning.Factory(
PatcherVersioningEnum.Branch,
tag,
commit,
branch,
autoTag: autoTag,
autoBranch: true);
ret.Versioning.Should().Be(PatcherVersioningEnum.Branch);
ret.Target.Should().Be(branch);
}
public void TagVersioningWithAutoForwardsTag(
bool autoBranch,
string tag,
string commit,
string branch)
{
var ret = GitPatcherVersioning.Factory(
PatcherVersioningEnum.Tag,
tag,
commit,
branch,
autoTag: true,
autoBranch: autoBranch);
ret.Versioning.Should().Be(PatcherVersioningEnum.Tag);
ret.Target.Should().Be(tag);
}
public async Task MalformedSha()
{
using var repoPath = GetRepository(out var remote, out var local);
var versioning = new GitPatcherVersioning(PatcherVersioningEnum.Commit, "derp");
var resp = await GitPatcherRun.CheckoutRunnerRepository(
proj : ProjPath,
localRepoDir : local,
patcherVersioning : versioning,
nugetVersioning : TypicalNugetVersioning(),
logger : null,
cancel : CancellationToken.None,
compile : false);
resp.IsHaltingError.Should().BeTrue();
resp.RunnableState.Succeeded.Should().BeFalse();
resp.RunnableState.Reason.Should().Contain("Malformed sha string");
}
public GitPatcherTargetingVm(
ILockToCurrentVersioning lockToCurrentVersioning,
IDriverRepositoryPreparationFollower driverRepositoryPreparation)
{
var targetOriginBranchName = this.WhenAnyValue(x => x.TargetBranchName)
.Select(x => $"origin/{x}")
.Replay(1).RefCount();
// Set latest checkboxes to drive user input
driverRepositoryPreparation.DriverInfo
.FlowSwitch(this.WhenAnyValue(x => x.BranchFollowMain))
.Throttle(TimeSpan.FromMilliseconds(150), RxApp.MainThreadScheduler)
.Subscribe(state =>
{
if (state.RunnableState.Succeeded)
{
this.TargetBranchName = state.Item.MasterBranchName;
}
})
.DisposeWith(this);
Observable.CombineLatest(
driverRepositoryPreparation.DriverInfo,
targetOriginBranchName,
(Driver, TargetBranch) => (Driver, TargetBranch))
.FlowSwitch(
Observable.CombineLatest(
this.WhenAnyValue(x => x.BranchAutoUpdate),
this.WhenAnyValue(x => x.PatcherVersioning),
(autoBranch, versioning) => autoBranch && versioning == PatcherVersioningEnum.Branch))
.Throttle(TimeSpan.FromMilliseconds(150), RxApp.MainThreadScheduler)
.Subscribe(x =>
{
if (x.Driver.RunnableState.Succeeded &&
x.Driver.Item.BranchShas.TryGetValue(x.TargetBranch, out var sha))
{
this.TargetCommit = sha;
}
})
.DisposeWith(this);
driverRepositoryPreparation.DriverInfo
.Select(x =>
x.RunnableState.Failed ? default : x.Item.Tags.OrderByDescending(x => x.Index).FirstOrDefault())
.FlowSwitch(
Observable.CombineLatest(
this.WhenAnyValue(x => x.TagAutoUpdate),
lockToCurrentVersioning.WhenAnyValue(x => x.Lock),
this.WhenAnyValue(x => x.PatcherVersioning),
(autoTag, locked, versioning) => !locked && autoTag && versioning == PatcherVersioningEnum.Tag))
.Throttle(TimeSpan.FromMilliseconds(150), RxApp.MainThreadScheduler)
.Subscribe(x =>
{
this.TargetTag = x?.Name ?? string.Empty;
this.TargetCommit = x?.Sha ?? string.Empty;
})
.DisposeWith(this);
var targetBranchSha = Observable.CombineLatest(
driverRepositoryPreparation.DriverInfo
.Select(x => x.RunnableState.Failed ? default : x.Item.BranchShas),
targetOriginBranchName,
(dict, branch) => dict?.GetOrDefault(branch))
.Replay(1)
.RefCount();
var targetTag = Observable.CombineLatest(
driverRepositoryPreparation.DriverInfo
.Select(x => x.RunnableState.Failed ? default : x.Item.Tags),
this.WhenAnyValue(x => x.TargetTag),
(tags, tag) => tags?
.Where(tagItem => tagItem.Name == tag)
.FirstOrDefault())
.Replay(1)
.RefCount();
// Set up empty target autofill
// Usually for initial bootstrapping
Observable.CombineLatest(
targetBranchSha,
this.WhenAnyValue(x => x.TargetCommit),
(targetBranchSha, targetCommit) => (targetBranchSha, targetCommit))
.Throttle(TimeSpan.FromMilliseconds(200), RxApp.MainThreadScheduler)
.Where(x => x.targetBranchSha != null && TargetCommit.IsNullOrWhitespace())
.Subscribe(x => { this.TargetCommit = x.targetBranchSha ?? string.Empty; })
.DisposeWith(this);
Observable.CombineLatest(
targetTag,
this.WhenAnyValue(x => x.TargetCommit),
(targetTagSha, targetCommit) => (targetTagSha, targetCommit))
.Throttle(TimeSpan.FromMilliseconds(200), RxApp.MainThreadScheduler)
.Where(x => x.targetTagSha != null && TargetCommit.IsNullOrWhitespace())
.Subscribe(x => { this.TargetCommit = x.targetTagSha?.Sha ?? string.Empty; })
.DisposeWith(this);
// Set up update available systems
UpdateToBranchCommand = NoggogCommand.CreateFromObject(
objectSource: Observable.CombineLatest(
targetBranchSha,
this.WhenAnyValue(x => x.TargetCommit),
(branch, target) => (BranchSha: branch, Current: target)),
canExecute: o => o.BranchSha != null && o.BranchSha != o.Current,
extraCanExecute: this.WhenAnyValue(x => x.PatcherVersioning)
.Select(vers => vers == PatcherVersioningEnum.Branch),
execute: o => { this.TargetCommit = o.BranchSha !; },
this);
UpdateToTagCommand = NoggogCommand.CreateFromObject(
objectSource: Observable.CombineLatest(
targetTag,
Observable.CombineLatest(
this.WhenAnyValue(x => x.TargetCommit),
this.WhenAnyValue(x => x.TargetTag),
(TargetSha, TargetTag) => (TargetSha, TargetTag)),
(tag, target) => (TagSha: tag?.Sha, Tag: tag?.Name, Current: target)),
canExecute: o => (o.TagSha != null && o.Tag != null) &&
(o.TagSha != o.Current.TargetSha || o.Tag != o.Current.TargetTag),
extraCanExecute: this.WhenAnyValue(x => x.PatcherVersioning)
.Select(vers => vers == PatcherVersioningEnum.Tag),
execute: o =>
{
this.TargetTag = o.Tag !;
this.TargetCommit = o.TagSha !;
},
this);
ActivePatcherVersion = Observable.CombineLatest(
this.WhenAnyValue(x => x.PatcherVersioning),
this.WhenAnyValue(x => x.TargetTag),
this.WhenAnyValue(x => x.TargetCommit),
targetOriginBranchName,
Observable.CombineLatest(
this.WhenAnyValue(x => x.TagAutoUpdate),
lockToCurrentVersioning.WhenAnyValue(x => x.Lock),
(auto, locked) => !locked && auto),
Observable.CombineLatest(
this.WhenAnyValue(x => x.BranchAutoUpdate),
lockToCurrentVersioning.WhenAnyValue(x => x.Lock),
(auto, locked) => !locked && auto),
(versioning, tag, commit, branch, tagAuto, branchAuto) =>
{
return(GitPatcherVersioning.Factory(
versioning: versioning,
tag: tag,
commit: commit,
branch: branch,
autoTag: tagAuto,
autoBranch: branchAuto));
})
.DistinctUntilChanged()
.Replay(1)
.RefCount();
}
