loob/GiecChallenge
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First Commit

Browse Source
This commit is contained in:
Maxime Boulay
2024-12-23 08:05:29 +01:00
commit ba64ceb471
171 changed files with 654157 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

139
backend/GiecChallenge.test/Services/AlimentServiceTest.cs Normal file
View File

@@ -0,0 +1,139 @@
using Moq;
using GiecChallenge.Services;
using Microsoft.Extensions.Logging;
using AutoMapper;
using GiecChallenge.Models;
using GiecChallenge.Profiles;
namespace GiecChallenge.Tests
{
public class AlimentServiceTest
{
private Mock<ILogger<AlimentService>> _logger = null!;
private Mock<GiecChallengeContext> _context = null!;
private AlimentService _service = null!;
[SetUp]
public void Setup()
{
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new AlimentProfile());
cfg.AddProfile(new ProductProfile());
});
IMapper mapper = config.CreateMapper();
_logger = new Mock<ILogger<AlimentService>>();
_context = Common.GetContext();
_context.Setup(g => g.Languages).Returns(Common.GetMockDbSet<Language>(Common.GetLanguages()).Object);
_context.Setup(g => g.ProductUserTranslations).Returns(Common.GetMockDbSet<ProductUserTranslation>(Common.GetProductUserTranslations()).Object);
_context.Setup(g => g.ProductSubGroups).Returns(Common.GetMockDbSet<ProductSubGroup>(Common.GetProductSubGroup()).Object);
_context.Setup(g => g.Aliments).Returns(Common.GetMockDbSet<Aliment>(Common.GetAliments()).Object);
_service = new AlimentService(_logger.Object, mapper, _context.Object);
}
[Test]
public async Task GetAllAliments()
{
var result = await _service.GetAllAliments();
Assert.AreEqual(result.Count, Common.GetAliments().Count);
}
[Test]
[TestCase("tom", "1002")]
[TestCase("tomate", "1002")]
[TestCase("poire", "1004")]
public async Task GetByName(string name, string ciqual)
{
var result = await _service.GetAliments(name);
Assert.AreEqual(result.Any(re => re.ciqual_code == ciqual), true);
}
[Test]
[TestCase("pomme")]
[TestCase("coca")]
public async Task GetByNameNothing(string name)
{
var result = await _service.GetAliments(name);
Assert.AreEqual(result.Any(), false);
}
[Test]
[TestCase("1002")]
[TestCase("1003")]
public async Task GetAliment(string id)
{
var result = await _service.GetAliment(id);
Assert.AreEqual(Common.GetAliments().First(al => al.ciqual == id).ciqual, id);
}
[Test]
[TestCase("10000002")]
[TestCase("10000003")]
public void GetAlimentNothing(string id)
{
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.GetAliment(id));
Assert.That(ex!.Message, Is.EqualTo(string.Concat(id, " does not exist")));
}
[Test]
[TestCase("10000002")]
[TestCase("10000003")]
public async Task Create(string id)
{
var aliment = Common.GetAlimentTest("poire", id);
var alimentDto = Common.GetAlimentDtoTest("poire", id);
await _service.Create(alimentDto);
Assert.AreEqual(_context.Object.Aliments.Any(l => l.ciqual == id), true);
}
[Test]
[TestCase("1002")]
[TestCase("1003")]
public void CreateAlreadyExists(string id)
{
var aliment = Common.GetAlimentTest("poire", id);
var alimentDto = Common.GetAlimentDtoTest("poire", id);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Create(alimentDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat(id, " already exists")));
}
[Test]
[TestCase("1002")]
[TestCase("1003")]
public async Task Update(string id)
{
bool postIsOk = true;
var alimentDto = Common.GetAlimentDtoTest("poire", id);
try {
await _service.Update(alimentDto);
}
catch {
postIsOk = false;
}
Assert.AreEqual(postIsOk, true);
}
[Test]
[TestCase("10000002")]
[TestCase("10000003")]
public void UpdateDoesNotExists(string id)
{
var alimentDto = Common.GetAlimentDtoTest("poire", id);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(alimentDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Aliment does not exist")));
}
}
}

132
backend/GiecChallenge.test/Services/LanguageServiceTest.cs Normal file
View File

