public async Task ShouldDetectFileChanges()
{
using (var test = StartTest(TestData.TestRepoMasterCleanSynchronized))
{
var events = new RepositoryManagerEvents();
var listener = Substitute.For <IRepositoryManagerListener>();
listener.AttachListener(test.RepositoryManager, events);
await events.WaitForNotBusy();
listener.ClearReceivedCalls();
events.Reset();
var foobarTxt = test.Environment.RepositoryPath.Combine("foobar.txt");
foobarTxt.WriteAllText("foobar");
test.RepositoryManager.WaitForEvents();
await events.WaitForNotBusy();
var received = await ProcessEvents(events);
// we expect these events
AssertReceivedEvent(nameof(events.GitStatusUpdated), received);
AssertReceivedEvent(nameof(events.LocalBranchesUpdated), received);
AssertReceivedEvent(nameof(events.RemoteBranchesUpdated), received);
AssertReceivedEvent(nameof(events.CurrentBranchUpdated), received);
}
}
public async Task ShouldAddAndCommitAllFiles()
{
using (var test = StartTest(TestData.TestRepoMasterCleanSynchronized))
{
var events = new RepositoryManagerEvents();
var listener = Substitute.For <IRepositoryManagerListener>();
listener.AttachListener(test.RepositoryManager, events);
listener.ClearReceivedCalls();
var foobarTxt = test.Environment.RepositoryPath.Combine("foobar.txt");
foobarTxt.WriteAllText("foobar");
test.RepositoryManager.WaitForEvents();
await events.WaitForNotBusy();
listener.ClearReceivedCalls();
events.Reset();
await test.RepositoryManager.CommitAllFiles("IntegrationTest Commit", string.Empty).StartAsAsync();
test.RepositoryManager.WaitForEvents();
await events.WaitForNotBusy();
var received = await ProcessEvents(events);
// we expect these events
AssertReceivedEvent(nameof(events.GitStatusUpdated), received);
AssertReceivedEvent(nameof(events.LocalBranchesUpdated), received);
AssertReceivedEvent(nameof(events.RemoteBranchesUpdated), received);
AssertReceivedEvent(nameof(events.GitAheadBehindStatusUpdated), received);
AssertReceivedEvent(nameof(events.GitLogUpdated), received);
}
}
public async Task ShouldDetectChangesToRemotesWhenSwitchingBranches()
{
using (var test = StartTest(TestData.TestRepoMasterTwoRemotes))
{
var events = new RepositoryManagerEvents();
var listener = Substitute.For <IRepositoryManagerListener>();
listener.AttachListener(test.RepositoryManager, events);
listener.ClearReceivedCalls();
await test.RepositoryManager.CreateBranch("branch2", "another/master").StartAsAsync();
test.RepositoryManager.WaitForEvents();
await events.WaitForNotBusy();
var received = await ProcessEvents(events);
// we expect these events
AssertReceivedEvent(nameof(events.LocalBranchesUpdated), received);
AssertReceivedEvent(nameof(events.RemoteBranchesUpdated), received);
AssertReceivedEvent(nameof(events.GitLogUpdated), received);
AssertReceivedEvent(nameof(events.CurrentBranchUpdated), received);
// we don't expect these events
AssertDidNotReceiveEvent(nameof(events.GitStatusUpdated), received);
AssertDidNotReceiveEvent(nameof(events.GitAheadBehindStatusUpdated), received);
//AssertDidNotReceiveEvent(nameof(events.GitLocksUpdated), received);
listener.ClearReceivedCalls();
events.Reset();
await test.RepositoryManager.SwitchBranch("branch2").StartAsAsync();
test.RepositoryManager.WaitForEvents();
await events.WaitForNotBusy();
received = await ProcessEvents(events);
// we expect these events
AssertReceivedEvent(nameof(events.GitStatusUpdated), received);
AssertReceivedEvent(nameof(events.GitAheadBehindStatusUpdated), received);
AssertReceivedEvent(nameof(events.GitLogUpdated), received);
AssertReceivedEvent(nameof(events.CurrentBranchUpdated), received);
// we don't expect these events
AssertDidNotReceiveEvent(nameof(events.LocalBranchesUpdated), received);
AssertDidNotReceiveEvent(nameof(events.RemoteBranchesUpdated), received);
AssertDidNotReceiveEvent(nameof(events.GitLocksUpdated), received);
}
}
public async Task ShouldDetectChangesToRemotes()
{
using (var test = StartTest(TestData.TestRepoMasterCleanSynchronized))
{
var events = new RepositoryManagerEvents();
var listener = Substitute.For <IRepositoryManagerListener>();
listener.AttachListener(test.RepositoryManager, events);
listener.ClearReceivedCalls();
await test.RepositoryManager.RemoteRemove("origin").StartAsAsync();
test.RepositoryManager.WaitForEvents();
await events.WaitForNotBusy();
var received = await ProcessEvents(events);
// we expect these events
AssertReceivedEvent(nameof(events.LocalBranchesUpdated), received);
AssertReceivedEvent(nameof(events.RemoteBranchesUpdated), received);
AssertReceivedEvent(nameof(events.GitAheadBehindStatusUpdated), received);
AssertReceivedEvent(nameof(events.GitLogUpdated), received);
AssertReceivedEvent(nameof(events.CurrentBranchUpdated), received);
// we don't expect these events
AssertDidNotReceiveEvent(nameof(events.GitStatusUpdated), received);
//AssertDidNotReceiveEvent(nameof(events.GitLocksUpdated), received);
listener.ClearReceivedCalls();
events.Reset();
await test.RepositoryManager.RemoteAdd("origin", test.TestRepo.RepoPath.Parent.Combine("bare")).StartAsAsync();
test.RepositoryManager.WaitForEvents();
await events.WaitForNotBusy();
received = await ProcessEvents(events);
// we expect these events
AssertReceivedEvent(nameof(events.LocalBranchesUpdated), received);
AssertReceivedEvent(nameof(events.RemoteBranchesUpdated), received);
AssertReceivedEvent(nameof(events.GitAheadBehindStatusUpdated), received);
AssertReceivedEvent(nameof(events.GitLogUpdated), received);
AssertReceivedEvent(nameof(events.CurrentBranchUpdated), received);
// we don't expect these events
AssertDidNotReceiveEvent(nameof(events.GitStatusUpdated), received);
//AssertDidNotReceiveEvent(nameof(events.GitLocksUpdated), received);
}
}
public async Task ShouldDetectFileChanges()
{
Logger.Trace("Starting ShouldDetectFileChanges");
try
{
var repositoryManagerListener = Substitute.For <IRepositoryManagerListener>();
await Initialize(TestRepoMasterCleanSynchronized, initializeRepository : false,
onRepositoryManagerCreated : manager => {
repositoryManagerListener.AttachListener(manager, repositoryManagerEvents);
});
repositoryManagerEvents.CurrentBranchUpdated.WaitOne(Timeout).Should().BeTrue();
repositoryManagerEvents.LocalBranchesUpdated.WaitOne(Timeout).Should().BeTrue();
repositoryManagerEvents.RemoteBranchesUpdated.WaitOne(Timeout).Should().BeTrue();
repositoryManagerEvents.GitLogUpdated.WaitOne(Timeout).Should().BeTrue();
repositoryManagerEvents.GitAheadBehindStatusUpdated.WaitOne(Timeout).Should().BeTrue();
repositoryManagerEvents.IsBusy.WaitOne(Timeout).Should().BeTrue();
repositoryManagerEvents.IsNotBusy.WaitOne(Timeout).Should().BeTrue();
repositoryManagerListener.ClearReceivedCalls();
repositoryManagerEvents.Reset();
var foobarTxt = TestRepoMasterCleanSynchronized.Combine("foobar.txt");
foobarTxt.WriteAllText("foobar");
await TaskManager.Wait();
RepositoryManager.WaitForEvents();
repositoryManagerEvents.WaitForNotBusy();
repositoryManagerEvents.GitStatusUpdated.WaitOne(Timeout).Should().BeTrue();
repositoryManagerListener.Received().OnIsBusyChanged(Args.Bool);
repositoryManagerListener.DidNotReceive().CurrentBranchUpdated(Args.NullableConfigBranch, Args.NullableConfigRemote);
repositoryManagerListener.DidNotReceive().GitAheadBehindStatusUpdated(Args.GitAheadBehindStatus);
repositoryManagerListener.Received().GitStatusUpdated(Args.GitStatus);
repositoryManagerListener.DidNotReceive().GitLocksUpdated(Args.GitLocks);
repositoryManagerListener.DidNotReceive().GitLogUpdated(Args.GitLogs);
repositoryManagerListener.DidNotReceive().LocalBranchesUpdated(Args.LocalBranchDictionary);
repositoryManagerListener.DidNotReceive().RemoteBranchesUpdated(Args.RemoteDictionary, Args.RemoteBranchDictionary);
}
finally
{
Logger.Trace("Ending ShouldDetectFileChanges");
}
}
public async Task ShouldAddAndCommitFiles()
{
Stopwatch watch = null;
ILogging logger = null;
StartTest(out watch, out logger);
try
{
var repositoryManagerListener = Substitute.For <IRepositoryManagerListener>();
InitializePlatformAndEnvironment(TestRepoMasterCleanSynchronized,
onRepositoryManagerCreated: manager => {
repositoryManagerListener.AttachListener(manager, repositoryManagerEvents);
});
repositoryManagerListener.AssertDidNotReceiveAnyCalls();
var foobarTxt = TestRepoMasterCleanSynchronized.Combine("foobar.txt");
foobarTxt.WriteAllText("foobar");
StartTrackTime(watch, logger, "RepositoryManager.WaitForEvents()");
RepositoryManager.WaitForEvents();
StopTrackTimeAndLog(watch, logger);
StartTrackTime(watch, logger, "repositoryManagerEvents.WaitForNotBusy()");
await repositoryManagerEvents.WaitForNotBusy();
StopTrackTimeAndLog(watch, logger);
// we expect these events
await AssertReceivedEvent(nameof(repositoryManagerEvents.GitStatusUpdated), repositoryManagerEvents.GitStatusUpdated);
// we don't expect these events
await AssertDidNotReceiveEvent(nameof(repositoryManagerEvents.LocalBranchesUpdated), repositoryManagerEvents.LocalBranchesUpdated);
await AssertDidNotReceiveEvent(nameof(repositoryManagerEvents.RemoteBranchesUpdated), repositoryManagerEvents.RemoteBranchesUpdated);
await AssertDidNotReceiveEvent(nameof(repositoryManagerEvents.GitAheadBehindStatusUpdated), repositoryManagerEvents.GitAheadBehindStatusUpdated);
await AssertDidNotReceiveEvent(nameof(repositoryManagerEvents.GitLogUpdated), repositoryManagerEvents.GitLogUpdated);
await AssertDidNotReceiveEvent(nameof(repositoryManagerEvents.GitLocksUpdated), repositoryManagerEvents.GitLocksUpdated);
await AssertDidNotReceiveEvent(nameof(repositoryManagerEvents.CurrentBranchUpdated), repositoryManagerEvents.CurrentBranchUpdated);
repositoryManagerListener.ClearReceivedCalls();
repositoryManagerEvents.Reset();
var filesToCommit = new List <string> {
"foobar.txt"
};
var commitMessage = "IntegrationTest Commit";
var commitBody = string.Empty;
StartTrackTime(watch, logger, "CommitFiles");
await RepositoryManager.CommitFiles(filesToCommit, commitMessage, commitBody).StartAsAsync();
StopTrackTimeAndLog(watch, logger);
await TaskManager.Wait();
RepositoryManager.WaitForEvents();
await repositoryManagerEvents.WaitForNotBusy();
// we expect these events
await AssertReceivedEvent(nameof(repositoryManagerEvents.LocalBranchesUpdated), repositoryManagerEvents.LocalBranchesUpdated);
await AssertReceivedEvent(nameof(repositoryManagerEvents.RemoteBranchesUpdated), repositoryManagerEvents.RemoteBranchesUpdated);
await AssertReceivedEvent(nameof(repositoryManagerEvents.GitAheadBehindStatusUpdated), repositoryManagerEvents.GitAheadBehindStatusUpdated);
await AssertReceivedEvent(nameof(repositoryManagerEvents.GitLogUpdated), repositoryManagerEvents.GitLogUpdated);
await AssertReceivedEvent(nameof(repositoryManagerEvents.GitStatusUpdated), repositoryManagerEvents.GitStatusUpdated);
await AssertReceivedEvent(nameof(repositoryManagerEvents.CurrentBranchUpdated), repositoryManagerEvents.CurrentBranchUpdated);
// we don't expect these events
await AssertDidNotReceiveEvent(nameof(repositoryManagerEvents.GitLocksUpdated), repositoryManagerEvents.GitLocksUpdated);
}
finally
{
EndTest(logger);
}
}
public async Task ShouldDetectBranchCreate()
{
using (var test = StartTest(TestData.TestRepoMasterCleanSynchronized))
{
var events = new RepositoryManagerEvents();
var listener = Substitute.For <IRepositoryManagerListener>();
listener.AttachListener(test.RepositoryManager, events);
listener.ClearReceivedCalls();
{
// prepopulate repository info cache
var b = test.Repository.CurrentBranch;
test.RepositoryManager.WaitForEvents();
var received = await ProcessEvents(events);
AssertReceivedEvent(nameof(events.CurrentBranchUpdated), received);
listener.ClearReceivedCalls();
events.Reset();
}
{
var createdBranch1 = "feature/document2";
await test.RepositoryManager.CreateBranch(createdBranch1, "feature/document").StartAsAsync();
test.RepositoryManager.WaitForEvents();
await events.WaitForNotBusy();
var received = await ProcessEvents(events);
// we expect these events
AssertReceivedEvent(nameof(events.LocalBranchesUpdated), received);
AssertReceivedEvent(nameof(events.RemoteBranchesUpdated), received);
AssertReceivedEvent(nameof(events.GitAheadBehindStatusUpdated), received);
// we don't expect these events
// TODO: log should not be getting called, but it is because when branches get changed we're blindly calling log
//AssertDidNotReceiveEvent(events.GitLogUpdated, received);
AssertDidNotReceiveEvent(nameof(events.GitStatusUpdated), received);
AssertDidNotReceiveEvent(nameof(events.CurrentBranchUpdated), received);
//AssertDidNotReceiveEvent(nameof(events.GitLocksUpdated), received);
listener.ClearReceivedCalls();
events.Reset();
await test.RepositoryManager.CreateBranch("feature2/document2", "feature/document").StartAsAsync();
test.RepositoryManager.WaitForEvents();
await events.WaitForNotBusy();
received = await ProcessEvents(events);
// we expect these events
AssertReceivedEvent(nameof(events.LocalBranchesUpdated), received);
AssertReceivedEvent(nameof(events.RemoteBranchesUpdated), received);
AssertReceivedEvent(nameof(events.GitAheadBehindStatusUpdated), received);
// we don't expect these events
AssertDidNotReceiveEvent(nameof(events.GitStatusUpdated), received);
// TODO: log should not be getting called, but it is because when branches get changed we're blindly calling log
//AssertDidNotReceiveEvent(events.GitLogUpdated, received);
AssertDidNotReceiveEvent(nameof(events.CurrentBranchUpdated), received);
//AssertDidNotReceiveEvent(nameof(events.GitLocksUpdated), received);
}
}
}
public async Task ShouldAddAndCommitFiles()
{
await Initialize(TestRepoMasterCleanSynchronized);
var repositoryManagerListener = Substitute.For <IRepositoryManagerListener>();
repositoryManagerListener.AttachListener(RepositoryManager, repositoryManagerEvents);
var expectedAfterChanges = new GitStatus {
Behind = 1,
LocalBranch = "master",
RemoteBranch = "origin/master",
Entries =
new List <GitStatusEntry> {
new GitStatusEntry("Assets\\TestDocument.txt",
TestRepoMasterCleanSynchronized.Combine("Assets", "TestDocument.txt"),
"Assets\\TestDocument.txt", GitFileStatus.Modified),
new GitStatusEntry("foobar.txt", TestRepoMasterCleanSynchronized.Combine("foobar.txt"),
"foobar.txt", GitFileStatus.Untracked)
}
};
var result = new GitStatus();
RepositoryManager.OnStatusUpdated += status => { result = status; };
var foobarTxt = TestRepoMasterCleanSynchronized.Combine("foobar.txt");
foobarTxt.WriteAllText("foobar");
var testDocumentTxt = TestRepoMasterCleanSynchronized.Combine("Assets", "TestDocument.txt");
testDocumentTxt.WriteAllText("foobar");
await TaskManager.Wait();
WaitForNotBusy(repositoryManagerEvents, 1);
RepositoryManager.WaitForEvents();
WaitForNotBusy(repositoryManagerEvents, 1);
repositoryManagerListener.Received().OnStatusUpdate(Args.GitStatus);
repositoryManagerListener.DidNotReceive().OnActiveBranchChanged(Arg.Any <ConfigBranch?>());
repositoryManagerListener.DidNotReceive().OnActiveRemoteChanged(Arg.Any <ConfigRemote?>());
repositoryManagerListener.DidNotReceive().OnHeadChanged();
repositoryManagerListener.DidNotReceive().OnLocalBranchListChanged();
repositoryManagerListener.DidNotReceive().OnRemoteBranchListChanged();
repositoryManagerListener.ReceivedWithAnyArgs().OnIsBusyChanged(Args.Bool);
repositoryManagerListener.DidNotReceive().OnLocksUpdated(Args.EnumerableGitLock);
result.AssertEqual(expectedAfterChanges);
repositoryManagerListener.ClearReceivedCalls();
repositoryManagerEvents.Reset();
await RepositoryManager
.CommitFiles(new List <string>() { "Assets\\TestDocument.txt", "foobar.txt" }, "IntegrationTest Commit", string.Empty)
.StartAsAsync();
await TaskManager.Wait();
RepositoryManager.WaitForEvents();
WaitForNotBusy(repositoryManagerEvents, 1);
repositoryManagerListener.DidNotReceive().OnStatusUpdate(Args.GitStatus);
repositoryManagerListener.DidNotReceive().OnActiveBranchChanged(Arg.Any <ConfigBranch?>());
repositoryManagerListener.DidNotReceive().OnActiveRemoteChanged(Arg.Any <ConfigRemote?>());
repositoryManagerListener.DidNotReceive().OnHeadChanged();
repositoryManagerListener.DidNotReceive().OnLocalBranchListChanged();
repositoryManagerListener.DidNotReceive().OnRemoteBranchListChanged();
repositoryManagerListener.Received(2).OnIsBusyChanged(Args.Bool);
repositoryManagerListener.DidNotReceive().OnLocksUpdated(Args.EnumerableGitLock);
}
public async Task ShouldAddAndCommitFiles()
{
Stopwatch watch = null;
ILogging logger = null;
StartTest(out watch, out logger);
try
{
var repositoryManagerListener = Substitute.For <IRepositoryManagerListener>();
InitializePlatformAndEnvironment(TestRepoMasterCleanSynchronized,
onRepositoryManagerCreated: manager => {
repositoryManagerListener.AttachListener(manager, repositoryManagerEvents);
});
repositoryManagerListener.AssertDidNotReceiveAnyCalls();
var foobarTxt = TestRepoMasterCleanSynchronized.Combine("foobar.txt");
foobarTxt.WriteAllText("foobar");
var testDocumentTxt = TestRepoMasterCleanSynchronized.Combine("Assets", "TestDocument.txt");
testDocumentTxt.WriteAllText("foobar");
await TaskManager.Wait();
RepositoryManager.WaitForEvents();
repositoryManagerEvents.WaitForNotBusy();
repositoryManagerEvents.GitStatusUpdated.WaitOne(Timeout).Should().BeTrue();
repositoryManagerListener.Received().OnIsBusyChanged(Args.Bool);
repositoryManagerListener.DidNotReceive().CurrentBranchUpdated(Args.NullableConfigBranch, Args.NullableConfigRemote);
repositoryManagerListener.DidNotReceive().GitAheadBehindStatusUpdated(Args.GitAheadBehindStatus);
repositoryManagerListener.Received().GitStatusUpdated(Args.GitStatus);
repositoryManagerListener.DidNotReceive().GitLocksUpdated(Args.GitLocks);
repositoryManagerListener.DidNotReceive().GitLogUpdated(Args.GitLogs);
repositoryManagerListener.DidNotReceive().LocalBranchesUpdated(Args.LocalBranchDictionary);
repositoryManagerListener.DidNotReceive().RemoteBranchesUpdated(Args.RemoteDictionary, Args.RemoteBranchDictionary);
repositoryManagerListener.ClearReceivedCalls();
repositoryManagerEvents.Reset();
await RepositoryManager
.CommitFiles(new List <string> {
"Assets\\TestDocument.txt", "foobar.txt"
}, "IntegrationTest Commit", string.Empty)
.StartAsAsync();
await TaskManager.Wait();
RepositoryManager.WaitForEvents();
repositoryManagerEvents.WaitForNotBusy();
repositoryManagerEvents.LocalBranchesUpdated.WaitOne(Timeout).Should().BeTrue();
repositoryManagerEvents.GitStatusUpdated.WaitOne(Timeout).Should().BeTrue();
repositoryManagerEvents.GitLogUpdated.WaitOne(Timeout).Should().BeTrue();
repositoryManagerListener.Received().OnIsBusyChanged(Args.Bool);
repositoryManagerListener.Received().CurrentBranchUpdated(Args.NullableConfigBranch, Args.NullableConfigRemote);
repositoryManagerListener.Received().GitAheadBehindStatusUpdated(Args.GitAheadBehindStatus);
repositoryManagerListener.Received().GitStatusUpdated(Args.GitStatus);
repositoryManagerListener.DidNotReceive().GitLocksUpdated(Args.GitLocks);
repositoryManagerListener.Received().GitLogUpdated(Args.GitLogs);
repositoryManagerListener.Received().LocalBranchesUpdated(Args.LocalBranchDictionary);
repositoryManagerListener.Received().RemoteBranchesUpdated(Args.RemoteDictionary, Args.RemoteBranchDictionary);
}
finally
{
EndTest(logger);
}
}
