Develop

.gitignore

@@ -1,5 +1,8 @@
 # From .NET Core 3.0 you can use the command: `dotnet new gitignore` to generate a customizable .gitignore file
 
+*.html
+*.css
+*.svg
 *.swp
 *.*~
 project.lock.json
@@ -59,3 +62,8 @@ obj/project.nuget.cache
 obj/project.packagespec.json
 obj/rider.project.model.nuget.info
 obj/rider.project.restore.info
+*.js
+*.htm
+*.css
+*.svg
+*.htm

API.Tests/API.Tests.csproj

@@ -0,0 +1,34 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="7.0.14" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="3.2.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\API\API.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="TestResults\" />
+  </ItemGroup>
+
+</Project>

API.Tests/CreateInboundOrderTest.cs

@@ -0,0 +1,66 @@
+using API.Services;
+
+namespace API.Tests;
+
+[Collection("Sequential")]
+public class CreateInboundOrderTest
+{
+    [Fact]
+    public async void PassTestCreateInboundOrder()
+    {
+        var context = SharedTesting.GetContext();
+        var mapper = SharedTesting.GetMapper();
+
+        var orderService = new OrderService(context, mapper, new AuthService(null, context), new ItemService(context, mapper));
+
+        var inboundOrderToCreate = await SharedTesting.GetRandomInboundOrderDto(context, mapper);
+
+        var inboundOrderCreated = await orderService.CreateInboundOrder(inboundOrderToCreate);
+        Assert.NotNull(inboundOrderCreated);
+
+        Assert.Equal(inboundOrderToCreate.TotalPrice, inboundOrderCreated.TotalPrice);
+        Assert.Equal(inboundOrderToCreate.Supplier.Id, inboundOrderCreated.Supplier.Id);
+        Assert.Equal(inboundOrderToCreate.Supplier.Items, inboundOrderCreated.Supplier.Items);
+        Assert.Equal(inboundOrderToCreate.Supplier.Name, inboundOrderCreated.Supplier.Name);
+        Assert.Equal(inboundOrderToCreate.OrderDate, inboundOrderCreated.OrderDate);
+        Assert.Equal(inboundOrderToCreate.OrderLines.Count, inboundOrderCreated.OrderLines.Count);
+        await context.Database.EnsureDeletedAsync();
+    }
+
+    [Fact]
+    public async void FailCreateDuplicateInboundOrder()
+    {
+        var context = SharedTesting.GetContext();
+        var mapper = SharedTesting.GetMapper();
+
+        var orderService = new OrderService(context, mapper, new AuthService(null, context), new ItemService(context, mapper));
+
+        var inboundOrderToCreate = await SharedTesting.GetRandomInboundOrderDto(context, mapper);
+
+        var inboundOrderCreated = await orderService.CreateInboundOrder(inboundOrderToCreate);
+        Assert.NotNull(inboundOrderCreated);
+
+        var inboundOrderToCreateDuplicate = await SharedTesting.GetRandomInboundOrderDto(context, mapper);
+        inboundOrderToCreateDuplicate.Id = inboundOrderCreated.Id;
+        inboundOrderToCreateDuplicate.SupplierName = inboundOrderCreated.Supplier.Name;
+
+        await Assert.ThrowsAsync<Exception>(async () => await orderService.CreateInboundOrder(inboundOrderToCreateDuplicate));
+        await context.Database.EnsureDeletedAsync();
+    }
+
+    [Fact]
+    public async void FailCreateInboundOrderWithUnknownSupplier()
+    {
+        var context = SharedTesting.GetContext();
+        var mapper = SharedTesting.GetMapper();
+
+        var orderService = new OrderService(context, mapper, new AuthService(null, context), new ItemService(context, mapper));
+
+        var inboundOrderToCreate = await SharedTesting.GetRandomInboundOrderDto(context, mapper);
+        inboundOrderToCreate.Supplier.Id = -1;
+        inboundOrderToCreate.SupplierName = "Unknown supplier";
+
+        await Assert.ThrowsAsync<Exception>(async () => await orderService.CreateInboundOrder(inboundOrderToCreate));
+        await context.Database.EnsureDeletedAsync();
+    }
+}

API.Tests/CreateItemTest.cs

