Merge branch 'main' of https://github.com/Svetloslav15/NorthwindAPI

Author: zdrawku

.github/workflows/build-test-ci.yml

@@ -0,0 +1,30 @@
+name: Build / unit tests
+
+on:
+  push:
+    branches:
+      - main 
+  pull_request:
+    branches:
+      - main
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest  
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v3
+
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: 6.x 
+
+    - name: Restore dependencies
+      run: dotnet restore
+
+    - name: Build
+      run: dotnet build --configuration Release 
+
+    - name: Run tests
+      run: dotnet test --configuration Release --no-build

NorthwindCRUD.Tests/BaseFixture.cs

@@ -0,0 +1,67 @@
+using System.Data.Common;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace NorthwindCRUD.Tests
+{
+    public class BaseFixture
+    {
+        // null! indicates that the member is initialized in other code
+        private DbConnection? connection = null!;
+
+        public DataHelper DataHelper { get; set; } = null!;
+
+        public DataHelper DataHelper2 { get; set; } = null!;
+
+        [TestInitialize]
+        public void Initialize()
+        {
+            DataContext context = GetInMemoryDatabaseContext();
+            DataContext context2 = GetInMemoryDatabaseContext();
+            Assert.AreNotEqual(context.GetHashCode(), context2.GetHashCode(), "Contexts instances should be different.");
+            Assert.AreEqual(context.Database.GetDbConnection(), context2.Database.GetDbConnection(), "Contexts instances should have the same database connection.");
+
+            DataHelper = new DataHelper(context);
+            DataHelper2 = new DataHelper(context2);
+        }
+
+        protected DataContext GetInMemoryDatabaseContext()
+        {
+            if (connection == null)
+            {
+                connection = CreateDbConnection();
+                var context = CreateInMemoryDatabaseContext(connection);
+                context.Database.EnsureCreated();
+
+                // DBSeeder.Seed(context);
+                return context;
+            }
+            else
+            {
+                // Create a new Context on already initialized DB connection
+                return CreateInMemoryDatabaseContext(connection);
+            }
+        }
+
+        protected DbConnection CreateDbConnection()
+        {
+            var connection = new SqliteConnection("DataSource=:memory:");
+            connection.Open();
+            return connection;
+        }
+
+        protected DataContext CreateInMemoryDatabaseContext(DbConnection connection)
+        {
+            var options = new DbContextOptionsBuilder<DataContext>()
+                .UseSqlite(connection)
+                .EnableSensitiveDataLogging()
+
+                // Uncomment the following line for detailed sql EF logs.
+                // .EnableDetailedErrors().LogTo(Console.WriteLine, LogLevel.Debug)
+                .Options;
+
+            return new DataContext(options);
+        }
+    }
+}

NorthwindCRUD.Tests/CategroyServiceFixture.cs

@@ -0,0 +1,66 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace NorthwindCRUD.Tests
+{
+    [TestClass]
+    public class CategoryServiceFixture : BaseFixture
+    {
+        [TestMethod]
+        public void ShouldCreateCategory()
+        {
+            var category = DataHelper.GetCategory();
+            var createdCategory = DataHelper.CategoryService.Create(category);
+
+            Assert.IsNotNull(createdCategory);
+            createdCategory = DataHelper2.CategoryService.GetById(createdCategory.CategoryId);
+
+            Assert.AreEqual(category.Name, createdCategory?.Name);
+            Assert.AreEqual(category.Description, createdCategory?.Description);
+        }
+
+        [TestMethod]
+        public void ShouldUpdateCategory()
+        {
+            var category = DataHelper.GetCategory();
+            string orignalName = category.Name;
+            string orignalDescription = category.Description;
+            var createdCategory = DataHelper.CategoryService.Create(category);
+
+            createdCategory.Name = "Updated Category";
+            createdCategory.Description = "Updated Description";
+            var updatedCategory = DataHelper.CategoryService.Update(createdCategory);
+
+            Assert.IsNotNull(updatedCategory);
+            updatedCategory = DataHelper2.CategoryService.GetById(updatedCategory.CategoryId);
+            Assert.IsNotNull(updatedCategory);
+            Assert.AreNotEqual(orignalName, updatedCategory.Name);
+            Assert.AreNotEqual(orignalDescription, updatedCategory.Description);
+            Assert.AreEqual(createdCategory.Name, updatedCategory.Name);
+            Assert.AreEqual(createdCategory.Description, updatedCategory.Description);
+        }
+
+        [TestMethod]
+        public void ShouldDeleteCategory()
+        {
+            var category = DataHelper.GetCategory();
+
+            var createdCategory = DataHelper.CategoryService.Create(category);
+
+            DataHelper.CategoryService.Delete(createdCategory.CategoryId);
+            var deletedCategory = DataHelper2.CategoryService.GetById(createdCategory.CategoryId);
+
+            Assert.IsNull(deletedCategory);
+        }
+
+        [TestMethod]
+        public void ShouldReturnAllCategories()
+        {
+            DataHelper.CategoryService.Create(DataHelper.GetCategory());
+            DataHelper.CategoryService.Create(DataHelper.GetCategory());
+            var result = DataHelper2.CategoryService.GetAll();
+
+            Assert.IsNotNull(result);
+            Assert.AreEqual(2, result.Length);
+        }
+    }
+}

