public MutationTest(DatabaseFixture fixture)
{
this.fixture = fixture;
ILoggerFactory factory = new NullLoggerFactory();
_projectService = new ProjectService(fixture.context);
_evaluationService = new EvaluationService(fixture.context);
_participantService = new ParticipantService(fixture.context);
_questionService = new QuestionService(fixture.context);
_answerService = new AnswerService(fixture.context);
_actionService = new ActionService(fixture.context);
_noteService = new NoteService(fixture.context);
_closingRemarkService = new ClosingRemarkService(fixture.context);
_questionTemplateService = new QuestionTemplateService(fixture.context);
_projectCategoryService = new ProjectCategoryService(fixture.context);
_authService = new MockAuthService();
_mutation = new Mutation(
_projectService,
_evaluationService,
_participantService,
_questionService,
_answerService,
_actionService,
_noteService,
_closingRemarkService,
_questionTemplateService,
_projectCategoryService,
_authService,
new Logger <Mutation>(factory)
);
_project = _projectService.Create("Project");
}
public Mutation(
ProjectService projectService,
EvaluationService evaluationService,
ParticipantService participantService,
QuestionService questionService,
AnswerService answerService,
ActionService actionService,
NoteService noteService,
ClosingRemarkService closingRemarkService,
QuestionTemplateService questionTemplateService,
ProjectCategoryService projectCategoryService,
IAuthService authService,
ILogger <Mutation> logger
)
{
_projectService = projectService;
_evaluationService = evaluationService;
_participantService = participantService;
_questionService = questionService;
_answerService = answerService;
_actionService = actionService;
_noteService = noteService;
_closingRemarkService = closingRemarkService;
_questionTemplateService = questionTemplateService;
_projectCategoryService = projectCategoryService;
_authService = authService;
_logger = logger;
}
public void RemoveFromSeveralProjectCategories()
{
var projectCategoryService = new ProjectCategoryService(fixture.context);
var projectCategory1 = projectCategoryService.Create(Randomize.String());
var projectCategory2 = projectCategoryService.Create(Randomize.String());
var projectCategoryIds = new List <string> {
projectCategory1.Id, projectCategory2.Id
};
var service = new QuestionTemplateService(fixture.context);
var template = service.GetAll().First();
service.AddToProjectCategory(template.Id, projectCategory1.Id);
service.AddToProjectCategory(template.Id, projectCategory2.Id);
var nActiveFirstCategory = service.ActiveQuestions(projectCategory1).Count();
var nActiveSecondCategory = service.ActiveQuestions(projectCategory2).Count();
var nTemplates = service.GetAll().Count();
var updatedQT = service.RemoveFromProjectCategories(template.Id, projectCategoryIds);
var updatedPC1 = projectCategoryService.Get(projectCategory1.Id);
var updatedPC2 = projectCategoryService.Get(projectCategory2.Id);
Assert.False(updatedQT.ProjectCategories.Contains(updatedPC1));
Assert.False(updatedQT.ProjectCategories.Contains(updatedPC2));
Assert.False(updatedPC1.QuestionTemplates.Contains(updatedQT));
Assert.False(updatedPC2.QuestionTemplates.Contains(updatedQT));
Assert.Equal(nActiveFirstCategory - 1, service.ActiveQuestions(projectCategory1).Count());
Assert.Equal(nActiveSecondCategory - 1, service.ActiveQuestions(projectCategory2).Count());
Assert.Equal(nTemplates, service.GetAll().Count());
}
public void RemoveFromProjectCategory()
{
var projectCategoryService = new ProjectCategoryService(fixture.context);
var projectCategory = projectCategoryService.Create(Randomize.String());
var service = new QuestionTemplateService(fixture.context);
var template = service.GetAll().First();
service.AddToProjectCategory(template.Id, projectCategory.Id);
var nActive = service.ActiveQuestions(projectCategory).Count();
var nTemplates = service.GetAll().Count();
var updatedQT = service.RemoveFromProjectCategories(template.Id, new List <string> {
projectCategory.Id
});
var updatedPC = projectCategoryService.Get(projectCategory.Id);
Assert.False(updatedQT.ProjectCategories.Contains(updatedPC));
Assert.False(updatedPC.QuestionTemplates.Contains(updatedQT));
Assert.Equal(nActive - 1, service.ActiveQuestions(projectCategory).Count());
Assert.Equal(nTemplates, service.GetAll().Count());
/* Removing the same QuestionTemplate should fail */
Assert.Throws <Exception>(() =>
service.RemoveFromProjectCategories(template.Id, new List <string> {
projectCategory.Id
})
);
}
public ProjectCategoryModel PostProjectCategory([FromBody] ProjectCategoryModel projectCategory)
{
Response.StatusCode = 201;
string result = ProjectCategoryService.AddProjectCategory(projectCategory, dbConn);
projectCategory.Id = Convert.ToInt32(result);
return(projectCategory);
}
public void GetExising()
{
var service = new ProjectCategoryService(fixture.context);
var name = Randomize.String();
var exisingId = service.Create(name).Id;
var exists = service.Get(exisingId);
Assert.Equal(name, exists.Name);
}
public void GetNonExisting()
{
var service = new ProjectCategoryService(fixture.context);
var nonExistingId = Randomize.String();
Assert.Throws <NotFoundInDBException>(
() => service.Get(nonExistingId)
);
}
public void Create()
{
var service = new ProjectCategoryService(fixture.context);
int nCategories = service.GetAll().Count();
service.Create(Randomize.String());
Assert.Equal(nCategories + 1, service.GetAll().Count());
}
public void DeleteQuestionTemplate()
{
var service = new QuestionTemplateService(fixture.context);
Barrier barrier = Randomize.Barrier();
var questionTemplateToDelete = service.Create(
barrier: barrier,
organization: Randomize.Organization(),
text: Randomize.String(),
supportNotes: Randomize.String()
);
var projectCategory = new ProjectCategoryService(fixture.context).GetAll().First();
questionTemplateToDelete = service.AddToProjectCategory(questionTemplateToDelete.Id, projectCategory.Id);
int maxOrderActive = service.GetAll()
.Where(qt => qt.Status == Status.Active)
.Max(qt => qt.Order)
;
int maxBarrierOrder = service.GetAll()
.Where(qt => qt.Status == Status.Active)
.Where(qt => qt.Barrier == barrier)
.Max(qt => qt.Order)
;
int maxAdminOrder = service.GetAll()
.Where(qt => qt.Status == Status.Active)
.Max(qt => qt.AdminOrder)
;
var deletedQuestionTemplate = service.Delete(questionTemplateToDelete);
int maxOrderActiveAfter = service.GetAll()
.Where(qt => qt.Status == Status.Active)
.Max(qt => qt.Order)
;
int maxBarrierOrderAfter = service.GetAll()
.Where(qt => qt.Status == Status.Active)
.Where(qt => qt.Barrier == barrier)
.Max(qt => qt.Order)
;
int maxAdminOrderAfter = service.GetAll()
.Where(qt => qt.Status == Status.Active)
.Max(qt => qt.AdminOrder)
;
int maxOrder = fixture.context.QuestionTemplates.Max(qt => qt.Order);
Assert.Equal(maxOrderActive - 1, maxOrderActiveAfter);
Assert.Equal(maxBarrierOrder - 1, maxBarrierOrderAfter);
Assert.Equal(maxAdminOrder - 1, maxAdminOrderAfter);
Assert.Equal(deletedQuestionTemplate.Order, maxOrder);
Assert.True(deletedQuestionTemplate.Status == Status.Voided);
Assert.Equal(deletedQuestionTemplate.ProjectCategories, questionTemplateToDelete.ProjectCategories);
}
public void CopyFrom()
{
var service = new ProjectCategoryService(fixture.context);
var nProjectCategories = service.GetAll().Count();
var other = service.GetAll().First();
var nTemplates = other.QuestionTemplates.Count();
var projectCategory = service.CopyFrom(Randomize.String(), other);
Assert.Equal(nProjectCategories + 1, service.GetAll().Count());
Assert.Equal(nTemplates, projectCategory.QuestionTemplates.Count());
}
public async Task WhenThereAreNoProjects_ReturnsNon()
{
var options = Helper.GetContextOptions();
using (var context = new DataContext(options))
{
var service = new ProjectCategoryService(context);
var categories = await service.GetAllAsync();
Assert.Equal(0, categories.Count);
}
}
public async Task WhenDeletingNonExistingCategory_ThrowsException(int id)
{
var options = Helper.GetContextOptions();
CreateTestData(options);
using (var context = new DataContext(options))
{
var service = new ProjectCategoryService(context);
await Assert.ThrowsAsync <RecordNotFoundException>(() => service.DeleteAsync(id));
}
}
public async Task WhenPassingInvalidIds_ReturnsNull(int id)
{
var options = Helper.GetContextOptions();
CreateTestData(options);
using (var context = new DataContext(options))
{
var service = new ProjectCategoryService(context);
var category = await service.GetAsync(id);
Assert.Null(category);
}
}
public async Task WhenPassingValidId_ReturnsCategory(int id, string shortDescription, string description)
{
var options = Helper.GetContextOptions();
CreateTestData(options);
using (var context = new DataContext(options))
{
var service = new ProjectCategoryService(context);
var category = await service.GetAsync(id);
ValidateProjectCategory(category, id, shortDescription, description);
}
}
public void EditQuestionTemplate()
{
var service = new QuestionTemplateService(fixture.context);
Barrier barrier = Randomize.Barrier();
var originalQT = service.Create(
barrier: barrier,
organization: Randomize.Organization(),
text: Randomize.String(),
supportNotes: Randomize.String()
);
var projectCategory = new ProjectCategoryService(fixture.context).GetAll().First();
originalQT = service.AddToProjectCategory(originalQT.Id, projectCategory.Id);
var nTemplates = service.GetAll().Count();
var nActive = service.ActiveQuestions(projectCategory).Count();
var newText = Randomize.String();
var newSupportNotes = Randomize.String();
var newOrganization = Randomize.Organization();
var updatedQT = service.Edit(
questionTemplate: originalQT,
barrier: barrier,
organization: newOrganization,
text: newText,
supportNotes: newSupportNotes,
status: Status.Active
);
Assert.Equal(nTemplates + 1, service.GetAll().Count());
Assert.Equal(nActive, service.ActiveQuestions(projectCategory).Count());
Assert.Equal(newText, updatedQT.Text);
Assert.Equal(newSupportNotes, updatedQT.SupportNotes);
Assert.Equal(barrier, updatedQT.Barrier);
Assert.Equal(newOrganization, updatedQT.Organization);
Assert.Equal(originalQT, updatedQT.previous);
Assert.True(updatedQT.ProjectCategories.Count() == 1);
Assert.Equal(updatedQT.AdminOrder, originalQT.AdminOrder);
}
public async Task WhenUpdatingNonExistingCategory_ThrowsException(int id, string shortDescription, string description)
{
var options = Helper.GetContextOptions();
CreateTestData(options);
using (var context = new DataContext(options))
{
var service = new ProjectCategoryService(context);
var categoryDto = new ProjectCategoryDto
{
Id = id,
ShortDescription = shortDescription,
Description = description
};
await Assert.ThrowsAsync <RecordNotFoundException>(() => service.UpdateAsync(categoryDto));
}
}
public async Task WhenDeletingExistingCategory_DeleteSuccessfully(int id)
{
var options = Helper.GetContextOptions();
CreateTestData(options);
using (var context = new DataContext(options))
{
var service = new ProjectCategoryService(context);
var categoryBeforeDelete = service.GetAsync(id);
Assert.NotNull(categoryBeforeDelete);
await service.DeleteAsync(id);
var deletedCategory = await service.GetAsync(id);
Assert.Null(deletedCategory);
}
}
public void Delete()
{
var service = new ProjectCategoryService(fixture.context);
int nCategories = service.GetAll().Count();
var oldProjectCategory = service.GetAll().First();
var newProjectCategory = service.CopyFrom(Randomize.String(), oldProjectCategory);
var qtService = new QuestionTemplateService(fixture.context);
var questionTemplate = qtService
.GetAll()
.Include(x => x.ProjectCategories)
.First(x => x.ProjectCategories.Contains(newProjectCategory))
;
service.Delete(newProjectCategory);
questionTemplate = qtService.GetQuestionTemplate(questionTemplate.Id);
Assert.False(questionTemplate.ProjectCategories.Contains(newProjectCategory));
Assert.Equal(nCategories, service.GetAll().Count());
}
public async Task WhenPassingCorrectData_SuccessfullyCreate(string shortDescription, string description)
{
var options = Helper.GetContextOptions();
CreateTestData(options);
using (var context = new DataContext(options))
{
var service = new ProjectCategoryService(context);
var projectCategoryDto = new ProjectCategoryDto
{
ShortDescription = shortDescription,
Description = description
};
var id = await service.CreateAsync(projectCategoryDto);
var projectCategory = await service.GetAsync(id);
ValidateProjectCategory(projectCategory, null, shortDescription, description);
}
}
public async Task WhenUpdatingExistingCategory_UpdateSuccessfully(int id, string shortDescription, string description)
{
var options = Helper.GetContextOptions();
CreateTestData(options);
using (var context = new DataContext(options))
{
var service = new ProjectCategoryService(context);
var categoryDto = new ProjectCategoryDto
{
Id = id,
ShortDescription = shortDescription,
Description = description
};
await service.UpdateAsync(categoryDto);
var updatedProject = await service.GetAsync(id);
ValidateProjectCategory(updatedProject, id, shortDescription, description);
}
}
public void AddToProjectCategory()
{
var projectCategoryService = new ProjectCategoryService(fixture.context);
var projectCategory = projectCategoryService.Create(Randomize.String());
var service = new QuestionTemplateService(fixture.context);
var nActive = service.ActiveQuestions(projectCategory).Count();
var nTemplates = service.GetAll().Count();
var template = service.GetAll().First();
var updatedQT = service.AddToProjectCategory(template.Id, projectCategory.Id);
var updatedSP = projectCategoryService.Get(projectCategory.Id);
Assert.True(updatedQT.ProjectCategories.Contains(updatedSP));
Assert.True(updatedSP.QuestionTemplates.Contains(updatedQT));
Assert.Equal(nActive + 1, service.ActiveQuestions(projectCategory).Count());
Assert.Equal(nTemplates, service.GetAll().Count());
/* Adding the same QuestionTemplate should fail */
Assert.Throws <Exception>(() =>
service.AddToProjectCategory(template.Id, projectCategory.Id)
);
}
static void Main(string[] args)
{
/*
* string fileName = @"C:\Users\lisse\Pictures\google_logo.svg";
* byte[] file = System.IO.File.ReadAllBytes(fileName);
* System.IO.FileInfo fileInfo = new System.IO.FileInfo(fileName);
* Console.WriteLine(fileInfo.Length);
*/
// Console.WriteLine(string.Join("", file));
// AddressRepository aRepo = new AddressRepository();
// Address address = aRepo.Get(1);
/*
* FilesRepository fileRepo = new FilesRepository();
* Console.WriteLine(fileRepo.Get(1).FileName);
* Files fileWrite = fileRepo.Get(2);
* System.IO.File.WriteAllBytes(Path.Combine(@"C:\Users\lisse\Pictures\", fileWrite.FileName + "2"), fileWrite.FileByte);
*/
/*
* string fileName2 = @"C:\Users\lisse\Pictures\google_logo2.svg";
* System.IO.FileInfo fileInfo2 = new System.IO.FileInfo(fileName2);
* Files fileTest2 = new Files();
* fileTest2.Name = "test import";
* fileTest2.FileName = fileInfo2.Name;
* fileTest2.FileExension = fileInfo2.Extension;
* fileTest2.FileByte = System.IO.File.ReadAllBytes(fileName2);
* fileTest2.FileSize = fileInfo2.Length;
* fileTest2.CreateBy = 1;
* Console.WriteLine(fileRepo.Insert(fileTest2));
*/
/*
* string projectDirectory = @"C:\Users\lisse\Documents\Technofuturtic\Projet";
* string projectFilename = Path.Combine(projectDirectory, "ProjectFile.svg");
* string productFilename = Path.Combine(projectDirectory, "ProductFile.svg");
* byte[] projectByte = System.IO.File.ReadAllBytes(projectFilename);
* byte[] productByte = System.IO.File.ReadAllBytes(productFilename);
* string projectString = string.Empty;
* string productString = string.Empty;
*
* foreach (byte b in projectByte)
* {
* projectString = string.Concat(projectString, b.ToString());
* //Console.WriteLine(b.ToString());
* }
*
* foreach (byte b in productByte)
* {
* productString = string.Concat(productString, b.ToString());
* //Console.WriteLine(b.ToString());
* }
*
* Console.WriteLine(projectString);
*/
/*
* // ************ City ***********
* CitiesRepository cityR = new CitiesRepository();
* Cities cityId = cityR.Get(1);
* IEnumerable<Cities> cityByName = cityR.GetByName("lou");
* IEnumerable<Cities> cityByPostalCode = cityR.GetByPostalCode("7110");
* IEnumerable<Cities> cityByCountry = cityR.GetCityByCountry(21);
*/
/*
* // ************ Role ***********
* RoleRepository roleR = new RoleRepository();
* Roles role = roleR.Get(1);
*/
/*
* // ************ Account ***********
* AccountRepository accR = new AccountRepository();
* Account account = accR.Get(1);
* Account account1 = accR.GetAccountByLogin("dave");
* Account account2 = accR.GetAccountByLogin("davde");
*/
/*
* // ************ Supplier ***********
* SupplierRepository suppR = new SupplierRepository();
* Supplier supplier = suppR.Get(1);
*/
/*
* // ************ Project ***********
* ProjectRepository projectR = new ProjectRepository();
* Project project = projectR.Get(1);
* IEnumerable<Project> projectAccount = projectR.GetProjectByAccountId(1);
* IEnumerable<Project> projectByName = projectR.GetProjectByName("maison");
*/
/*
* // ************ Category ***********
* CategoryRepository catR = new CategoryRepository();
* Category cat = catR.Get(1);
*/
// ************ ContactInfo ***********
ContactInfoRepository ciR = new ContactInfoRepository();
ContactInfo ci = ciR.Get(1);
/*
* // ************ Product ***********
* ProductRepository productR = new ProductRepository();
* Product p1 = productR.Get(1);
* IEnumerable<Product> p2 = productR.GetAll();
* IEnumerable<Product> p3 = productR.GetByManufacturer("Buderus");
* IEnumerable<Product> p4 = productR.GetByName("Chaudière");
*/
// ************ ProductCategory ***********
ProductCategoryRepository pdcR = new ProductCategoryRepository();
IEnumerable <ProductCategory> pdc1 = pdcR.Get(1);
// ************ ProjectCategory ***********
ProjectCategoryRepository pjcR = new ProjectCategoryRepository();
IEnumerable <ProjectCategory> pjc1 = pjcR.Get(1);
CountryService countryService = new CountryService();
CitiesService citiesService = new CitiesService(countryService);
AddressService addressService = new AddressService(citiesService);
RolesService rolesService = new RolesService();
ContactInfoService contactInfoService = new ContactInfoService();
AccountService accServ = new AccountService(addressService, rolesService, contactInfoService);
Console.WriteLine(accServ.Get(1).Address.Street);
SupplierService supplierService = new SupplierService(addressService, contactInfoService);
BLL.Models.Supplier supplier = supplierService.Get(1);
FilesService filesService = new FilesService();
BLL.Models.Files file = filesService.Get(1);
CategoryService categoryService = new CategoryService();
ProductCategoryService productCategoryService = new ProductCategoryService(categoryService, filesService);
List <BLL.Models.ProductCategory> productCategory = productCategoryService.Get(1);
ProductService productService = new ProductService(productCategoryService);
ProjectCategoryProductService projectCategoryProductService = new ProjectCategoryProductService(productService, supplierService);
ProjectCategoryService projectCategoryService = new ProjectCategoryService(categoryService, filesService, projectCategoryProductService);
ProjectService projectService = new ProjectService(addressService, projectCategoryService);
BLL.Models.Project project = projectService.Get(1);
FilesRepository filesRepository = new FilesRepository();
byte[] fileByte = filesRepository.Download(1);
}
public List <ProjectCategoryModel> GetCategoriesForProject([FromRoute] int projectid)
{
return(ProjectCategoryService.GetProjectCategories(projectid, dbConn));
}
public string DeleteProjectCategory([FromRoute] int id)
{
return(ProjectCategoryService.DeleteProjectCategory(id, dbConn));
}
public ProjectCategoryController()
{
_UserService = new UserService();
_ProjectCategoryService = new ProjectCategoryService();
}