@@ -0,0 +1,84 @@
+using API.DataTransferObjects;
+using API.Enums;
+using API.Services;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Tests;
+
+[Collection("Sequential")]
+public class CreateItemTest
+{
+    [Fact]
+    public async void PassCreateLiquorTest()
+    {
+        var context = SharedTesting.GetContext();
+        var mapper = SharedTesting.GetMapper();
+
+        var itemService = new ItemService(context, mapper);
+
+        var customEnum1 = new CustomEnum { Key = "ltest1", Value = "lTest1", EnumType = EnumType.LiqourType};
+        context.CustomEnums.Add(customEnum1);
+        await context.SaveChangesAsync();
+
+        var testItemDto = new ItemDto { ItemType = ItemType.Liquor, Name = "Test1", Ean = "123456789", Quantity = 10, ReservedQuantity = 0, ImageUrl = "test",
+            Price = 10, Description = "test", Year = 1999, Volume = 0.7, AlcoholPercentage = 40, LiquorTypeEnum = customEnum1 };
+
+        var createdItemDto = await itemService.CreateItem(testItemDto);
+        Assert.NotNull(createdItemDto);
+
+        var createdLiquor = await context.Liquors.FirstOrDefaultAsync(liq => liq.Id == createdItemDto.Id);
+        Assert.NotNull(createdLiquor);
+
+        Assert.Equal(createdItemDto.Id, createdLiquor.Id);
+        await context.Database.EnsureDeletedAsync();
+    }
+
+    [Fact]
+    public async void PassCreateWineTest()
+    {
+        var context = SharedTesting.GetContext();
+        var mapper = SharedTesting.GetMapper();
+
+        var itemService = new ItemService(context, mapper);
+
+        var customEnum1 = new CustomEnum { Key = "ltest1", Value = "lTest1", EnumType = EnumType.WineType};
+        context.CustomEnums.Add(customEnum1);
+        await context.SaveChangesAsync();
+
+
+        var testItemDto = new ItemDto { ItemType = ItemType.Wine, Name = "Test1", Ean = "123456789", Quantity = 10, ReservedQuantity = 0, ImageUrl = "test",
+            Price = 10, Description = "test", Year = 1999, Volume = 0.7, AlcoholPercentage = 40, SuitableForEnumIds = new List<int> { 0, 1 }, WineTypeEnum = customEnum1 };
+
+        var createdItemDto = await itemService.CreateItem(testItemDto);
+        Assert.NotNull(createdItemDto);
+
+        var createdWine = await context.Wines.FirstOrDefaultAsync(wine => wine.Id == createdItemDto.Id);
+        Assert.NotNull(createdWine);
+
+        Assert.Equal(createdItemDto.Id, createdWine.Id);
+        await context.Database.EnsureDeletedAsync();
+    }
+
+    [Fact]
+    public async void PassCreateDefaultItemTest()
+    {
+        var context = SharedTesting.GetContext();
+        var mapper = SharedTesting.GetMapper();
+
+        var itemService = new ItemService(context, mapper);
+
+        await context.SaveChangesAsync();
+
+        var itemDto1 = new ItemDto { ItemType = ItemType.DefaultItem, Name = "Test1", Ean = "123456789", Quantity = 10, ReservedQuantity = 0, ImageUrl = "test",
+            Price = 10, Description = "test", Year = 1999, Volume = 0.7, AlcoholPercentage = 40 };
+
+        var createdItemDto = await itemService.CreateItem(itemDto1);
+        Assert.NotNull(createdItemDto);
+
+        var createdItem = await context.DefaultItems.FirstOrDefaultAsync(item => item.Id == createdItemDto.Id);
+        Assert.NotNull(createdItem);
+
+        Assert.Equal(createdItemDto.Id, createdItem.Id);
+        await context.Database.EnsureDeletedAsync();
+    }
+}

API.Tests/CreatePurchaseOrderTest.cs

