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 ShouldDetectGitFetch()
{
using (var test = StartTest(TestData.TestRepoMasterCleanUnsynchronized))
{
var events = new RepositoryManagerEvents();
var listener = Substitute.For <IRepositoryManagerListener>();
listener.AttachListener(test.RepositoryManager, events);
listener.ClearReceivedCalls();
await test.RepositoryManager.Fetch("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.CurrentBranchUpdated), 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(nameof(events.GitLogUpdated), received);
//AssertDidNotReceiveEvent(nameof(events.GitAheadBehindStatusUpdated), received);
//AssertDidNotReceiveEvent(nameof(events.GitLocksUpdated), received);
}
}
public async Task ShouldDetectGitPull()
{
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.Pull("origin", "master").StartAsAsync();
//await TaskManager.Wait();
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.GitAheadBehindStatusUpdated), received);
AssertReceivedEvent(nameof(events.GitLogUpdated), received);
AssertReceivedEvent(nameof(events.CurrentBranchUpdated), received);
// we don't expect these events
// TODO: this should not happen but it's happening right now because when local branches get updated in the cache, remotes get updated too
//AssertDidNotReceiveEvent(nameof(events.RemoteBranchesUpdated), received);
//AssertDidNotReceiveEvent(nameof(events.GitLocksUpdated), received);
}
}
public async Task ShouldDetectBranchDelete()
{
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.DeleteBranch("feature/document", true).StartAsAsync();
//await TaskManager.Wait();
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);
AssertDidNotReceiveEvent(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 ShouldDetectFileChanges()
{
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");
await TaskManager.Wait();
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);
}
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 ShouldDetectFileChanges()
{
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.ClearReceivedCalls();
//repositoryManagerEvents.Reset();
repositoryManagerListener.AssertDidNotReceiveAnyCalls();
var foobarTxt = TestRepoMasterCleanSynchronized.Combine("foobar.txt");
foobarTxt.WriteAllText("foobar");
await TaskManager.Wait();
StartTrackTime(watch, logger, "RepositoryManager.WaitForEvents()");
RepositoryManager.WaitForEvents();
StopTrackTimeAndLog(watch, logger);
StartTrackTime(watch, logger, "repositoryManagerEvents.WaitForNotBusy()");
repositoryManagerEvents.WaitForNotBusy();
StopTrackTimeAndLog(watch, logger);
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
{
EndTest(logger);
}
}
