public void CreateCommand_Invoked_ShouldCreateRepositoryAndCloneAndRaiseClosed()
{
bool closed = false;
_sut.Name = "repo";
_sut.LocalPath = "path";
_sut.IsPrivate = true;
_sut.Closed += delegate { closed = true; };
var remoteRepo = new GitRemoteRepository()
{
CloneUrl = Guid.NewGuid().ToString(),
Name = Guid.NewGuid().ToString()
};
_gitService.Expect(x => x.CloneRepository(remoteRepo.CloneUrl, remoteRepo.Name, _sut.LocalPath));
var result = _gitClientService
.Capture()
.Args <GitRemoteRepository, GitRemoteRepository>((s, repo) => s.CreateRepositoryAsync(repo), remoteRepo);
_sut.CreateCommand.Execute(null);
Assert.AreEqual(1, result.CallCount);
var args = result.Args[0];
Assert.AreEqual(_sut.Name, args.Name);
Assert.AreEqual(_sut.Description, args.Description);
Assert.AreEqual(_sut.IsPrivate, args.IsPrivate);
_gitClientService.VerifyAllExpectations();
_gitService.VerifyAllExpectations();
Assert.That(closed, Is.EqualTo(true));
}
public async Task <GitRemoteRepository> CreateRepositoryAsync(GitRemoteRepository newRepository)
{
var repository = newRepository.MapTo <Repository>();
repository.Name = repository.Name.Replace(' ', '-');
var result = await _bitbucketClient.RepositoriesClient.CreateRepository(repository, newRepository.IsTeam);
return(result.MapTo <GitRemoteRepository>());
}
public void PublishRepository(GitRemoteRepository repository)
{
Repository activeRepository = GetRepository();
SetRemote(activeRepository, repository.CloneUrl);
Push(activeRepository);
Fetch(activeRepository);
SetTrackingRemote(activeRepository);
}
public bool IsOriginRepo(GitRemoteRepository gitRemoteRepository)
{
if (gitRemoteRepository?.CloneUrl == null)
{
return(false);
}
Uri uri = new Uri(gitRemoteRepository.CloneUrl);
return(_bitbucketClient.ApiConnection.ApiUrl.Host.Contains(uri.Host, StringComparison.OrdinalIgnoreCase));
}
public void PublishCommand_Invoked_ShouldCreateAndPublishRepositoryAndRefreshActiveRepo()
{
IEnumerable <GitTeam> teams = new List <GitTeam>()
{
new GitTeam()
{
Name = "TeamName"
}
};
var connectionData = new ConnectionData()
{
UserName = "******", IsLoggedIn = true
};
_gitClientService.Expect(x => x.GetTeams()).Return(teams.FromTaskAsync());
_userInfoService.Stub(x => x.ConnectionData).Return(connectionData);
_sut.Initialize();
var remoteRepo = new GitRemoteRepository();
_sut.SelectedOwner = new Owner()
{
Name = "owner"
};
_sut.RepositoryName = "repoName with space";
_sut.Description = "description";
_sut.IsPrivate = true;
_gitService.Expect(x => x.PublishRepository(remoteRepo));
_gitWatcher.Expect(x => x.Refresh());
var result = _gitClientService
.Capture()
.Args <GitRemoteRepository, GitRemoteRepository>((s, repo) => s.CreateRepositoryAsync(repo), remoteRepo);
_sut.PublishRepositoryCommand.Execute(null);
Assert.AreEqual(1, result.CallCount);
var args = result.Args[0];
Assert.AreEqual("repoName-with-space", args.Name);
Assert.AreEqual(_sut.Description, args.Description);
Assert.AreEqual(_sut.IsPrivate, args.IsPrivate);
Assert.AreEqual(_sut.SelectedOwner, args.Owner);
_gitClientService.VerifyAllExpectations();
_gitService.VerifyAllExpectations();
_gitWatcher.VerifyAllExpectations();
}
private bool IsGitLocalRepoAndLoggedIn(GitRemoteRepository repo)
{
return(_userInformationService.ConnectionData.IsLoggedIn && repo != null && string.IsNullOrEmpty(repo.CloneUrl));
}
public ActiveRepositoryChangedEvent(GitRemoteRepository activeRepository, GitRemoteRepository previousRepository)
{
PreviousRepository = previousRepository;
ActiveRepository = activeRepository;
}