@@ -0,0 +1,60 @@
+using API.DataTransferObjects;
+using API.Enums;
+using API.Models;
+using API.Services;
+using Microsoft.AspNetCore.Http;
+namespace API.Tests;
+
+[Collection("Sequential")]
+public class CreatePurchaseOrderTest
+{
+    /// <summary>
+    /// Tests if a purchase order can be created and returned with no exceptions and without being null.
+    /// </summary>
+    [Fact]
+    public async void PassCreatePurchaseOrderTest()
+    {
+        var context = SharedTesting.GetContext();
+        var mapper = SharedTesting.GetMapper();
+
+        var orderService = new OrderService(context, mapper, new AuthService(null, context), new ItemService(context, mapper));
+
+        var testPurchaseOrder = await SharedTesting.GetRandomPurchaseOrderDto(context, mapper);
+
+        var createdPurchaseOrder = await orderService.CreatePurchaseOrder(testPurchaseOrder);
+        Assert.NotNull(createdPurchaseOrder);
+
+        Assert.Equal(createdPurchaseOrder.TotalPrice, testPurchaseOrder.TotalPrice);
+        Assert.Equal(createdPurchaseOrder.CustomerFirstName, testPurchaseOrder.CustomerFirstName);
+        Assert.Equal(createdPurchaseOrder.CustomerLastName, testPurchaseOrder.CustomerLastName);
+        Assert.Equal(createdPurchaseOrder.CustomerPhone, testPurchaseOrder.CustomerPhone);
+        Assert.Equal(createdPurchaseOrder.CustomerEmail, testPurchaseOrder.CustomerEmail);
+        Assert.Equal(createdPurchaseOrder.AddressLine, testPurchaseOrder.AddressLine);
+        Assert.Equal(createdPurchaseOrder.PostalCode, testPurchaseOrder.PostalCode);
+        Assert.Equal(createdPurchaseOrder.City, testPurchaseOrder.City);
+        Assert.Equal(createdPurchaseOrder.Country, testPurchaseOrder.Country);
+        Assert.Equal(createdPurchaseOrder.OrderLines.Count, testPurchaseOrder.OrderLines.Count);
+        Assert.Equal(createdPurchaseOrder.PurchaseOrderState, testPurchaseOrder.PurchaseOrderState);
+        await context.Database.EnsureDeletedAsync();
+    }
+
+    /// <summary>
+    /// Tests if it's possible to create a purchase order that already exists.
+    /// </summary>
+    [Fact]
+    public async void FailCreatePurchaseOrderTestOrderAlreadyExists()
+    {
+        var context = SharedTesting.GetContext();
+        var mapper = SharedTesting.GetMapper();
+
+        var orderService = new OrderService(context, mapper, new AuthService(null, context), new ItemService(context, mapper));
+
+        var testPurchaseOrder = await SharedTesting.GetRandomPurchaseOrderDto(context, mapper);
+
+        var createdPurchaseOrder = await orderService.CreatePurchaseOrder(testPurchaseOrder);
+        testPurchaseOrder.Id = createdPurchaseOrder.Id;
+        Assert.NotNull(createdPurchaseOrder);
+        await Assert.ThrowsAsync<Exception>(async () =>await orderService.CreatePurchaseOrder(testPurchaseOrder));
+        await context.Database.EnsureDeletedAsync();
+    }
+}

API.Tests/EditInboundOrderTest.cs

@@ -0,0 +1,49 @@
+using API.Services;
+
+namespace API.Tests;
+
+[Collection("Sequential")]
+public class EditInboundOrderTest
+{
+    [Fact]
+    public async void PassTestEditInboundOrder()
+    {
+        var context = SharedTesting.GetContext();
+        var mapper = SharedTesting.GetMapper();
+
+        var orderService = new OrderService(context, mapper, new AuthService(null, context), new ItemService(context, mapper));
+
+        var inboundOrderToCreate = await SharedTesting.GetRandomInboundOrderDto(context, mapper);
+
+        var inboundOrderCreated = await orderService.CreateInboundOrder(inboundOrderToCreate);
+        Assert.NotNull(inboundOrderCreated);
+
+        var inboundOrderToEdit = await SharedTesting.GetRandomInboundOrderDto(context, mapper);
+        inboundOrderToEdit.Id = inboundOrderCreated.Id;
+
+        var inboundOrderEdited = await orderService.EditInboundOrder(inboundOrderToEdit);
+        Assert.NotNull(inboundOrderEdited);
+
+        Assert.Equal(inboundOrderToEdit.TotalPrice, inboundOrderEdited.TotalPrice);
+        Assert.Equal(inboundOrderToEdit.Supplier.Id, inboundOrderEdited.Supplier.Id);
+        Assert.Equal(inboundOrderToEdit.Supplier.Items, inboundOrderEdited.Supplier.Items);
+        Assert.Equal(inboundOrderToEdit.Supplier.Name, inboundOrderEdited.Supplier.Name);
+        Assert.Equal(inboundOrderToEdit.OrderDate, inboundOrderEdited.OrderDate);
+        Assert.Equal(inboundOrderToEdit.OrderLines.Count, inboundOrderEdited.OrderLines.Count);
+        await context.Database.EnsureDeletedAsync();
+    }
+
+    [Fact]
+    public async void FailEditNonExistingInboundOrder()
+    {
+        var context = SharedTesting.GetContext();
+        var mapper = SharedTesting.GetMapper();
+
+        var orderService = new OrderService(context, mapper, new AuthService(null, context), new ItemService(context, mapper));
+
+        var inboundOrderToEdit = await SharedTesting.GetRandomInboundOrderDto(context, mapper);
+
+        await Assert.ThrowsAsync<Exception>(async () => await orderService.EditInboundOrder(inboundOrderToEdit));
+        await context.Database.EnsureDeletedAsync();
+    }
+}