@@ -0,0 +1,132 @@
using Moq;
using GiecChallenge.Services;
using Microsoft.Extensions.Logging;
using AutoMapper;
using GiecChallenge.Models;
using GiecChallenge.Profiles;
namespace GiecChallenge.Tests
{
public class LanguageServiceTest
{
private Mock<ILogger<LanguageService>> _logger = null!;
private Mock<GiecChallengeContext> _context = null!;
private LanguageService _service = null!;
private List<LanguageDto> _allLanguagesDTO = null!;
private string _language = "FR";
[SetUp]
public void Setup()
{
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new LanguageProfile());
});
IMapper mapper = config.CreateMapper();
_logger = new Mock<ILogger<LanguageService>>();
_allLanguagesDTO = Common.GetLanguagesDto("Français", "English");
_context = Common.GetContext();
_context.Setup(g => g.Languages).Returns(Common.GetMockDbSet<Language>(Common.GetLanguages()).Object);
_context.Setup(g => g.LanguageLanguages).Returns(Common.GetMockDbSet<LanguageLanguage>(Common.GetLanguages().SelectMany(l => l.names).ToList()).Object);
_service = new LanguageService(_logger.Object, mapper, _context.Object);
}
[Test]
public async Task GetAllLanguages()
{
var result = await _service.GetAllLanguages();
Assert.AreEqual(result.Count, Common.GetLanguages().Count);
}
[Test]
[TestCase("Anglais")]
[TestCase("çais")]
public async Task GetByName(string name)
{
var result = await _service.GetLanguages(name, _language);
Assert.AreEqual(result.Any(re => re.names.Any(rer => rer.name.ToLower().Contains(name.ToLower()))), true);
}
[Test]
[TestCase("pomme")]
[TestCase("poire")]
public async Task GetByNameNothing(string name)
{
var result = await _service.GetLanguages(name, _language);
Assert.AreEqual(result.Any(), false);
}
[Test]
[TestCase("f3390acd-acf2-4ab9-8d39-25b216182320")]
[TestCase("0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
public async Task GetLanguage(Guid id)
{
var result = await _service.GetLanguage(id);
Assert.AreEqual(result!.id, id);
}
[Test]
[TestCase("46c619b1-1859-4665-bc8b-cf51eb30777e")]
[TestCase("eca28033-9954-498f-89d4-a911e40f5a33")]
public void GetLanguageNothing(Guid id)
{
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.GetLanguage(id));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Language does not exist")));
}
[Test]
[TestCase("IT", "Italien", "IT")]
[TestCase("ES", "Espagnol", "FR")]
public async Task Create(string isoCode, string name, string languageOfName)
{
var languageDto = Common.GetLanguageDtoTest(isoCode, name, languageOfName);
await _service.Create(languageDto);
Assert.AreEqual(_context.Object.Languages.Any(l => l.ISOCode == isoCode), true);
Assert.AreEqual(_context.Object.Languages.Any(l => l.ISOCode == isoCode && l.names.Any()), true);
}
[Test]
[TestCase("FR", "Français", "FR")]
[TestCase("EN", "English", "EN")]
public void CreateAlreadyExists(string isoCode, string name, string languageOfName)
{
var languageDto = Common.GetLanguageDtoTest(isoCode, name, languageOfName);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Create(languageDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Language already exists")));
}
[Test]
[TestCase("f3390acd-acf2-4ab9-8d39-25b216182320", "FR", "Italien", "FR")]
[TestCase("0b1307be-9ffd-4dcd-9431-4fe58b6420f7", "ES", "Espagnol", "FR")]
[TestCase("d7ee9249-1edc-4158-ad4d-9892fb703e47", "EN", "German", "EN")]
public async Task Update(Guid id, string isoCode, string name, string languageOfName)
{
var languageDto = Common.GetLanguageDtoTest(isoCode, name, languageOfName);
await _service.Update(id, languageDto);
Assert.True(_context.Object.Languages.Any(l => l.names.Any(ln => ln.language.ISOCode == languageOfName)));
}
[Test]
[TestCase("46c619b1-1859-4665-bc8b-cf51eb30777e", "FR", "Français")]
[TestCase("eca28033-9954-498f-89d4-a911e40f5a33", "EN", "English")]
public void UpdateDoesNotExists(Guid id, string isoCode, string name)
{
var languageDto = Common.GetLanguageDtoTest(isoCode, name);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(id, languageDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Language does not exist")));
}
}
}

130
backend/GiecChallenge.test/Services/ProductGroupServiceTest.cs Normal file
View File

@@ -0,0 +1,130 @@
using Moq;
using GiecChallenge.Services;
using Microsoft.Extensions.Logging;
using AutoMapper;
using GiecChallenge.Models;
using GiecChallenge.Profiles;
namespace GiecChallenge.Tests
{
public class ProductGroupServiceTest
{
private Mock<ILogger<GroupService>> _logger = null!;
private Mock<GiecChallengeContext> _context = null!;
private GroupService _service = null!;
[SetUp]
public void Setup()
{
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new GroupProfile());
});
IMapper mapper = config.CreateMapper();
_logger = new Mock<ILogger<GroupService>>();
_context = Common.GetContext();
_context.Setup(g => g.ProductGroups).Returns(Common.GetMockDbSet<ProductGroup>(Common.GetGroups()).Object);
_context.Setup(g => g.ProductGroupLanguages).Returns(Common.GetMockDbSet<ProductGroupLanguage>(Common.GetGroupLanguage()).Object);
_context.Setup(g => g.Languages).Returns(Common.GetMockDbSet<Language>(Common.GetLanguages()).Object);
_context.Setup(g => g.LanguageLanguages).Returns(Common.GetMockDbSet<LanguageLanguage>(Common.GetLanguages().SelectMany(l => l.names).ToList()).Object);
_service = new GroupService(_logger.Object, mapper, _context.Object);
}
[Test]
public async Task GetAllGroups()
{
var result = await _service.GetAllGroups();
Assert.AreEqual(result.Count, Common.GetGroups().Count);
}
[Test]
[TestCase("aliMent", "FR")]
[TestCase("tro", "EN")]
public async Task GetByName(string name, string language)
{
var result = await _service.GetGroups(name, language);
Assert.AreEqual(result.Any(re => re.names.Any(rer => rer.name.ToLower().Contains(name.ToLower()))), true);
}
[Test]
[TestCase("pomme", "FR")]
[TestCase("poire", "EN")]
[TestCase("aliMent", "EN")]
public async Task GetByNameNothing(string name, string language)
{
var result = await _service.GetGroups(name, language);
Assert.AreEqual(result.Any(), false);
}
[Test]
[TestCase("b21a6403-f428-454f-942d-dbd1fc3fa551")]
[TestCase("8f46bf6f-6cbf-47ac-8d51-039eabc820c3")]
public async Task GetGroup(Guid id)
{
var result = await _service.GetGroup(id);
Assert.AreEqual(result!.id, id);
}
[Test]
[TestCase("46c619b1-1859-4665-bc8b-cf51eb30777e")]
[TestCase("eca28033-9954-498f-89d4-a911e40f5a33")]
public void GetGroupNothing(Guid id)
{
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.GetGroup(id));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Group does not exist")));
}
[Test]
[TestCase("Transport", "f3390acd-acf2-4ab9-8d39-25b216182320")]
[TestCase("Commute", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
public async Task Create(string name, string language)
{
var groupDto = Common.GetGroupDtoTest(name, language);
await _service.Create(groupDto);
Assert.AreEqual(_context.Object.ProductGroups.Any(l => l.names.Any(ln => ln.name == name)), true);
}
[Test]
[TestCase("aliMent", "f3390acd-acf2-4ab9-8d39-25b216182320")]
[TestCase("ElectroniC device", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
public void CreateAlreadyExists(string name, string language)
{
var groupDto = Common.GetGroupDtoTest(name, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Create(groupDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Group already exists")));
}
[Test]
[TestCase("b21a6403-f428-454f-942d-dbd1fc3fa551", "Nourriture", "f3390acd-acf2-4ab9-8d39-25b216182320")]
[TestCase("8f46bf6f-6cbf-47ac-8d51-039eabc820c3", "Materiel electronique", "f3390acd-acf2-4ab9-8d39-25b216182320")]
public async Task Update(Guid id, string name, string isoCode)
{
var groupDto = Common.GetGroupDtoTest(name, isoCode);
await _service.Update(id, groupDto);
Assert.True(_context.Object.ProductGroups.Any(l => l.names.Any(ln => ln.name == name)));
}
[Test]
[TestCase("46c619b1-1859-4665-bc8b-cf51eb30777e", "f3390acd-acf2-4ab9-8d39-25b216182320", "Français")]
[TestCase("eca28033-9954-498f-89d4-a911e40f5a33", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7", "English")]
public void UpdateDoesNotExists(Guid id, string isoCode, string name)
{
var groupDto = Common.GetGroupDtoTest(isoCode, name);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(id, groupDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Group does not exist")));
}
}
}

334
backend/GiecChallenge.test/Services/ProductServiceTest.cs Normal file
View File

@@ -0,0 +1,334 @@
using Moq;
using GiecChallenge.Services;
using Microsoft.Extensions.Logging;
using AutoMapper;
using GiecChallenge.Models;
using GiecChallenge.Profiles;
namespace GiecChallenge.Tests
{
public class ProductServiceTest
{
private Mock<ILogger<ProductService>> _logger = null!;
private Mock<GiecChallengeContext> _context = null!;
private ProductService _service = null!;
private List<ProductDto> _allProductsDTO = null!;
private string _language = "f3390acd-acf2-4ab9-8d39-25b216182320";
[SetUp]
public void Setup()
{
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new ProductProfile());
});
IMapper mapper = config.CreateMapper();
_logger = new Mock<ILogger<ProductService>>();
_allProductsDTO = Common.GetProductsDto();
_context = Common.GetContext();
_context.Setup(g => g.Languages).Returns(Common.GetMockDbSet<Language>(Common.GetLanguages()).Object);
_context.Setup(g => g.ProductSubGroups).Returns(Common.GetMockDbSet<ProductSubGroup>(Common.GetProductSubGroup()).Object);
_context.Setup(g => g.ProductGroups).Returns(Common.GetMockDbSet<ProductGroup>(Common.GetProductGroup()).Object);
_context.Setup(g => g.ProductUserTranslations).Returns(Common.GetMockDbSet<ProductUserTranslation>(Common.GetProductUserTranslations()).Object);
_context.Setup(g => g.Products).Returns(Common.GetMockDbSet<Product>(Common.GetProducts()).Object);
_context.Setup(g => g.Users).Returns(Common.GetMockDbSet<User>(Common.GetUsers()).Object);
_service = new ProductService(_logger.Object, mapper, _context.Object);
}
[Test]
public async Task GetAllProducts()
{
var result = await _service.GetAllProducts();
Assert.AreEqual(result.Count, Common.GetProducts().Count);
}
[Test]
[TestCase("ip")]
[TestCase("pen", "EN")]
public async Task GetByName(string name, string language = "FR")
{
var result = await _service.GetProducts(name, language);
Assert.AreEqual(result.Any(re => re.names.Any(rer => rer.name.ToLower().Contains(name))), true);
}
[Test]
[TestCase("pomme")]
[TestCase("poire")]
public async Task GetByNameNothing(string name)
{
var result = await _service.GetProducts(name, _language);
Assert.AreEqual(result.Any(), false);
}
[Test]
[TestCase("e5f89b1d-171f-4460-a2cc-18e1534b5bae")]
[TestCase("526ea756-50da-486f-8a44-5e964f249c1e")]
public async Task GetProduct(Guid id)
{
var result = await _service.GetProduct(id);
Assert.AreEqual(result!.id, id);
}
[Test]
[TestCase("46c619b1-1859-4665-bc8b-cf51eb30777e")]
[TestCase("eca28033-9954-498f-89d4-a911e40f5a33")]
public void GetProductNothing(Guid id)
{
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.GetProduct(id));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Product does not exist")));
}
[Test]
[TestCase("991979cd-b95f-4e9a-85e7-e1f7ce6932fb", "526ea756-50da-486f-8a44-5e964f249c1e")]
[TestCase("3a69d206-7236-11ed-a1eb-0242ac120002", "e5f89b1d-171f-4460-a2cc-18e1534b5bae")]
public async Task GetProductByGroup(string group, Guid id)
{
var result = await _service.GetProductsByGroup(group);
Assert.AreEqual(result!.First().id, id);
}
[Test]
[TestCase("Voiture")]
[TestCase("Animal")]
public void GetProductByGroupBadValue(string group)
{
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.GetProductsByGroup(group));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Group ", group, " doesn't exist")));
}
[Test]
[TestCase("fd837d14-a085-11ed-a8fc-0242ac120002")]
[TestCase("fd837ea4-a085-11ed-a8fc-0242ac120002")]
public async Task GetProductByGroupNothing(string group)
{
var result = await _service.GetProductsByGroup(group);
Assert.AreEqual(result.Any(), false);
}
[Test]
[TestCase("04f3eb50-6119-487a-86a6-b6c24e620536", "e5f89b1d-171f-4460-a2cc-18e1534b5bae")]
[TestCase("4f52f771-7752-472f-921e-88824fc4c5d5", "526ea756-50da-486f-8a44-5e964f249c1e")]
public async Task GetProductBySubGroup(string subgroup, Guid id)
{
var result = await _service.GetProductsBySubGroup(subgroup);
Assert.AreEqual(result!.First().id, id);
}
[Test]
[TestCase("Voiture")]
[TestCase("Animal")]
public void GetProductBySubGroupBadValue(string subgroup)
{
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.GetProductsBySubGroup(subgroup));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Sub group ", subgroup, " doesn't exist")));
}
[Test]
[TestCase("db815ede-1764-46c4-9f37-7a80851930a2")]
[TestCase("fd83786e-a085-11ed-a8fc-0242ac120002")]
public async Task GetProductBySubGroupNothing(string subgroup)
{
var result = await _service.GetProductsBySubGroup(subgroup);
Assert.AreEqual(result.Any(), false);
}
[Test]
[TestCase("iPhone", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
[TestCase("Apple Watch", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
public async Task Create(string name, string language)
{
var productDto = Common.GetProductDtoTest(name, Common.GetProductSubGroup().First().id.ToString(), language);
await _service.Create(productDto);
Assert.AreEqual(_context.Object.Products.Any(l => l.names.Any(ln => ln.name == name)), true);
}
[Test]
[TestCase("iPhone", "0b1307be-9ffd-4dcd-9431-4fe58b6420d7")]
[TestCase("Apple Watch", "0b1307be-9ffd-4dcd-9431-4fe58b6420g7")]
public void CreateLanguageBadValue(string name, string language)
{
var productDto = Common.GetProductDtoTest(name, Common.GetProductSubGroup().First().id.ToString(), language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Create(productDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Language ", language, " doesn't exist")));
}
[Test]
[TestCase("iPhone", "0b1307be-9ffd-4dcd-9431-4fe58b6420d7")]
[TestCase("Apple Watch", "0b1307be-9ffd-4dcd-9431-4fe58b6420g7")]
public void CreateLanguageNotExists(string name, string language)
{
var productDto = Common.GetProductDtoTest(name, Common.GetProductSubGroup().First().id.ToString(), language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Create(productDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Language ", language, " doesn't exist")));
}
[Test]
[TestCase("iPhone", "Tablet", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
[TestCase("Apple Watch", "Watch", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
public void CreateGroupNotExists(string name, string group, string language)
{
var productDto = Common.GetProductDtoTest(name, group, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Create(productDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Group does not exist")));
}
[Test]
[TestCase("iPad", "04f3eb50-6119-487a-86a6-b6c24e620536", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
[TestCase("chou vert", "4f52f771-7752-472f-921e-88824fc4c5d5", "f3390acd-acf2-4ab9-8d39-25b216182320")]
public void CreateAlreadyExists(string name, string group, string language)
{
var productDto = Common.GetProductDtoTest(name, group, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Create(productDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Product already exists")));
}
[Test]
[TestCase("e5f89b1d-171f-4460-a2cc-18e1534b5bae", "iPhone", "04f3eb50-6119-487a-86a6-b6c24e620536", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
[TestCase("526ea756-50da-486f-8a44-5e964f249c1e", "Poire", "4f52f771-7752-472f-921e-88824fc4c5d5", "f3390acd-acf2-4ab9-8d39-25b216182320")]
public async Task Update(Guid id, string name, string group, string language)
{
bool postIsOk = true;
var productDto = Common.GetProductDtoTest(name, group, language);
try {
await _service.Update(id, productDto);
}
catch {
postIsOk = false;
}
Assert.AreEqual(postIsOk, true);
}
[Test]
[TestCase("46c619b1-1859-4665-bc8b-cf51eb30777e")]
[TestCase("eca28033-9954-498f-89d4-a911e40f5a33")]
public void UpdateDoesNotExists(Guid id)
{
var productDto = Common.GetProductDtoTest("poire", "4f52f771-7752-472f-921e-88824fc4c5d5", "f3390acd-acf2-4ab9-8d39-25b216182320");
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(id, productDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Product does not exist")));
}
[Test]
[TestCase("e5f89b1d-171f-4460-a2cc-18e1534b5bae", "iPhone", "04f3eb50-6119-487a-86a6-b6c24e620536", "CN")]
[TestCase("526ea756-50da-486f-8a44-5e964f249c1e", "Poire", "4f52f771-7752-472f-921e-88824fc4c5d5", "FI")]
public void UpdateLanguageNotExists(Guid id, string name, string group, string language)
{
var productDto = Common.GetProductDtoTest(name, group, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(id, productDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Language ", language, " doesn't exist")));
}
[Test]
[TestCase("e5f89b1d-171f-4460-a2cc-18e1534b5bae", "iPhone", "Phone", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
[TestCase("526ea756-50da-486f-8a44-5e964f249c1e", "Poire", "Alcool", "f3390acd-acf2-4ab9-8d39-25b216182320")]
public void UpdateGroupNotExists(Guid id, string name, string group, string language)
{
var productDto = Common.GetProductDtoTest(name, group, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(id, productDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Group does not exist")));
}
[Test]
[TestCase("Galaxy Tab", "0a891394-be17-473b-9924-eccaf6ce79ed", "e5f89b1d-171f-4460-a2cc-18e1534b5bae")]
[TestCase("Waterman", "0a891394-be17-473b-9924-eccaf6ce79ed", "526ea756-50da-486f-8a44-5e964f249c1e")]
public async Task CreateUserTranslation(string name, string user, string product)
{
var productUserTranslationDTO = Common.GetProductTranslationDtoTest(name, user, product, string.Empty);
await _service.CreateTranslation(productUserTranslationDTO);
Assert.True(_context.Object.ProductUserTranslations.Any(l => l.name == name && l.user.id.ToString() == user && l.product.id.ToString() == product));
}
[Test]
[TestCase("Galaxy Tab", "0a891394-be17-473b-9924-eccafwce79ed", "e5f89b1d-171f-4460-a2cc-18e1534b5bae")]
[TestCase("Waterman", "0a891394-be17-473b-9924-eccaf6ci79ed", "526ea756-50da-486f-8a44-5e964f249c1e")]
public void CreateUserTranslationUserNotExist(string name, string user, string product)
{
var productUserTranslationDTO = Common.GetProductTranslationDtoTest(name, user, product, string.Empty);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.CreateTranslation(productUserTranslationDTO));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("User does not exist")));
}
[Test]
[TestCase("Galaxy Tab", "0a891394-be17-473b-9924-eccaf6ce79ed", "e5f89b1d-171f-4460-a2cd-18e1534b5bae")]
[TestCase("Waterman", "0a891394-be17-473b-9924-eccaf6ce79ed", "526ea756-50da-486f-8a4y-5e964f249c1e")]
public void CreateUserTranslationProductNotExists(string name, string user, string product)
{
var productUserTranslationDTO = Common.GetProductTranslationDtoTest(name, user, product, string.Empty);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.CreateTranslation(productUserTranslationDTO));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Product does not exist")));
}
[Test]
[TestCase("tomate", "0a891394-be17-473b-9924-eccaf6ce79ed", "479d91d4-8f93-433f-8b4c-b5b08c12db5c")]
[TestCase("chou", "9beb47ab-0def-437c-b510-02d8f9623ebb", "5823ec98-2726-4b39-b01e-8453bbde5524")]
public async Task UpdateUserTranslation(string name, string user, string id)
{
var productUserTranslationDTO = Common.GetProductTranslationDtoTest(name, string.Empty, string.Empty, id);
var previousName = _context.Object.ProductUserTranslations.First(l => l.id == Guid.Parse(id)).name;
await _service.UpdateTranslation(productUserTranslationDTO, Guid.Parse(user));
Assert.AreNotEqual(_context.Object.ProductUserTranslations.First(l => l.id == Guid.Parse(id)).name, previousName);
}
[Test]
[TestCase("tomate", "0a891394-be17-473b-9924-eccaf6ce79ed", "f917a5bf-4a96-496b-90cc-ad24d6d4f4fe")]
[TestCase("chou", "9beb47ab-0def-437c-b510-02d8f9623ebb", "debc6de1-48ce-430c-b4e4-0ab5024272f4")]
public void UpdateUserTranslationNotExists(string name, string user, string id)
{
var productUserTranslationDTO = Common.GetProductTranslationDtoTest(name, string.Empty, string.Empty, id);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.UpdateTranslation(productUserTranslationDTO, Guid.Parse(user)));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Translation doesn't exist")));
}
[Test]
[TestCase("tomate", "0a891394-be17-473b-9924-eccaf6ce79ed", "479d91d4-8f93-433f-8b4c-b5b08c12db5c")]
[TestCase("chou", "9beb47ab-0def-437c-b510-02d8f9623ebb", "5823ec98-2726-4b39-b01e-8453bbde5524")]
public async Task DeleteUserTranslation(string name, string user, string id)
{
var productUserTranslationDTO = Common.GetProductTranslationDtoTest(name, string.Empty, string.Empty, id);
await _service.DeleteTranslation(productUserTranslationDTO, Guid.Parse(user));
Assert.IsTrue(_context.Object.ProductUserTranslations.Any(l => l.id == Guid.Parse(id)));
}
[Test]
[TestCase("tomate", "0a891394-be17-473b-9924-eccaf6ce79ed", "f917a5bf-4a96-496b-90cc-ad24d6d4f4fe")]
[TestCase("chou", "9beb47ab-0def-437c-b510-02d8f9623ebb", "debc6de1-48ce-430c-b4e4-0ab5024272f4")]
public void DeleteUserTranslationNotExists(string name, string user, string id)
{
var productUserTranslationDTO = Common.GetProductTranslationDtoTest(name, string.Empty, string.Empty, id);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.DeleteTranslation(productUserTranslationDTO, Guid.Parse(user)));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Translation does not exist")));
}
}
}

176
backend/GiecChallenge.test/Services/ProductSubGroupServiceTest.cs Normal file
View File

@@ -0,0 +1,176 @@
using Moq;
using GiecChallenge.Services;
using Microsoft.Extensions.Logging;
using AutoMapper;
using GiecChallenge.Models;
using GiecChallenge.Profiles;
namespace GiecChallenge.Tests
{
public class ProductSubGroupServiceTest
{
private Mock<ILogger<SubGroupService>> _logger = null!;
private Mock<GiecChallengeContext> _context = null!;
private SubGroupService _service = null!;
private List<GroupDto> _allGroupsDTO = null!;
private string _Group = "FR";
[SetUp]
public void Setup()
{
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new SubGroupProfile());
});
IMapper mapper = config.CreateMapper();
_logger = new Mock<ILogger<SubGroupService>>();
_allGroupsDTO = Common.GetGroupsDto("Français", "English");
_context = Common.GetContext();
_context.Setup(g => g.ProductGroups).Returns(Common.GetMockDbSet<ProductGroup>(Common.GetGroups()).Object);
_context.Setup(g => g.ProductSubGroups).Returns(Common.GetMockDbSet<ProductSubGroup>(Common.GetSubGroups()).Object);
_context.Setup(g => g.ProductSubGroupLanguages).Returns(Common.GetMockDbSet<ProductSubGroupLanguage>(Common.GetSubGroupLanguage()).Object);
_context.Setup(g => g.Languages).Returns(Common.GetMockDbSet<Language>(Common.GetLanguages()).Object);
_service = new SubGroupService(_logger.Object, mapper, _context.Object);
}
[Test]
public async Task GetAllGroups()
{
var result = await _service.GetAllSubGroups();
Assert.AreEqual(result.Count, Common.GetGroups().Count);
}
[Test]
[TestCase("Boisson")]
[TestCase("hon")]
public async Task GetByName(string name)
{
var result = await _service.GetSubGroups(name, _Group);
Assert.AreEqual(result.Any(re => re.names.Any(rer => rer.name.ToLower().Contains(name.ToLower()))), true);
}
[Test]
[TestCase("vian")]
[TestCase("poire")]
public async Task GetByNameNothing(string name)
{
var result = await _service.GetSubGroups(name, _Group);
Assert.AreEqual(result.Any(), false);
}
[Test]
[TestCase("bf0cc5d3-2b4f-4761-ac4f-5dc25005aa32")]
[TestCase("1dda078c-d158-4078-aa8e-981d5ac5cd57")]
public async Task GetSubGroup(Guid id)
{
var result = await _service.GetSubGroup(id);
Assert.AreEqual(result!.id, id);
}
[Test]
[TestCase("46c619b1-1859-4665-bc8b-cf51eb30777e")]
[TestCase("eca28033-9954-498f-89d4-a911e40f5a33")]
public void GetSubGroupNothing(Guid id)
{
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.GetSubGroup(id));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Sub Group does not exist")));
}
[Test]
[TestCase("Viande", "b21a6403-f428-454f-942d-dbd1fc3fa551", "f3390acd-acf2-4ab9-8d39-25b216182320")]
[TestCase("Tablet", "8f46bf6f-6cbf-47ac-8d51-039eabc820c3", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
public async Task Create(string name, string groupOfName, string language)
{
var subGroupDto = Common.GetSubGroupDtoTest(name, groupOfName, language);
await _service.Create(subGroupDto);
Assert.AreEqual(_context.Object.ProductSubGroups.Any(l => l.names.Any(ln => ln.name == name)), true);
}
[Test]
[TestCase("Boisson", "b21a6403-f428-454f-942d-dbd1fc3fa551", "f3390acd-acf2-4ab9-8d39-25b216182320")]
[TestCase("Smartphone", "8f46bf6f-6cbf-47ac-8d51-039eabc820c3", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
public void CreateAlreadyExists(string name, string groupOfName, string language)
{
var subGroupDto = Common.GetSubGroupDtoTest(name, groupOfName, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Create(subGroupDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Sub Group already exists")));
}
[Test]
[TestCase("bf0cc5d3-2b4f-4761-ac4f-5dc25005aa32", "Tablet", "8f46bf6f-6cbf-47ac-8d51-039eabc820c3", "f3390acd-acf2-4ab9-8d39-25b216182320")]
[TestCase("1dda078c-d158-4078-aa8e-981d5ac5cd57", "Viande", "b21a6403-f428-454f-942d-dbd1fc3fa551", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
public async Task Update(Guid id, string name, string groupOfName, string language)
{
var subGroupDto = Common.GetSubGroupDtoTest(name, groupOfName, language);
await _service.Update(id, subGroupDto);
Assert.True(_context.Object.ProductSubGroups.Any(l => l.names.Any(ln => ln.name == name)));
}
[Test]
[TestCase("46c619b1-1859-4665-bc8b-cf51eb30777e", "Tablet", "991979cd-b95f-4e9a-85e7-e1f7ce6932fb", "f3390acd-acf2-4ab9-8d39-25b216182320")]
[TestCase("eca28033-9954-498f-89d4-a911e40f5a33", "Viande", "3a69d206-7236-11ed-a1eb-0242ac120002", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
public void UpdateDoesNotExists(Guid id, string isoCode, string name, string language)
{
var subGroupDto = Common.GetSubGroupDtoTest(isoCode, name, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(id, subGroupDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Sub Group does not exist")));
}
[Test]
[TestCase("bf0cc5d3-2b4f-4761-ac4f-5dc25005aa32", "Tablet", "Elec", "FR")]
[TestCase("1dda078c-d158-4078-aa8e-981d5ac5cd57", "Viande", "Bouffe", "EN")]
public void UpdateWithGroupBadFormat(Guid id, string isoCode, string name, string language)
{
var subGroupDto = Common.GetSubGroupDtoTest(isoCode, name, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(id, subGroupDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat(name, " is not valid")));
}
[Test]
[TestCase("bf0cc5d3-2b4f-4761-ac4f-5dc25005aa32", "Tablet", "bf0cc5d3-2b4f-4761-ac4f-5dc25005aa32", "f3390acd-acf2-4ab9-8d39-25b216182320")]
[TestCase("1dda078c-d158-4078-aa8e-981d5ac5cd57", "Viande", "1dda078c-d158-4078-aa8e-981d5ac5cd57", "0b1307be-9ffd-4dcd-9431-4fe58b6420f7")]
public void UpdateWithGroupUnknown(Guid id, string isoCode, string name, string language)
{
var subGroupDto = Common.GetSubGroupDtoTest(isoCode, name, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(id, subGroupDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Group does not exist")));
}
[Test]
[TestCase("bf0cc5d3-2b4f-4761-ac4f-5dc25005aa32", "Tablet", "991979cd-b95f-4e9a-85e7-e1f7ce6932fb", "IT")]
[TestCase("1dda078c-d158-4078-aa8e-981d5ac5cd57", "Viande", "3a69d206-7236-11ed-a1eb-0242ac120002", "ES")]
public void UpdateWithLanguageBadValue(Guid id, string isoCode, string name, string language)
{
var subGroupDto = Common.GetSubGroupDtoTest(isoCode, name, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(id, subGroupDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat(language, " is not valid")));
}
[Test]
[TestCase("bf0cc5d3-2b4f-4761-ac4f-5dc25005aa32", "Tablet", "991979cd-b95f-4e9a-85e7-e1f7ce6932fb", "991979cd-b95f-4e9a-85e7-e1f7ce6932fb")]
[TestCase("1dda078c-d158-4078-aa8e-981d5ac5cd57", "Viande", "3a69d206-7236-11ed-a1eb-0242ac120002", "3a69d206-7236-11ed-a1eb-0242ac120001")]
public void UpdateWithLanguageUnknown(Guid id, string isoCode, string name, string language)
{
var subGroupDto = Common.GetSubGroupDtoTest(isoCode, name, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(id, subGroupDto));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Language ", language, " doesn't exist")));
}
}
}

384
backend/GiecChallenge.test/Services/PurchaseServiceTest.cs Normal file
View File

@@ -0,0 +1,384 @@
using Moq;
using GiecChallenge.Services;
using Microsoft.Extensions.Logging;
using AutoMapper;
using GiecChallenge.Models;
using GiecChallenge.Profiles;
namespace GiecChallenge.Tests
{
public class PurchaseServiceTest
{
private Mock<ILogger<PurchaseService>> _logger = null!;
private Mock<GiecChallengeContext> _context = null!;
private PurchaseService _service = null!;
private List<UserDto> _allUsersDTO = null!;
[SetUp]
public void Setup()
{
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new PurchaseProfile());
});
IMapper mapper = config.CreateMapper();
_logger = new Mock<ILogger<PurchaseService>>();
_context = Common.GetContext();
_context.Setup(x => x.SetEntityStateModified(It.IsAny<Purchase>()));
_context.Setup(g => g.Purchases).Returns(Common.GetMockDbSet<Purchase>(Common.GetPurchases()).Object);
_context.Setup(g => g.Products).Returns(Common.GetMockDbSet<Product>(Common.GetProducts()).Object);
_context.Setup(g => g.ProductPurchases).Returns(Common.GetMockDbSet<ProductPurchase>(Common.GetProductPurchases()).Object);
_context.Setup(g => g.ProductUserTranslations).Returns(Common.GetMockDbSet<ProductUserTranslation>(Common.GetProductUserTranslations()).Object);
_context.Setup(g => g.Users).Returns(Common.GetMockDbSet<User>(Common.GetUsers()).Object);
_context.Setup(g => g.Currencies).Returns(Common.GetMockDbSet<Currency>(Common.GetCurrencies()).Object);
_context.Setup(g => g.CarbonLoans).Returns(Common.GetMockDbSet<CarbonLoan>(Common.GetCarbonLoans()).Object);
_service = new PurchaseService(_logger.Object, mapper, _context.Object);
}
[Test]
[TestCase("0a891394-be17-473b-9924-eccaf6ce79ed")]
[TestCase("9beb47ab-0def-437c-b510-02d8f9623ebb")]
public async Task GetAll(string idUser)
{
var result = await _service.GetAll(Guid.Parse(idUser));
Assert.AreEqual(_context.Object.Purchases.Count(u => u.user.id == Guid.Parse(idUser)), result.Count());
}
[Test]
[TestCase("9a3f9eb6-1f46-46b5-aa66-b0e3d0b37c82")]
[TestCase("d89b6c34-ae14-43f6-b5e0-26f6265a9bd2")]
public void GetAllUserNotCorrect(string idUser)
{
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.GetAll(Guid.Parse(idUser)));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Nice try")));
}
[Test]
[TestCase("0a891394-be17-473b-9924-eccaf6ce79ed", "30/11/2021", "05/01/2022", 2)]
[TestCase("0a891394-be17-473b-9924-eccaf6ce79ed", "30/11/2021", "02/01/2022", 1)]
[TestCase("9beb47ab-0def-437c-b510-02d8f9623ebb", "30/11/2021", "05/01/2022", 1)]
[TestCase("9beb47ab-0def-437c-b510-02d8f9623ebb", "05/11/2022", "06/11/2022", 0)]
public async Task GetByDate(string idUser, string dateBegin, string dateEnd, int expectedResult)
{
var result = await _service.GetBetweenDate(Guid.Parse(idUser), DateTime.Parse(dateBegin), DateTime.Parse(dateEnd));
Assert.AreEqual(expectedResult, result.Count());
}
[Test]
[TestCase("9a3f9eb6-1f46-46b5-aa66-b0e3d0b37c82", "30/11/2021", "05/01/2022", 2)]
[TestCase("d89b6c34-ae14-43f6-b5e0-26f6265a9bd2", "30/11/2021", "05/01/2022", 1)]
public void GetUserNotCorrect(string idUser, string dateBegin, string dateEnd, int expectedResult)
{
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.GetBetweenDate(Guid.Parse(idUser), DateTime.Parse(dateBegin), DateTime.Parse(dateEnd)));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Nice try")));
}
[Test]
[TestCase("05/11/2023",
"0a891394-be17-473b-9924-eccaf6ce79ed",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.0, 12.2},
new[] {1.2, 2.3})]
[TestCase("07/12/2023",
"9beb47ab-0def-437c-b510-02d8f9623ebb",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.0, 12.2},
new[] {3, 4.3})]
public async Task Create(DateTime date, string idUser, string[] products, string[] currencies, double[] prices, double[] quantities)
{
var purchaseToTest = Common.GetPurchaseDto(date, products.ToList(), currencies.ToList(), prices.ToList(), quantities.ToList());
await _service.Create(Guid.Parse(idUser), purchaseToTest);
var purchase = _context.Object.Purchases.First(u => u.datePurchase == date);
foreach (string product in products) {
Assert.IsTrue(purchase.products.Any(p => p.product.id == Guid.Parse(product)));
}
}
[Test]
[TestCase("01/01/2023",
"9a3f9eb6-1f46-46b5-aa66-b0e3d0b37c82",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.2, 12.2},
new[] {1.2, 2.3})]
[TestCase("01/01/2023",
"d89b6c34-ae14-43f6-b5e0-26f6265a9bd2",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.2, 12.0},
new[] {1.2, 2.3})]
public void CreateUserNotExists(DateTime date, string idUser, string[] products, string[] currencies, double[] prices, double[] quantities)
{
var purchaseToTest = Common.GetPurchaseDto(date, products.ToList(), currencies.ToList(), prices.ToList(), quantities.ToList());
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Create(Guid.Parse(idUser), purchaseToTest));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Nice try")));
}
[Test]
[TestCase("01/01/2023",
"0a891394-be17-473b-9924-eccaf6ce79ed",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "5a39736d-de7b-4b26-b4c6-b5841a52ddbf"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.2, 12.2},
new[] {1.2, 2.3})]
[TestCase("01/01/2023",
"9beb47ab-0def-437c-b510-02d8f9623ebb",
new[] {"4ec6db81-f8e0-4343-9973-f6a91e4d4c29", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.2, 12.2},
new[] {1.2, 2.3})]
public void CreateProductNotExists(DateTime date, string idUser, string[] products, string[] currencies, double[] prices, double[] quantities)
{
var purchaseToTest = Common.GetPurchaseDto(date, products.ToList(), currencies.ToList(), prices.ToList(), quantities.ToList());
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Create(Guid.Parse(idUser), purchaseToTest));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Product does not exist")));
}
[Test]
[TestCase("01/01/2023",
"0a891394-be17-473b-9924-eccaf6ce79ed",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"f150f3ca-1a18-40e1-a01a-fad22724514a", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.2, 12.2},
new[] {1.2, 2.3})]
[TestCase("01/01/2023",
"9beb47ab-0def-437c-b510-02d8f9623ebb",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "f2672cf5-761e-4f5a-8fc2-b3264fc5dd0d"},
new[] {15.2, 12.2},
new[] {1.2, 2.3})]
public void CreateCurrencyNotExists(DateTime date, string idUser, string[] products, string[] currencies, double[] prices, double[] quantities)
{
var purchaseToTest = Common.GetPurchaseDto(date, products.ToList(), currencies.ToList(), prices.ToList(), quantities.ToList());
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Create(Guid.Parse(idUser), purchaseToTest));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Currency does not exist")));
}
[Test]
[TestCase("01/01/2023",
"0a891394-be17-473b-9924-eccaf6ce79ed",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {-5, 1.22},
new[] {1.2, 2.3})]
[TestCase("01/01/2023",
"9beb47ab-0def-437c-b510-02d8f9623ebb",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {1.25, -1},
new[] {1.2, 2.3})]
public void CreatePriceNotCorrect(DateTime date, string idUser, string[] products, string[] currencies, double[] prices, double[] quantities)
{
var purchaseToTest = Common.GetPurchaseDto(date, products.ToList(), currencies.ToList(), prices.ToList(), quantities.ToList());
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Create(Guid.Parse(idUser), purchaseToTest));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Price must be superior than 0")));
}
[Test]
[TestCase("01/01/2023",
"0a891394-be17-473b-9924-eccaf6ce79ed",
new string[] {},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {-5, 1.22},
new[] {1.2, 2.3})]
[TestCase("01/01/2023",
"9beb47ab-0def-437c-b510-02d8f9623ebb",
new string[] {},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {1.25, -1},
new[] {1.2, 2.3})]
public void CreateNoProduct(DateTime date, string idUser, string[] products, string[] currencies, double[] prices, double[] quantities)
{
var purchaseToTest = Common.GetPurchaseDto(date, products.ToList(), currencies.ToList(), prices.ToList(), quantities.ToList());
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Create(Guid.Parse(idUser), purchaseToTest));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("No product selected")));
}
[Test]
[TestCase("01/01/2023",
"e2075166-6f2c-4172-8906-2f100a6a1456",
"0a891394-be17-473b-9924-eccaf6ce79ed",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.0, 12.2},
new[] {1.2, 2.3})]
[TestCase("01/01/2023",
"51e6eec0-d9fd-47fc-830a-88d1e6638b88",
"9beb47ab-0def-437c-b510-02d8f9623ebb",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.0, 12.2},
new[] {3, 4.51})]
[TestCase("01/01/2023",
"51e6eec0-d9fd-47fc-830a-88d1e6638b88",
"9beb47ab-0def-437c-b510-02d8f9623ebb",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.0, 12.2},
new[] {5.6, 6.7})]
public async Task Update(DateTime date, string idPurchase, string idUser, string[] products, string[] currencies, double[] prices, double[] quantities)
{
var purchaseToTest = Common.GetPurchaseDto(date, products.ToList(), currencies.ToList(), prices.ToList(), quantities.ToList());
purchaseToTest.id = Guid.Parse(idPurchase);
await _service.Update(Guid.Parse(idUser), purchaseToTest);
var purchase = _context.Object.Purchases.First(p => p.id == Guid.Parse(idPurchase));
foreach (string product in products) {
Assert.IsTrue(purchase.products.Any(p => p.product.id == Guid.Parse(product)));
}
}
[Test]
[TestCase("01/01/2023",
"e2075166-6f2c-4172-8906-2f100a6a1456",
"9a3f9eb6-1f46-46b5-aa66-b0e3d0b37c82",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.2, 12.2},
new[] {1.2, 2.3})]
[TestCase("01/01/2023",
"51e6eec0-d9fd-47fc-830a-88d1e6638b88",
"d89b6c34-ae14-43f6-b5e0-26f6265a9bd2",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.2, 12.0},
new[] {1.2, 2.3})]
[TestCase("01/01/2023",
"e2075166-6f2c-4172-8906-2f100a6a1456",
"9beb47ab-0def-437c-b510-02d8f9623ebb",
new string[] {},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {-5, 1.22},
new[] {1.2, 2.3})]
[TestCase("01/01/2023",
"51e6eec0-d9fd-47fc-830a-88d1e6638b88",
"0a891394-be17-473b-9924-eccaf6ce79ed",
new string[] {},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {1.25, -1},
new[] {1.2, 2.3})]
public void UpdateUserNotExists(DateTime date, string idPurchase, string idUser, string[] products, string[] currencies, double[] prices, double[] quantities)
{
var purchaseToTest = Common.GetPurchaseDto(date, products.ToList(), currencies.ToList(), prices.ToList(), quantities.ToList());
purchaseToTest.id = Guid.Parse(idPurchase);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(Guid.Parse(idUser), purchaseToTest));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Purchase does not exist")));
}
[Test]
[TestCase("01/01/2023",
"e2075166-6f2c-4172-8906-2f100a6a1456",
"0a891394-be17-473b-9924-eccaf6ce79ed",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "5a39736d-de7b-4b26-b4c6-b5841a52ddbf"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.2, 12.2},
new[] {1.2, 2.3})]
[TestCase("01/01/2023",
"51e6eec0-d9fd-47fc-830a-88d1e6638b88",
"9beb47ab-0def-437c-b510-02d8f9623ebb",
new[] {"4ec6db81-f8e0-4343-9973-f6a91e4d4c29", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.2, 12.2},
new[] {1.2, 2.3})]
public void UpdateProductNotExists(DateTime date, string idPurchase, string idUser, string[] products, string[] currencies, double[] prices, double[] quantities)
{
var purchaseToTest = Common.GetPurchaseDto(date, products.ToList(), currencies.ToList(), prices.ToList(), quantities.ToList());
purchaseToTest.id = Guid.Parse(idPurchase);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(Guid.Parse(idUser), purchaseToTest));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Product does not exist")));
}
[Test]
[TestCase("01/01/2023",
"e2075166-6f2c-4172-8906-2f100a6a1456",
"0a891394-be17-473b-9924-eccaf6ce79ed",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"f150f3ca-1a18-40e1-a01a-fad22724514a", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {15.2, 12.2},
new[] {1.2, 2.3})]
[TestCase("01/01/2023",
"51e6eec0-d9fd-47fc-830a-88d1e6638b88",
"9beb47ab-0def-437c-b510-02d8f9623ebb",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "f2672cf5-761e-4f5a-8fc2-b3264fc5dd0d"},
new[] {15.2, 12.2},
new[] {1.2, 2.3})]
public void UpdateCurrencyNotExists(DateTime date, string idPurchase, string idUser, string[] products, string[] currencies, double[] prices, double[] quantities)
{
var purchaseToTest = Common.GetPurchaseDto(date, products.ToList(), currencies.ToList(), prices.ToList(), quantities.ToList());
purchaseToTest.id = Guid.Parse(idPurchase);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(Guid.Parse(idUser), purchaseToTest));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Currency does not exist")));
}
[Test]
[TestCase("01/01/2023",
"e2075166-6f2c-4172-8906-2f100a6a1456",
"0a891394-be17-473b-9924-eccaf6ce79ed",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {-5, 1.22},
new[] {1.2, 2.3})]
[TestCase("01/01/2023",
"51e6eec0-d9fd-47fc-830a-88d1e6638b88",
"9beb47ab-0def-437c-b510-02d8f9623ebb",
new[] {"e5f89b1d-171f-4460-a2cc-18e1534b5bae", "526ea756-50da-486f-8a44-5e964f249c1e"},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {1.25, -1},
new[] {1.2, 2.3})]
public void UpdatePriceNotCorrect(DateTime date, string idPurchase, string idUser, string[] products, string[] currencies, double[] prices, double[] quantities)
{
var purchaseToTest = Common.GetPurchaseDto(date, products.ToList(), currencies.ToList(), prices.ToList(), quantities.ToList());
purchaseToTest.id = Guid.Parse(idPurchase);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(Guid.Parse(idUser), purchaseToTest));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Price must be superior than 0")));
}
[Test]
[TestCase("01/01/2023",
"e2075166-6f2c-4172-8906-2f100a6a1456",
"0a891394-be17-473b-9924-eccaf6ce79ed",
new string[] {},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {-5, 1.22},
new[] {1.2, 2.3})]
[TestCase("01/01/2023",
"51e6eec0-d9fd-47fc-830a-88d1e6638b88",
"9beb47ab-0def-437c-b510-02d8f9623ebb",
new string[] {},
new[] {"1a7d6616-dfd1-47c8-ba42-2b12e71c43af", "1a7d6616-dfd1-47c8-ba42-2b12e71c43af"},
new[] {1.25, -1},
new[] {1.2, 2.3})]
public void UpdateNoProduct(DateTime date, string idPurchase, string idUser, string[] products, string[] currencies, double[] prices, double[] quantities)
{
var purchaseToTest = Common.GetPurchaseDto(date, products.ToList(), currencies.ToList(), prices.ToList(), quantities.ToList());
purchaseToTest.id = Guid.Parse(idPurchase);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Update(Guid.Parse(idUser), purchaseToTest));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("No product selected")));
}
[Test]
[TestCase("0a891394-be17-473b-9924-eccaf6ce79ed",
"01/01/2022",
"\nPomme de Terre Monalisa\n1 × 2.5 kg\n3.90 €\n \n\nAubergine\n1 × 400 g\n2.20 €\n \n\nCarottes\n1 × 1 kg\n2.20 €\n \n\nOignons Jaune\n1 × 500 g\n1.40 €\n \n\nPotimarron\n2 × 1.2 kg\n7.60 €\n \n\nPersil\n1 × 1\n1.40 €\n \n\nPatate Douce\n2 × 500 g\n5.60 €\n \nEARL LA POMME DORET\n \n\nPoire Conference\n1 × 1 kg\n2.20 €\n \n\nPomme Golden\n1 × 1 kg\n2.00 €\n \nEARL BERGERIE DE BAISENAZ\n \n\nFlan de Brebis Vanille\n3 × (2 × 12.5 cL)\n8.16 €\n \n\nYaourt de Brebis Fraise\n1 × (2 × 125 g)\n2.60 €\n \n\nYaourt de Brebis Fruits Des Bois\n1 × (2 × 125 g)\n2.60 €\n \nGoûter Desserts\n \n\nFarine de Blé T65 Label Rouge\n1 × (1 × 1 kg)\n2.00 €\n \n\nFarine de Blé T80 Bio\n1 × (1 × 1 kg)\n2.40 €\n \n\nSucette Chocolat Au Lait\n1 × 15 g\n1.50 €\n \n\nTablette de Chocolat Lait Afrique\n1 × (1 × 100 g)\n5.50 €\n \nGAEC les Maillets\n \n\nFv- Le Frais de Vache\n1 × 170 g\n2.00 €",
0)]
[TestCase("0a891394-be17-473b-9924-eccaf6ce79ed",
"01/01/2022",
"\nchou vert\n1 × 2.5 kg\n3.90 €\n \n\ntomate de saison\n1 × 400 g\n2.20 €\n \n\nCarottes\n1 × 1 kg\n2.20 €\n \n\nOignons Jaune\n1 × 500 g\n1.40 €\n \n\nPotimarron\n2 × 1.2 kg\n7.60 €\n \n\nPersil\n1 × 1\n1.40 €\n \n\nPatate Douce\n2 × 500 g\n5.60 €\n \nEARL LA POMME DORET\n \n\nPoire Conference\n1 × 1 kg\n2.20 €\n \n\nPomme Golden\n1 × 1 kg\n2.00 €\n \nEARL BERGERIE DE BAISENAZ\n \n\nFlan de Brebis Vanille\n3 × (2 × 12.5 cL)\n8.16 €\n \n\nYaourt de Brebis Fraise\n1 × (2 × 125 g)\n2.60 €\n \n\nYaourt de Brebis Fruits Des Bois\n1 × (2 × 125 g)\n2.60 €\n \nGoûter Desserts\n \n\nFarine de Blé T65 Label Rouge\n1 × (1 × 1 kg)\n2.00 €\n \n\nFarine de Blé T80 Bio\n1 × (1 × 1 kg)\n2.40 €\n \n\nSucette Chocolat Au Lait\n1 × 15 g\n1.50 €\n \n\nTablette de Chocolat Lait Afrique\n1 × (1 × 100 g)\n5.50 €\n \nGAEC les Maillets\n \n\nFv- Le Frais de Vache\n1 × 170 g\n2.00 €",
2)]
public async Task PurchaseLaRuche(string idUser, DateTime datePurchase, string command, int productWaited) {
PurchaseLaRucheDto purchaseLaRucheDto = Common.GetPurchaseLaRucheDto(datePurchase, command);
var result = await _service.ImportLaRuchePurchase(Guid.Parse(idUser), purchaseLaRucheDto);
Assert.IsTrue(_context.Object.Purchases.Any(p => p.id == result.id));
Assert.AreEqual(_context.Object.Purchases.First(p => p.id == result.id).products.Count(), productWaited);
}
}
}