NorthwindCRUD.Tests/CustomerServiceFixture.cs

@@ -0,0 +1,41 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace NorthwindCRUD.Tests
+{
+    [TestClass]
+    public class CustomerServiceFixture : BaseFixture
+    {
+        [TestMethod]
+        public void ShouldCreateCustomer()
+        {
+            var customer = DataHelper.GetCustomer();
+            var createdCustomer = DataHelper.CustomerService.Create(customer);
+            Assert.IsNotNull(createdCustomer);
+            Assert.AreEqual(customer, createdCustomer, "Customers instances should be the same since we are over the same context");
+
+            createdCustomer = DataHelper2.CustomerService.GetById(createdCustomer.CustomerId);
+            Assert.IsNotNull(createdCustomer);
+            Assert.AreNotEqual(customer, createdCustomer, "Customer instances should be different");
+
+            Assert.AreEqual(customer.CompanyName, createdCustomer.CompanyName);
+            Assert.AreEqual(customer.ContactName, createdCustomer.ContactName);
+            Assert.AreEqual(customer.ContactTitle, createdCustomer.ContactTitle);
+            Assert.AreEqual(customer.Address.Street, createdCustomer.Address.Street);
+            Assert.AreEqual(customer.Address.City, createdCustomer.Address.City);
+            Assert.AreEqual(customer.Address.PostalCode, createdCustomer.Address.PostalCode);
+            Assert.AreEqual(customer.Address.Country, createdCustomer.Address.Country);
+            Assert.AreEqual(customer.Address.Phone, createdCustomer.Address.Phone);
+        }
+
+        [TestMethod]
+        public void ShouldReturnAllCustomers()
+        {
+            DataHelper.CustomerService.Create(DataHelper.GetCustomer());
+            DataHelper.CustomerService.Create(DataHelper.GetCustomer());
+
+            var result = DataHelper2.CustomerService.GetAll();
+            Assert.IsNotNull(result);
+            Assert.AreEqual(2, result.Length);
+        }
+    }
+}

NorthwindCRUD.Tests/EmployeeServiceFixture.cs

@@ -0,0 +1,101 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NorthwindCRUD.Models.DbModels;
+
+namespace NorthwindCRUD.Tests
+{
+    [TestClass]
+    public class EmployeeServiceFixture : BaseFixture
+    {
+        [TestMethod]
+        public void ShouldCreateEmployee()
+        {
+            EmployeeDb employee = DataHelper.GetEmployee();
+
+            var createdEmployee = DataHelper.EmployeeService.Create(employee);
+
+            Assert.IsNotNull(createdEmployee);
+            createdEmployee = DataHelper2.EmployeeService.GetById(createdEmployee.EmployeeId);
+            Assert.IsNotNull(createdEmployee);
+            Assert.AreEqual(employee.FirstName, createdEmployee.FirstName);
+            Assert.AreEqual(employee.LastName, createdEmployee.LastName);
+            Assert.AreEqual(employee.Title, createdEmployee.Title);
+        }
+
+        [TestMethod]
+        public void ShouldUpdateEmployee()
+        {
+            var employee = DataHelper.GetEmployee();
+            string originalTitle = employee.Title;
+            var createdEmployee = DataHelper.EmployeeService.Create(employee);
+
+            createdEmployee.Title = "Director";
+            var updatedEmployee = DataHelper.EmployeeService.Update(createdEmployee);
+
+            Assert.IsNotNull(updatedEmployee);
+            updatedEmployee = DataHelper2.EmployeeService.GetById(updatedEmployee.EmployeeId);
+            Assert.IsNotNull(updatedEmployee);
+            Assert.AreNotEqual(originalTitle, updatedEmployee.Title);
+            Assert.AreEqual(createdEmployee.Title, updatedEmployee.Title);
+        }
+
+        [TestMethod]
+        public void ShouldDeleteEmployee()
+        {
+            var employee = DataHelper.GetEmployee();
+            var createdEmployee = DataHelper.EmployeeService.Create(employee);
+
+            DataHelper.EmployeeService.Delete(createdEmployee.EmployeeId);
+            var deletedEmployee = DataHelper2.EmployeeService.GetById(createdEmployee.EmployeeId);
+
+            Assert.IsNull(deletedEmployee);
+        }
+
+        [TestMethod]
+        public void ShouldReturnAllEmployees()
+        {
+            DataHelper.EmployeeService.Create(DataHelper.GetEmployee());
+            DataHelper.EmployeeService.Create(DataHelper.GetEmployee());
+
+            var result = DataHelper2.EmployeeService.GetAll();
+
+            Assert.IsNotNull(result);
+            Assert.AreEqual(2, result.Length);
+        }
+
+        [TestMethod]
+        public void ShouldReturnEmployeesByReportsTo()
+        {
+            var manager = DataHelper.GetEmployee();
+
+            var createdManager = DataHelper.EmployeeService.Create(manager);
+            var employee1 = DataHelper.GetEmployee();
+            employee1.ReportsTo = createdManager.EmployeeId;
+
+            var employee2 = DataHelper.GetEmployee();
+            employee2.ReportsTo = createdManager.EmployeeId;
+
+            var createdEmployee1 = DataHelper.EmployeeService.Create(employee1);
+            var createdEmployee2 = DataHelper.EmployeeService.Create(employee2);
+
+            var result = DataHelper.EmployeeService.GetEmployeesByReportsTo(createdManager.EmployeeId);
+            Assert.IsNotNull(result);
+            Assert.AreEqual(2, result.Length);
+            Assert.IsTrue(result.All(e => e.ReportsTo == createdManager.EmployeeId));
+        }
+
+        [TestMethod]
+        public void ShouldReturnEmployeeById()
+        {
+            var employee = DataHelper.GetEmployee();
+
+            var createdEmployee = DataHelper.EmployeeService.Create(employee);
+
+            var result = DataHelper.EmployeeService.GetById(createdEmployee.EmployeeId);
+
+            Assert.IsNotNull(result);
+            Assert.AreEqual(employee.FirstName, result.FirstName);
+            Assert.AreEqual(employee.LastName, result.LastName);
+            Assert.AreEqual(employee.Title, result.Title);
+        }
+    }
+}

