public async Task ShouldDetectFileChanges()
{
Stopwatch watch = null;
ILogging logger = null;
StartTest(out watch, out logger);
try
{
var repositoryManagerListener = Substitute.For <IRepositoryManagerListener>();
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();
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);
}
}
public async Task ShouldDetectFileChanges()
{
await Initialize(TestRepoMasterCleanSynchronized);
var managerAutoResetEvent = new RepositoryManagerAutoResetEvent();
var repositoryManagerListener = Substitute.For <IRepositoryManagerListener>();
repositoryManagerListener.AttachListener(RepositoryManager, managerAutoResetEvent);
var expected = new GitStatus {
Behind = 1,
LocalBranch = "master",
RemoteBranch = "origin/master",
Entries =
new List <GitStatusEntry> {
new GitStatusEntry("foobar.txt", TestRepoMasterCleanSynchronized.Combine("foobar.txt"),
"foobar.txt", GitFileStatus.Untracked)
}
};
var result = new GitStatus();
RepositoryManager.OnRepositoryChanged += status => { result = status; };
Logger.Trace("Issuing Changes");
var foobarTxt = TestRepoMasterCleanSynchronized.Combine("foobar.txt");
foobarTxt.WriteAllText("foobar");
await TaskManager.Wait();
// give the fs watcher a bit of time to catch up
await TaskEx.Delay(200);
await TaskManager.Wait();
managerAutoResetEvent.OnRepositoryChanged.WaitOne(TimeSpan.FromSeconds(2)).Should().BeTrue();
Logger.Trace("Continue test");
repositoryManagerListener.Received().OnRepositoryChanged(Args.GitStatus);
result.AssertEqual(expected);
repositoryManagerListener.ReceivedWithAnyArgs().OnIsBusyChanged(Args.Bool);
repositoryManagerListener.DidNotReceive().OnActiveBranchChanged();
repositoryManagerListener.DidNotReceive().OnActiveRemoteChanged();
repositoryManagerListener.DidNotReceive().OnHeadChanged();
repositoryManagerListener.DidNotReceive().OnLocalBranchListChanged();
repositoryManagerListener.DidNotReceive().OnRemoteBranchListChanged();
repositoryManagerListener.DidNotReceive().OnRemoteOrTrackingChanged();
repositoryManagerListener.DidNotReceive().OnLocksUpdated(Args.EnumerableGitLock);
}
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 ShouldDetectFileChanges()
{
await Initialize(TestRepoMasterCleanSynchronized);
using (var repositoryWatcher = CreateRepositoryWatcher(TestRepoMasterCleanSynchronized))
{
var watcherAutoResetEvent = new RepositoryWatcherAutoResetEvent();
var repositoryWatcherListener = Substitute.For <IRepositoryWatcherListener>();
repositoryWatcherListener.AttachListener(repositoryWatcher, watcherAutoResetEvent);
repositoryWatcher.Initialize();
repositoryWatcher.Start();
try
{
var foobarTxt = TestRepoMasterCleanSynchronized.Combine("foobar.txt");
Logger.Trace("Issuing Changes");
foobarTxt.WriteAllText("foobar");
await TaskManager.Wait();
watcherAutoResetEvent.IndexChanged.WaitOne(TimeSpan.FromSeconds(2)).Should().BeTrue();
watcherAutoResetEvent.RepositoryChanged.WaitOne(TimeSpan.FromSeconds(2)).Should().BeTrue();
Logger.Trace("Continue test");
repositoryWatcherListener.DidNotReceive().ConfigChanged();
repositoryWatcherListener.DidNotReceive().HeadChanged();
repositoryWatcherListener.Received().IndexChanged();
repositoryWatcherListener.DidNotReceive().LocalBranchCreated(Args.String);
repositoryWatcherListener.DidNotReceive().LocalBranchDeleted(Args.String);
repositoryWatcherListener.DidNotReceive().LocalBranchChanged(Args.String);
repositoryWatcherListener.DidNotReceive().RemoteBranchChanged(Args.String, Args.String);
repositoryWatcherListener.DidNotReceive().RemoteBranchCreated(Args.String, Args.String);
repositoryWatcherListener.DidNotReceive().RemoteBranchDeleted(Args.String, Args.String);
repositoryWatcherListener.Received().RepositoryChanged();
}
finally
{
repositoryWatcher.Stop();
}
}
}
public async Task ShouldDetectFileChanges()
{
await Initialize(TestRepoMasterCleanSynchronized);
var repositoryManagerListener = Substitute.For <IRepositoryManagerListener>();
repositoryManagerListener.AttachListener(RepositoryManager, repositoryManagerEvents);
var expected = new GitStatus {
Behind = 1,
LocalBranch = "master",
RemoteBranch = "origin/master",
Entries =
new List <GitStatusEntry> {
new GitStatusEntry("foobar.txt", TestRepoMasterCleanSynchronized.Combine("foobar.txt"),
"foobar.txt", GitFileStatus.Untracked)
}
};
var result = new GitStatus();
Environment.Repository.OnStatusUpdated += status => { result = status; };
var foobarTxt = TestRepoMasterCleanSynchronized.Combine("foobar.txt");
foobarTxt.WriteAllText("foobar");
await TaskManager.Wait();
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.Received().OnIsBusyChanged(Args.Bool);
repositoryManagerListener.DidNotReceive().OnLocksUpdated(Args.EnumerableGitLock);
result.AssertEqual(expected);
}
public async Task ShouldAddAndCommitAllFiles()
{
Logger.Trace("Starting ShouldAddAndCommitAllFiles");
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");
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
.CommitAllFiles("IntegrationTest Commit", string.Empty)
.StartAsAsync();
await TaskManager.Wait();
RepositoryManager.WaitForEvents();
repositoryManagerEvents.WaitForNotBusy();
repositoryManagerEvents.GitStatusUpdated.WaitOne(Timeout).Should().BeTrue();
repositoryManagerEvents.GitStatusUpdated.WaitOne(Timeout).Should().BeTrue();
repositoryManagerEvents.LocalBranchesUpdated.WaitOne(Timeout).Should().BeTrue();
repositoryManagerEvents.GitLogUpdated.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.Received().GitLogUpdated(Args.GitLogs);
repositoryManagerListener.Received().LocalBranchesUpdated(Args.LocalBranchDictionary);
repositoryManagerListener.DidNotReceive().RemoteBranchesUpdated(Args.RemoteDictionary, Args.RemoteBranchDictionary);
}
finally
{
Logger.Trace("Ending ShouldAddAndCommitAllFiles");
}
}
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 ShouldDetectFileChangesAndCommit()
{
Logger.Trace("Starting ShouldDetectFileChangesAndCommit");
try
{
InitializePlatformAndEnvironment(TestRepoMasterCleanSynchronized);
using (var repositoryWatcher = CreateRepositoryWatcher(TestRepoMasterCleanSynchronized))
{
var watcherAutoResetEvent = new RepositoryWatcherAutoResetEvent();
var repositoryWatcherListener = Substitute.For <IRepositoryWatcherListener>();
repositoryWatcherListener.AttachListener(repositoryWatcher, watcherAutoResetEvent);
repositoryWatcher.Initialize();
repositoryWatcher.Start();
repositoryWatcher.Stop();
try
{
var foobarTxt = TestRepoMasterCleanSynchronized.Combine("foobar.txt");
Logger.Trace("Issuing Changes");
foobarTxt.WriteAllText("foobar");
await TaskManager.Wait();
Logger.Trace("Continue test");
repositoryWatcher.Start();
watcherAutoResetEvent.RepositoryChanged.WaitOne(TimeSpan.FromSeconds(2)).Should().BeTrue();
watcherAutoResetEvent.Reset();
repositoryWatcherListener.DidNotReceive().HeadChanged();
repositoryWatcherListener.DidNotReceive().ConfigChanged();
repositoryWatcherListener.DidNotReceive().RepositoryCommitted();
repositoryWatcherListener.DidNotReceive().IndexChanged();
repositoryWatcherListener.Received().RepositoryChanged();
repositoryWatcherListener.DidNotReceive().LocalBranchesChanged();
repositoryWatcherListener.DidNotReceive().RemoteBranchesChanged();
repositoryWatcherListener.ClearReceivedCalls();
repositoryWatcher.Stop();
Logger.Trace("Issuing Command");
await GitClient.AddAll().StartAsAsync();
Logger.Trace("Completed Command");
repositoryWatcher.Start();
watcherAutoResetEvent.IndexChanged.WaitOne(TimeSpan.FromSeconds(2)).Should().BeTrue();
watcherAutoResetEvent.Reset();
repositoryWatcherListener.DidNotReceive().HeadChanged();
repositoryWatcherListener.DidNotReceive().ConfigChanged();
repositoryWatcherListener.DidNotReceive().RepositoryCommitted();
repositoryWatcherListener.Received(1).IndexChanged();
repositoryWatcherListener.DidNotReceive().RepositoryChanged();
repositoryWatcherListener.DidNotReceive().LocalBranchesChanged();
repositoryWatcherListener.DidNotReceive().RemoteBranchesChanged();
repositoryWatcherListener.ClearReceivedCalls();
repositoryWatcher.Stop();
Logger.Trace("Issuing Command");
await GitClient.Commit("Test Commit", string.Empty).StartAsAsync();
Logger.Trace("Completed Command");
repositoryWatcher.Start();
watcherAutoResetEvent.RepositoryCommitted.WaitOne(TimeSpan.FromSeconds(2)).Should().BeTrue();
watcherAutoResetEvent.IndexChanged.WaitOne(TimeSpan.FromSeconds(2)).Should().BeTrue();
watcherAutoResetEvent.Reset();
repositoryWatcherListener.DidNotReceive().HeadChanged();
repositoryWatcherListener.DidNotReceive().ConfigChanged();
repositoryWatcherListener.Received(1).RepositoryCommitted();
repositoryWatcherListener.Received(1).IndexChanged();
repositoryWatcherListener.DidNotReceive().RepositoryChanged();
repositoryWatcherListener.Received(1).LocalBranchesChanged();
repositoryWatcherListener.DidNotReceive().RemoteBranchesChanged();
repositoryWatcherListener.ClearReceivedCalls();
}
finally
{
repositoryWatcher.Stop();
}
}
}
finally
{
Logger.Trace("Ending ShouldDetectFileChangesAndCommit");
}
}
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()
{
await Initialize(TestRepoMasterCleanSynchronized);
var managerAutoResetEvent = new RepositoryManagerAutoResetEvent();
var repositoryManagerListener = Substitute.For <IRepositoryManagerListener>();
repositoryManagerListener.AttachListener(RepositoryManager, managerAutoResetEvent);
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 expectedAfterCommit = new GitStatus {
Ahead = 1,
Behind = 1,
LocalBranch = "master",
RemoteBranch = "origin/master",
Entries = new List <GitStatusEntry>()
};
var result = new GitStatus();
RepositoryManager.OnRepositoryChanged += status => {
result = status;
};
Logger.Trace("Issuing Changes");
var foobarTxt = TestRepoMasterCleanSynchronized.Combine("foobar.txt");
foobarTxt.WriteAllText("foobar");
var testDocumentTxt = TestRepoMasterCleanSynchronized.Combine("Assets", "TestDocument.txt");
testDocumentTxt.WriteAllText("foobar");
await TaskManager.Wait();
managerAutoResetEvent.OnRepositoryChanged.WaitOne(TimeSpan.FromSeconds(200)).Should().BeTrue();
Logger.Trace("Continue test");
repositoryManagerListener.Received().OnRepositoryChanged(Args.GitStatus);
result.AssertEqual(expectedAfterChanges);
repositoryManagerListener.ReceivedWithAnyArgs().OnIsBusyChanged(Args.Bool);
repositoryManagerListener.DidNotReceive().OnActiveBranchChanged();
repositoryManagerListener.DidNotReceive().OnActiveRemoteChanged();
repositoryManagerListener.DidNotReceive().OnHeadChanged();
repositoryManagerListener.DidNotReceive().OnLocalBranchListChanged();
repositoryManagerListener.DidNotReceive().OnRemoteBranchListChanged();
repositoryManagerListener.DidNotReceive().OnRemoteOrTrackingChanged();
repositoryManagerListener.DidNotReceive().OnLocksUpdated(Args.EnumerableGitLock);
repositoryManagerListener.ClearReceivedCalls();
Logger.Trace("Issuing Command");
await RepositoryManager
.CommitFiles(new List <string>() { "Assets\\TestDocument.txt", "foobar.txt" }, "IntegrationTest Commit", string.Empty)
.StartAsAsync();
await TaskManager.Wait();
managerAutoResetEvent.OnActiveBranchChanged.WaitOne(TimeSpan.FromSeconds(5)).Should().BeTrue();
Logger.Trace("Continue test");
repositoryManagerListener.Received(1).OnActiveBranchChanged();
repositoryManagerListener.DidNotReceive().OnActiveRemoteChanged();
repositoryManagerListener.DidNotReceive().OnHeadChanged();
repositoryManagerListener.DidNotReceive().OnLocalBranchListChanged();
repositoryManagerListener.DidNotReceive().OnRemoteBranchListChanged();
repositoryManagerListener.DidNotReceive().OnRemoteOrTrackingChanged();
repositoryManagerListener.DidNotReceive().OnLocksUpdated(Args.EnumerableGitLock);
}
public async Task ShouldAddAndCommitAllFiles()
{
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();
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);
repositoryManagerListener.ClearReceivedCalls();
repositoryManagerEvents.Reset();
StartTrackTime(watch, logger, "CommitAllFiles");
await RepositoryManager
.CommitAllFiles("IntegrationTest Commit", string.Empty)
.StartAsAsync();
StopTrackTimeAndLog(watch, logger);
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();
repositoryManagerEvents.LocalBranchesUpdated.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);
}
}
