public void Setup()
{
_createGitLabGroupCommand = A.Fake <ICreateGitLabGroupCommand>();
_createGitLabProjectCommand = A.Fake <ICreateGitLabProjectCommand>();
_pushToGitLabRepositoryCommand = A.Fake <IPushToGitLabRepositoryCommand>();
_gitLabProjectFactory = A.Fake <IGitLabProjectFactory>();
_gitLabGroupFactory = A.Fake <IGitLabGroupFactory>();
_pushToRepositoryResponse = new PushToRepositoryResponse()
{
Successful = true
};
_group = new Group();
_project = new Project();
_createSolutionModel = new CreateSolutionModel();
A.CallTo(() => _pushToGitLabRepositoryCommand.ExecuteAsync(A <PushToRepositoryRequest> ._))
.Returns(_pushToRepositoryResponse);
A.CallTo(() => _createGitLabGroupCommand.ExecuteAsync(A <Group> ._)).Returns(_group);
A.CallTo(() => _createGitLabProjectCommand.ExecuteAsync(A <Project> ._)).Returns(_project);
_sut = new CreateGitLabSolutionCommand(_createGitLabGroupCommand, _createGitLabProjectCommand,
_pushToGitLabRepositoryCommand, _gitLabProjectFactory, _gitLabGroupFactory);
}
public async Task <ActionResponse> ExecuteAsync(CreateSolutionModel model, Action <CreateSolutionModel, string> notifyAction)
{
var template = await _getTemplateByIdQuery.ExecuteAsync(model.SolutionTemplateId);
await _gitService.CloneProjectAsync(template.RepositoryUrl, (s) => {});
return(new ActionResponse());
}
public void Setup()
{
Sut = Get <ICreateOctopusSolutionCommand>();
_createSolutionModel = new CreateSolutionModel()
{
OctopusProjectName = "Divisions",
OctopusGroupId = "ProjectGroups-1",
OctopusLifeCycleId = "Lifecycles-1"
};
}
public void Setup()
{
_sut = new GitLabProjectFactory();
_model = new CreateSolutionModel()
{
GitLabProjectName = "Divisions Admin",
GitLabProjectDescription = "Project Description"
};
_groupId = "123";
}
public void ExecuteCommand_ReturnsSuccessfulResult()
{
_createSolutionModel = new CreateSolutionModel()
{
VisualStudioSolutionName = "Divisions",
VisualStudioSubprojectName = "Admin"
};
_sut.ExecuteAsync(_createSolutionModel, (model, s) => { });
Assert.That(AssertDirectoryExists);
}
public void Setup()
{
Sut = Get <ICreateGitLabSolutionCommand>();
_createSolutionModel = new CreateSolutionModel()
{
VisualStudioSolutionName = "Divisions",
VisualStudioSubprojectName = "Admin",
GitLabProjectName = "Divisions Admin App",
GitLabGroupName = "Divisions",
GitLabGroupPath = "divisions",
GitLabProjectDescription = "Divisions Admin Application"
};
}
public async Task <CreateSolutionResponse> ExecuteAsync(CreateSolutionModel model,
Action <CreateSolutionModel, string> notifyAction)
{
notifyAction(model, "Solution creation process started");
var visualStudioResponse = await _createVisualStudioSolutionCommand.ExecuteAsync(model, notifyAction);
var gitLabResponse = await _createTeamcitySolutionCommand.ExecuteAsync(model, notifyAction);
var teamCityResponse = await _createTeamcitySolutionCommand.ExecuteAsync(model, notifyAction);
return(new CreateSolutionResponse());
}
public async Task <ActionResponse> ExecuteAsync(CreateSolutionModel model, Action <CreateSolutionModel, string> notifyAction)
{
// Clean working directory
_directoryService.DeleteDirectory(_configuration.WorkingDirectory);
var directory = _directoryService.CreateDirectory(_configuration.DownloadDirectory);
// Clone template repository
await _cloneSolutionTemplateCommand.ExecuteAsync(model, notifyAction);
_directoryService.CopyDirectory(directory.FullName, _configuration.WorkingDirectory);
await _updateSolutionFileNamespacesCommand.ExecuteAsync(model, notifyAction);
// download template and unzip into location
return(await _cloneSolutionTemplateCommand.ExecuteAsync(model, notifyAction));
}
public IList <ValidationResult> Validate(CreateSolutionModel model)
{
foreach (var rule in ValidationRules)
{
var isValid = rule.RuleExpression.Compile()(model);
var result = new ValidationResult()
{
IsValid = isValid, Message = rule.Message
};
ValidationResults.Add(result);
}
return(ValidationResults);
}
public async Task <ActionResponse> ExecuteAsync(CreateSolutionModel model, Action <CreateSolutionModel, string> notifyAction)
{
var cloneProjectScript = new PowershellScript("Convert-Solution.ps1", s => {});
cloneProjectScript.AddArgument("solutionName", model.VisualStudioSolutionName);
cloneProjectScript.AddArgument("projectName", model.VisualStudioSubprojectName);
cloneProjectScript.AddArgument("workingDirPath", _configuration.WorkingDirectory);
var result = await Task.Run(() => cloneProjectScript.ExecuteAync());
return(new ActionResponse()
{
Success = result.Suceess,
Errors = result.ErrorMessages
});
}
public ActionResponse Eval(CreateSolutionModel model)
{
var teamcityResults = new TeamCityValidationRules().Validate(model);
var response = new ActionResponse()
{
Success = true
};
if (teamcityResults.Any(res => !res.IsValid))
{
response.Success = false;
response.Errors = teamcityResults.Select(res => res.Message);
}
return(response);
}
public IActionResult CreateSolution(CreateSolutionModel model)
{
if (ModelState.IsValid)
{
var entity = new Solution.Domain.Solution();
model.CopyTo(entity);
entity.SolutionId = Guid.NewGuid();
entity.OrganizationId = CurrentUser.OrganizationId;
entity.PublisherId = CurrentUser.SystemUserId;
entity.CreatedBy = CurrentUser.SystemUserId;
entity.CreatedOn = DateTime.Now;
entity.InstalledOn = DateTime.Now;
_solutionService.Create(entity);
return(CreateSuccess(new { id = entity.SolutionId }));
}
return(CreateFailure(GetModelErrors()));
}
public void UpdateNamespacesInFiles_ReturnsSuccessfullFlag()
{
var expectedSolutionFileName = "Divisions.Admin.sln";
_createSolutionModel = new CreateSolutionModel()
{
VisualStudioSolutionName = "Divisions",
VisualStudioSubprojectName = "Admin"
};
var result = _Sut.ExecuteAsync(_createSolutionModel, (s, m) => { });
result.Wait();
Assert.That(result.Result.Success, Is.True, "The update script failed to execute: {0}", result.Result.Errors.FirstOrDefault());
Assert.That(AssertFileHasBeenRenamed(expectedSolutionFileName));
}
public async Task <CreateOctopusSolutionResponse> ExecuteAsync(CreateSolutionModel model,
Action <CreateSolutionModel, string> notifyAction)
{
// get group or create new
var project = new ProjectResource()
{
Name = model.OctopusProjectName,
ProjectGroupId = model.OctopusGroupId,
LifecycleId = model.OctopusLifeCycleId
};
project = await _createOctopusProjectCommand.ExecuteAsync(project);
return(new CreateOctopusSolutionResponse()
{
Project = project
});
}
public async Task <CreateTeamCitySolutionResponse> ExecuteAsync(CreateSolutionModel model, Action <CreateSolutionModel, string> notifyAction)
{
notifyAction(model, "Teamcity build started");
Project parentProject;
await _createVisualStudioSolutionCommand.ExecuteAsync(model, notifyAction);
// Create Main Project
if (model.NewParentProject)
{
var mainProjectModel = _modelFactory.Create(model.TeamCityNewParentProjectName);
parentProject = await _createProjectCommand.ExecuteAsync(mainProjectModel);
}
else
{
parentProject = await _getProjectQuery.Execute(model.TeamCityParentProjectId);
}
// Create Sub Project
var subProjectModel = _modelFactory.Create(model.TeamCitySubprojectName, parentProject.Id);
var subProject = await _createProjectCommand.ExecuteAsync(subProjectModel);
// Create Build
var build = await _createBuildCommand.ExecuteAsync(subProject.Id);
var param = await _updateBuildParameterCommand.Execute(build, "SolutionName", model.VisualStudioSolutionName);
// Create VCS Root and attach to build
var vcsModel = _vcsModelFactory.Create(model.TeamCitySubprojectName + " master", subProject.Id, model.SourceControlUrl);
var vcs = await _createVcsRootCommand.Execute(vcsModel, build.Id);
notifyAction(model, "Teamcity build complete");
return(new CreateTeamCitySolutionResponse()
{
ParentProject = parentProject,
SubProject = subProject,
TypVcsRoot = vcs
});
}
public async Task <CreateGitLabSolutionResponse> ExecuteAsync(CreateSolutionModel model,
Action <CreateSolutionModel, string> notifyAction)
{
var group = _gitLabGroupFactory.Create(model.GitLabProjectName, model.GitLabGroupPath);
var newGroup = await _createGitLabGroupCommand.ExecuteAsync(group);
var project = _gitLabProjectFactory.Create(model.GitLabProjectName, model.GitLabProjectDescription, newGroup.Id);
project = await _createGitLabProjectCommand.ExecuteAsync(project);
var pushRequest = new PushToRepositoryRequest()
{
RepositoryUrl = project.HttpUrl
};
var repoResponse = await _pushToGitLabRepositoryCommand.ExecuteAsync(pushRequest);
return(new CreateGitLabSolutionResponse()
{
Group = newGroup,
Project = project,
PushToRepositorySuccessful = repoResponse.Successful
});
}
private void NotifyAction(CreateSolutionModel model, string message)
{
}
public IActionResult CreateSolution()
{
CreateSolutionModel model = new CreateSolutionModel();
return(View(model));
}