NorthwindCRUD.Tests/EmployeeTerritoryServiceFixture.cs

@@ -0,0 +1,57 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace NorthwindCRUD.Tests
+{
+    [TestClass]
+    public class EmployeeTerritoryServiceFixture : BaseFixture
+    {
+        [TestMethod]
+        public void ShouldAddTerritoryToEmployee()
+        {
+            var employeeId = DataHelper.CreateEmployee().EmployeeId;
+            var territoryId = DataHelper.CreateTerritory().TerritoryId;
+
+            DataHelper.CreateEmployeeTerritory(employeeId, territoryId);
+
+            var territories = DataHelper2.EmployeeTerritoryService.GetTeritoriesByEmployeeId(employeeId);
+            Assert.IsNotNull(territories);
+            Assert.IsTrue(territories.Any(t => t.TerritoryId == territoryId));
+        }
+
+        [TestMethod]
+        public void ShouldReturnTerritoriesForEmployee()
+        {
+            var employeeId = DataHelper.CreateEmployee().EmployeeId;
+            var territoryId1 = DataHelper.CreateTerritory().TerritoryId;
+            var territoryId2 = DataHelper.CreateTerritory().TerritoryId;
+
+            DataHelper.CreateEmployeeTerritory(employeeId, territoryId1);
+            DataHelper.CreateEmployeeTerritory(employeeId, territoryId2);
+
+            var territories = DataHelper2.EmployeeTerritoryService.GetTeritoriesByEmployeeId(employeeId);
+
+            Assert.IsNotNull(territories);
+            Assert.AreEqual(2, territories.Length);
+            Assert.IsTrue(territories.Any(t => t.TerritoryId == territoryId1));
+            Assert.IsTrue(territories.Any(t => t.TerritoryId == territoryId2));
+        }
+
+        [TestMethod]
+        public void ShouldReturnEmployeesForTerritory()
+        {
+            var territoryId = DataHelper.CreateTerritory().TerritoryId;
+            var employeeId1 = DataHelper.CreateEmployee().EmployeeId;
+            var employeeId2 = DataHelper.CreateEmployee().EmployeeId;
+
+            DataHelper.CreateEmployeeTerritory(employeeId1, territoryId);
+            DataHelper.CreateEmployeeTerritory(employeeId2, territoryId);
+
+            var employees = DataHelper2.EmployeeTerritoryService.GetEmployeesByTerritoryId(territoryId);
+
+            Assert.IsNotNull(employees);
+            Assert.AreEqual(2, employees.Length);
+            Assert.IsTrue(employees.Any(e => e.EmployeeId == employeeId1));
+            Assert.IsTrue(employees.Any(e => e.EmployeeId == employeeId2));
+        }
+    }
+}