public ProjectInfo Get(int id)
{
ProjectInfo project = new ProjectInfo();
project = ProjectBl.GetProjectById(id);
return(project);
}
public async Task <IActionResult> ProjectDetails(int id)
{
if (id < 0)
{
return(NotFound());
}
return(View(await
ProjectBl.PrepareViewProjectDetails(id)));
}
public JsonResult <IEnumerable <ProjectInfo> > Get()
{
ProjectInfo[] ListOfProjects = ProjectBl.GetAllProjects();
var proj = from c in ListOfProjects
select c;
return(Json(proj));
}
/// <summary>
/// Defines user roles which can change project state.
/// </summary>
/// <param name="projectBl">Extends project business logic class.</param>
/// <param name="role">Role of user in project.</param>
/// <returns>Boolean value which points to possibility to change project state.</returns>
public static bool CanChangeProject(this ProjectBl projectBl, AppUserRole role)
{
if (role.IsOwner())
{
return(true);
}
else
{
return(false);
}
}
public async Task GetByIdAsync_Should_Fail_Access()
{
// Arrange
mockProjRepo.Setup(repo => repo.GetByIdAsync(1)).ReturnsAsync(GetSampleProjects()[0]);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(It.IsAny <string>(), It.IsAny <int>())).ReturnsAsync(AppUserRole.None);
var projectBL = new ProjectBl(mockProjRepo.Object, mapper, mockProjectUserRepo.Object, mockSprintRepo.Object);
// Act
var resultFromBl = projectBL.GetByIdAsync(It.IsAny <int>(), It.IsAny <string>());
// Assert
await Assert.ThrowsAsync <ForbiddenResponseException>(() => projectBL.GetByIdAsync(It.IsAny <int>(), It.IsAny <string>()));
}
/// <summary>
/// Defines user roles which can view project data.
/// </summary>
/// <param name="projectBl">Extends project business logic class.</param>
/// <param name="role">Role of user in project.</param>
/// <returns>Boolean value which points to possibility to view project data.</returns>
public static bool CanAccessProject(this ProjectBl projectBl, AppUserRole role)
{
if (role.IsScrumMaster() || role.IsOwner() ||
role.IsDeveloper() || role.IsObserver())
{
return(true);
}
else
{
return(false);
}
}
public HttpResponseMessage Post(ProjectInfo project)
{
try
{
ProjectBl.AddNewProject(project);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (Exception ex)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
}
public async Task GetByIdAsync_Should_Throw_NotFoundResponseException(int projectId)
{
string userId = It.IsAny <string>();
// Arrange
mockProjRepo.Setup(repo => repo.GetByIdAsync(projectId)).ReturnsAsync(null as Project);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(userId, projectId)).ReturnsAsync(AppUserRole.Owner);
var projectBL = new ProjectBl(mockProjRepo.Object, mapper, mockProjectUserRepo.Object, mockSprintRepo.Object);
// Act
var resultFromBl = projectBL.GetByIdAsync(projectId, userId);
// Assert
await Assert.ThrowsAsync <NotFoundResponseException>(() => projectBL.GetByIdAsync(projectId, userId));
}
public void GetAllAsync_Should_Returns_AllProjects()
{
// Arrange
mockProjRepo.Setup(repo => repo.GetAllAsync()).ReturnsAsync(GetSampleProjects());
var projectBL = new ProjectBl(mockProjRepo.Object, mapper, mockProjectUserRepo.Object, mockSprintRepo.Object);
// Act
var resultFromBl = projectBL.GetAllAsync();
// Assert
var typeResult = Assert.IsType <Task <IEnumerable <ProjectDto> > >(resultFromBl);
var model = Assert.IsAssignableFrom <IEnumerable <ProjectDto> >(typeResult.Result);
Assert.Equal(GetSampleProjects().Count, model.Count());
}
public void GetByIdAsync_Should_Work_Can_Access(string userIdRole)
{
// Arrange
mockProjRepo.Setup(repo => repo.GetByIdAsync(1)).ReturnsAsync(GetSampleProjects()[0]);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember("IsObserver", It.IsAny <int>())).ReturnsAsync(AppUserRole.Observer);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember("IsDeveloper", It.IsAny <int>())).ReturnsAsync(AppUserRole.Developer);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember("IsScrumMaster", It.IsAny <int>())).ReturnsAsync(AppUserRole.ScrumMaster);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember("IsOwner", It.IsAny <int>())).ReturnsAsync(AppUserRole.Owner);
var projectBL = new ProjectBl(mockProjRepo.Object, mapper, mockProjectUserRepo.Object, mockSprintRepo.Object);
// Act
var resultFromBl = projectBL.GetByIdAsync(1, userIdRole);
// Assert
mockProjRepo.Verify(r => r.GetByIdAsync(1), Times.Once);
}
public void DeleteAsync_Should_Not_Found(int projectId)
{ // Arrange
string userId = It.IsAny <string>();
mockProjRepo.Setup(repo => repo.GetByIdAsync(projectId)).ReturnsAsync(null as Project);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(userId, projectId)).ReturnsAsync(AppUserRole.Owner);
var projectBL = new ProjectBl(mockProjRepo.Object, mapper, mockProjectUserRepo.Object, mockSprintRepo.Object);
// Act
var result = projectBL.DeleteAsync(projectId, userId);
// Assert
Assert.IsType <ProjectResponse>(result.Result);
Assert.False(result.Result.Success);
Assert.Equal("Project not found", result.Result.Message);
}
public ProjectController(
ProjectDbContext context,
ApplicationDbContext appcontext,
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
ILogger <AccountController> logger
)
{
_context = context;
_appcontext = appcontext;
_userManager = userManager;
_signInManager = signInManager;
_logger = logger;
ProjectBl.ProjectLayer(context, appcontext);
}
public void Delete_Should_Call_Once_DeleteAsync_Into_Repository()
{
// Arrange
mockProjRepo.Setup(repo => repo.GetByIdAsync(It.IsAny <int>())).ReturnsAsync(GetSampleProjects()[0]);
mockProjRepo.Setup(repo => repo.DeleteAsync(It.IsAny <int>()));
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(It.IsAny <string>(), It.IsAny <int>())).ReturnsAsync(AppUserRole.Owner);
var projectBL = new ProjectBl(mockProjRepo.Object, mapper, mockProjectUserRepo.Object, mockSprintRepo.Object);
// Act
var result = projectBL.DeleteAsync(It.IsAny <int>(), It.IsAny <string>());
// Assert
mockProjRepo.Verify(r => r.DeleteAsync(It.IsAny <int>()), Times.Once);
Assert.IsType <ProjectResponse>(result.Result);
Assert.True(result.Result.Success);
}
public async Task Delete_Should_Fail_Only_Owner_Can_Delete(string userIdRole)
{
// Arrange
mockProjRepo.Setup(repo => repo.GetByIdAsync(It.IsAny <int>())).ReturnsAsync(GetSampleProjects()[0]);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember("IsObserver", It.IsAny <int>())).ReturnsAsync(AppUserRole.Observer);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember("IsDeveloper", It.IsAny <int>())).ReturnsAsync(AppUserRole.Developer);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember("IsScrumMaster", It.IsAny <int>())).ReturnsAsync(AppUserRole.ScrumMaster);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember("IsNone", It.IsAny <int>())).ReturnsAsync(AppUserRole.None);
var projectBL = new ProjectBl(mockProjRepo.Object, mapper, mockProjectUserRepo.Object, mockSprintRepo.Object);
// Act
var result = projectBL.DeleteAsync(It.IsAny <int>(), userIdRole);
// Assert
mockProjRepo.Verify(r => r.DeleteAsync(It.IsAny <int>()), Times.Never);
await Assert.ThrowsAsync <ForbiddenResponseException>(() => projectBL.DeleteAsync(It.IsAny <int>(), userIdRole));
}
public void GetByIdAsync_Should_Call_Once_ReadAsync()
{
string userId = It.IsAny <string>();
int projectId = 1;
int index = projectId - 1;
// Arrange
mockProjRepo.Setup(repo => repo.GetByIdAsync(projectId)).ReturnsAsync(GetSampleProjects()[index]);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(userId, projectId)).ReturnsAsync(AppUserRole.Owner);
var projectBL = new ProjectBl(mockProjRepo.Object, mapper, mockProjectUserRepo.Object, mockSprintRepo.Object);
// Act
var resultFromBl = projectBL.GetByIdAsync(projectId, userId);
// Assert
var typeResult = Assert.IsType <Task <ProjectDto> >(resultFromBl);
mockProjRepo.Verify(r => r.GetByIdAsync(projectId), Times.Once);
}
public void GetByIdAsync_Should_Return_The_Same_Resault()
{
// Arrange
string userId = It.IsAny <string>();
int projectId = 1;
int index = projectId - 1;
mockProjRepo.Setup(repo => repo.GetByIdAsync(projectId)).ReturnsAsync(GetSampleProjects()[index]);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(userId, projectId)).ReturnsAsync(AppUserRole.Owner);
var projectBL = new ProjectBl(mockProjRepo.Object, mapper, mockProjectUserRepo.Object, mockSprintRepo.Object);
// Act
var resultFromBl = projectBL.GetByIdAsync(projectId, userId);
// Assert
Assert.Equal(GetSampleProjects()[index].Id, resultFromBl.Result.Id);
Assert.Equal(GetSampleProjects()[index].Name, resultFromBl.Result.Name);
Assert.Equal(GetSampleProjects()[index].Description, resultFromBl.Result.Description);
}
public void Update_Should_Call_Once_UpdateAsync()
{
// Arrange
var projectDto = new ProjectDto {
Id = 1, Name = "First Update", Description = "Some description for Project1"
};
mockProjRepo.Setup(repo => repo.GetByIdAsync(It.IsAny <int>())).ReturnsAsync(GetSampleProjects()[0]);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(It.IsAny <string>(), It.IsAny <int>())).ReturnsAsync(AppUserRole.Owner);
var projectBL = new ProjectBl(mockProjRepo.Object, mapper, mockProjectUserRepo.Object, mockSprintRepo.Object);
// Act
var result = projectBL.UpdateAsync(projectDto, It.IsAny <string>());
// Assert
mockProjRepo.Verify(r => r.UpdateAsync(It.IsAny <Project>()), Times.Once);
Assert.IsType <ProjectResponse>(result.Result);
Assert.True(result.Result.Success);
}
public void Create_Should_Call_Once_CreateAsync()
{
// Arrange
var projectDto = new ProjectDto {
Id = 1, Name = "Project 1", Description = "Some description"
};
mockProjRepo.Setup(repo => repo.CreateAsync(null as Project));
mockSprintRepo.Setup(repo => repo.CreateAsync(null as Sprint));
mockProjectUserRepo.Setup(repo => repo.CreateRecordAsync(null as ProjectUser));
var projectBL = new ProjectBl(mockProjRepo.Object, mapper, mockProjectUserRepo.Object, mockSprintRepo.Object);
// Act
var result = projectBL.CreateAsync(projectDto, It.IsAny <string>());
// Assert
mockProjRepo.Verify(r => r.CreateAsync(It.IsAny <Project>()), Times.Once);
Assert.IsType <ProjectResponse>(result.Result);
Assert.True(result.Result.Success);
}
public void Delete_Should_Work()
{
// Arrange
var projectDto = new ProjectDto {
Id = 1, Name = "Project for deleting", Description = "Some description for Project1"
};
Project project = mapper.Map <ProjectDto, Project>(projectDto);
mockProjRepo.Setup(repo => repo.GetByIdAsync(It.IsAny <int>())).ReturnsAsync(project);
mockProjectUserRepo.Setup(repo => repo.GetRoleOfMember(It.IsAny <string>(), It.IsAny <int>())).ReturnsAsync(AppUserRole.Owner);
var projectBL = new ProjectBl(mockProjRepo.Object, mapper, mockProjectUserRepo.Object, mockSprintRepo.Object);
// Act
var result = projectBL.DeleteAsync(It.IsAny <int>(), It.IsAny <string>());
// Assert
Assert.IsType <ProjectResponse>(result.Result);
Assert.True(result.Result.Success);
Assert.Equal(projectDto.Name, result.Result.ProjectDTO.Name);
Assert.Equal(projectDto.Description, result.Result.ProjectDTO.Description);
}
public ProjectController(IProjectRepository repo)
{
_repo = repo;
_projectBl = new ProjectBl(repo);
}
public HttpResponseMessage Post(ProjectInfo project)
{
return(ProjectBl.UpdateProject(project));
}
public HttpResponseMessage Delete(int id, bool isOpen)
{
return(ProjectBl.SoftDeleteProject(id, isOpen));
}
