Diligent.WebAPI.Business/Services/ApplicantService.cs

@@ -51,7 +51,7 @@ namespace Diligent.WebAPI.Business.Services
         {
             var applicant = await _context.Applicants.FindAsync(id);
             if (applicant is null)
-                throw new EntityNotFoundException("Insurer not found");
+                throw new EntityNotFoundException("Applicant not found");
 
             _mapper.Map(applicantUpdateDto, applicant);
 

Diligent.WebAPI.Data/Extensions/ServiceCollection.cs

@@ -10,8 +10,9 @@ public static class ServiceCollection
             {
                 options.EnableSensitiveDataLogging();
             }
-
-            options.UseSqlServer(configuration.GetConnectionString(nameof(Diligent.WebAPI)));
+            var secret = Environment.GetEnvironmentVariable("SECRET");
+            var connectionString = configuration.GetConnectionString(nameof(Diligent.WebAPI));
+            options.UseSqlServer(String.Concat(connectionString,secret));
         });
     }
 }

Diligent.WebAPI.Host/appsettings.json

@@ -1,6 +1,6 @@
 {
   "ConnectionStrings": {
-    "WebApi": "Server=192.168.88.105;Database=HRCenter;User Id=hrcentar;Password=;"
+    "WebApi": "Server=192.168.88.105;Database=HRCenter;User Id=hrcentar;Password="
   },
   "Authorization": {
     "JwtExpiredTime": "5",

Diligent.WebAPI.Tests/Controllers/ApplicantsControllerTests.cs

@@ -0,0 +1,66 @@
+using Diligent.WebAPI.Contracts.DTOs.Applicant;
+using Diligent.WebAPI.Contracts.Exceptions;
+using NSubstitute;
+
+namespace Diligent.WebAPI.Tests.Controllers
+{
+    public class ApplicantsControllerTests
+    {
+        private IApplicantService _applicantService = Substitute.For<IApplicantService>();
+        private readonly ApplicantViewDto _applicant;
+        public ApplicantsControllerTests()
+        {
+            _applicant = new ApplicantViewDto
+            {
+                ApplicantId = 1,
+                ApplicationChannel = "Instagram",
+                BitBucketLink = null,
+                CV = "link",
+                DateOfApplication = DateTime.Now,
+                Email = "some@mail.com",
+                Experience = 1,
+                FirstName = "Dzenis",
+                LastName = "Hadzifejzovic",
+                GithubLink = null,
+                LinkedlnLink = null,
+                PhoneNumber = "432424",
+                Position = ".NET Developer"
+            };
+        }
+
+        [Fact]
+        public async Task GetById_ShouldReturn_200OK_WhenApplicantExist()
+        {
+            _applicantService.GetById(Arg.Any<int>()).Returns(_applicant);
+            ApplicantsController applicantsController = new(_applicantService);
+
+            var result = await applicantsController.GetById(1);
+
+            (result as OkObjectResult).StatusCode.Should().Be(200);
+        }
+
+        [Fact]
+        public async Task GetById_ShouldThrowEntityNotFooundException_WhenApplicantDontExist()
+        {
+            _applicantService.When(x => x.GetById(Arg.Any<int>())).Do(x => { throw new EntityNotFoundException(); });
+            ApplicantsController applicantsController = new(_applicantService);
+
+            await Assert.ThrowsAsync<EntityNotFoundException>(() => applicantsController.GetById(1000));
+        }
+
+        [Fact]
+        public async Task GetAll_ShouldReturn_200OK_Always()
+        {
+            var applicants = new List<ApplicantViewDto>
+            {
+                _applicant
+            };
+            _applicantService.GetAll().Returns(applicants);
+            ApplicantsController applicantsController = new(_applicantService);
+
+            var result = await applicantsController.GetAll();
+
+            (result as OkObjectResult).StatusCode.Should().Be(200);
+        }
+    }
+}

Diligent.WebAPI.Tests/Diligent.WebAPI.Tests.csproj

@@ -10,6 +10,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions" Version="6.8.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="6.0.10" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
     <PackageReference Include="NSubstitute" Version="4.4.0" />
     <PackageReference Include="xunit" Version="2.4.1" />

Diligent.WebAPI.Tests/Helpers.cs

@@ -0,0 +1,24 @@
+using Diligent.WebAPI.Data;
+using Diligent.WebAPI.Data.Entities;
+using Microsoft.EntityFrameworkCore;
+
+namespace Diligent.WebAPI.Tests
+{
+    public static class Helpers
+    {
+        public static async Task<DatabaseContext> GetDatabaseContext(List<Applicant> applicants)
+        {
+            var options = new DbContextOptionsBuilder<DatabaseContext>()
+                .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+                .Options;
+            var databaseContext = new DatabaseContext(options);
+            databaseContext.Database.EnsureCreated();
+            if (!await databaseContext.Applicants.AnyAsync())
+            {
+                await databaseContext.Applicants.AddRangeAsync(applicants);
+                await databaseContext.SaveChangesAsync();
+            }
+            return databaseContext;
+        }
+    }
+}

Diligent.WebAPI.Tests/Services/ApplicantServiceTests.cs

@@ -0,0 +1,154 @@
+using AutoMapper;
+using Diligent.WebAPI.Business.MappingProfiles;
+using Diligent.WebAPI.Business.Services;
+using Diligent.WebAPI.Contracts.DTOs.Applicant;
+using Diligent.WebAPI.Contracts.Exceptions;
+using Diligent.WebAPI.Data.Entities;
+
+namespace Diligent.WebAPI.Tests.Services
+{
+    public class ApplicantServiceTests
+    {
+        private readonly IMapper _mapper;
+        private readonly List<Applicant> _applicants;
+        private readonly Applicant _applicant;
+        public ApplicantServiceTests()
+        {
+            _applicant = new Applicant
+            {
+                ApplicantId = 1,
+                ApplicationChannel = "Instagram",
+                BitBucketLink = null,
+                CV = "link",
+                DateOfApplication = DateTime.Now,
+                Email = "some@mail.com",
+                Experience = 1,
+                FirstName = "Dzenis",
+                LastName = "Hadzifejzovic",
+                GithubLink = null,
+                LinkedlnLink = null,
+                PhoneNumber = "432424",
+                Position = ".NET Developer"
+            };
+            _applicants = new List<Applicant>
+            {
+                _applicant
+            };
+
+            // configure mapper
+            var configuration = new MapperConfiguration(cfg => cfg.AddProfiles(
+                new List<Profile>
+            {
+                new ApplicantMappingProfile()
+            }));
+            _mapper = new Mapper(configuration);
+        }
+
+        [Fact]
+        public async Task GetAll_ShouldReturnListOfApplicants_Always()
+        {
+            var databaseContext = await Helpers.GetDatabaseContext(_applicants);
+            ApplicantService applicantService = new(databaseContext, _mapper);
+
+            var result = await applicantService.GetAll();
+
+            result.Should().BeEquivalentTo(_mapper.Map<List<ApplicantViewDto>>(_applicants));
+        }
+
+        [Fact]
+        public async Task GetById_ShouldReturnApplicant_WhenApplicantExist()
+        {
+            var databaseContext = await Helpers.GetDatabaseContext(_applicants);
+            ApplicantService applicantService = new(databaseContext, _mapper);
+
+            var result = await applicantService.GetById(1);
+
+            result.Should().BeEquivalentTo(_mapper.Map<ApplicantViewDto>(_applicant));
+        }
+
+        [Fact]
+        public async Task GetById_ShouldThrowEntityNotFooundException_WhenApplicantDontExist()
+        {
+            var databaseContext = await Helpers.GetDatabaseContext(_applicants);
+            ApplicantService applicantService = new(databaseContext, _mapper);
+
+            await Assert.ThrowsAsync<EntityNotFoundException>(async () => await applicantService.GetById(1000));
+        }
+
+        [Fact]
+        public async Task CreateApplicant_ShouldAddEntityIntoDatabase_Always()
+        {
+            var databaseContext = await Helpers.GetDatabaseContext(_applicants);
+            ApplicantService applicantService = new(databaseContext, _mapper);
+
+            ApplicantCreateDto applicantCreateDto = new()
+            {
+                ApplicationChannel = "Facebook",
+                BitBucketLink = null,
+                CV = "link",
+                Email = "some@mail.com",
+                Experience = 1,
+                FirstName = "Meris",
+                LastName = "Ahmatovic",
+                GithubLink = null,
+                LinkedlnLink = null,
+                PhoneNumber = "432424",
+                Position = ".NET Developer"
+            };
+
+            await applicantService.CreateApplicant(applicantCreateDto);
+
+            var applicants = await applicantService.GetAll();
+
+            Assert.Equal(2, applicants.Count);
+        }
+
+        [Fact]
+        public async Task DeleteApplicant_ShouldDeleteApplicant_WhenApplicantExist()
+        {
+            var databaseContext = await Helpers.GetDatabaseContext(_applicants);
+            ApplicantService applicantService = new(databaseContext, _mapper);
+
+            await applicantService.DeleteApplicant(1);
+            var applicants = await applicantService.GetAll();
+
+            Assert.Empty(applicants);
+        }
+
+        [Fact]
+        public async Task DeleteApplicant_ShouldThrowEntityNotFooundException_WhenApplicantDontExist()
+        {
+            var databaseContext = await Helpers.GetDatabaseContext(_applicants);
+            ApplicantService applicantService = new(databaseContext, _mapper);
+
+            await Assert.ThrowsAsync<EntityNotFoundException>(async () => await applicantService.DeleteApplicant(1000));
+        }
+
+        [Fact]
+        public async Task UpdateApplicant_ShouldUpdateApplicant_WhenApplicantExist()
+        {
+            var databaseContext = await Helpers.GetDatabaseContext(_applicants);
+            ApplicantService applicantService = new(databaseContext, _mapper);
+
+            ApplicantUpdateDto applicantUpdateDto = new()
+            {
+                ApplicationChannel = "Instagram",
+                BitBucketLink = null,
+                CV = "link",
+                Email = "some@mail.com",
+                Experience = 1,
+                FirstName = "Dzenis",
+                LastName = "Hadzifejzovic",
+                GithubLink = null,
+                LinkedlnLink = null,
+                PhoneNumber = "432424",
+                Position = "React Developer"
+            };
+
+            await applicantService.UpdateApplicant(1,applicantUpdateDto);
+            var applicant = await applicantService.GetById(1);
+
+            Assert.Equal(applicant.Position,applicantUpdateDto.Position);
+        }
+    }
+}