102
backend/GiecChallenge.test/Services/UserServiceTest.cs Normal file
View File

@@ -0,0 +1,102 @@
using Moq;
using GiecChallenge.Services;
using Microsoft.Extensions.Logging;
using AutoMapper;
using GiecChallenge.Models;
using GiecChallenge.Profiles;
using Microsoft.Extensions.Configuration;
using System.Text;
namespace GiecChallenge.Tests
{
public class UserServiceTest
{
private Mock<ILogger<UserService>> _logger = null!;
private Mock<GiecChallengeContext> _context = null!;
private IConfiguration _configuration = null!;
private UserService _service = null!;
private List<UserDto> _allUsersDTO = null!;
[SetUp]
public void Setup()
{
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new UserProfile());
});
IMapper mapper = config.CreateMapper();
_logger = new Mock<ILogger<UserService>>();
var inMemorySettings = new Dictionary<string, string?> {
{"PasswordHash", "udr576eozuQkiLiLjpPJ"},
{"JWT:Secret", "YcJ=OB0%uFr$Q8sT<(o'"},
{"JWT:ValidIssuer", "http://localhost"},
{"JWT:ValidAudience", "http://localhost"}
};
_configuration = new ConfigurationBuilder().AddInMemoryCollection(inMemorySettings).Build();
_context = Common.GetContext();
_context.Setup(g => g.Users).Returns(Common.GetMockDbSet<User>(Common.GetUsers()).Object);
_context.Setup(g => g.Languages).Returns(Common.GetMockDbSet<Language>(Common.GetLanguages()).Object);
_context.Setup(g => g.UserGroups).Returns(Common.GetMockDbSet<UserGroup>(Common.GetUserGroups()).Object);
_service = new UserService(_logger.Object, mapper, _context.Object, _configuration);
}
[Test]
[TestCase("email@email.com", "toto1", "FR")]
[TestCase("email2@email.com", "toto3", "EN")]
public async Task Register(string email, string password, string language)
{
var userToTest = Common.GetUserDto(email, password, language);
await _service.Register(userToTest);
Assert.IsTrue(_context.Object.Users.Any(u => u.email == email));
}
[Test]
[TestCase("email@email.com", "toto1", "DK")]
[TestCase("email2@email.com", "toto3", "CN")]
public void RegisterLanguageNotExists(string email, string password, string language)
{
var userToTest = Common.GetUserDto(email, password, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Register(userToTest));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Language does not exist")));
}
[Test]
[TestCase("toto@toto.com", "toto1", "FR")]
[TestCase("toto1@toto.com", "toto3", "EN")]
public void RegisterAlreadyExist(string email, string password, string language)
{
var userToTest = Common.GetUserDto(email, password, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Register(userToTest));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("User already exist")));
}
[Test]
[TestCase("toto@toto.com", "password1", "FR")]
[TestCase("toto1@toto.com", "password2", "EN")]
public async Task Login(string email, string password, string language)
{
var userToTest = Common.GetUserDto(email, password, language);
var result = await _service.Login(userToTest);
Assert.IsTrue(_context.Object.Users.Any(u => u.email == email));
}
[Test]
[TestCase("toto@toto.com", "toto1", "FR")]
[TestCase("toto1@toto.com", "toto2", "FR")]
[TestCase("toto1@toto.com", "password1", "FR")]
[TestCase("toto@toto.com", "password2", "FR")]
public void LoginNotExist(string email, string password, string language)
{
var userToTest = Common.GetUserDto(email, password, language);
var ex = Assert.ThrowsAsync<Exception>(async () => await _service.Login(userToTest));
Assert.That(ex!.Message, Is.EqualTo(string.Concat("Email or password is incorrect")));
}
}
}