ing Hng.Infrastructure.Repository.Interface

diff --git a/.github/workflows/dev-deployment.yml b/.github/workflows/dev-deployment.yml
index baae780..f90dc1b 100644
--- a/.github/workflows/dev-deployment.yml
+++ b/.github/workflows/dev-deployment.yml
@@ -10,23 +10,22 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
-      - name: Build Docker image
-        run: docker build -t csharp_dev .
+      # - name: Build Docker image
+      #   run: docker build -t csharp_dev .
 
-      - name: Save and compress Docker image
-        run: docker save csharp_dev | gzip > csharp_dev.tar.gz
+      # - name: Save and compress Docker image
+      #   run: docker save csharp_dev | gzip > csharp_dev.tar.gz
 
-      - name: Upload Docker image
-        uses: actions/upload-artifact@v2
-        with:
-          name: csharp_dev
-          path: csharp_dev.tar.gz
+      # - name: Upload Docker image
+      #   uses: actions/upload-artifact@v4
+      #   with:
+      #     name: csharp_dev
+      #     path: csharp_dev.tar.gz
         
   deploy:
     needs: build
-    if: github.event.repository.fork == false
     runs-on: ubuntu-latest
 
     environment:
@@ -34,29 +33,41 @@ jobs:
       url: ${{ vars.URL }}
 
     steps:
-      - name: Download Docker image
-        uses: actions/download-artifact@v2
-        with:
-          name: csharp_dev
-          path: .
+      # - name: Download Docker image
+      #   uses: actions/download-artifact@v4
+      #   with:
+      #     name: csharp_dev
+      #     path: .
 
-      - name: Copy image to server
-        uses: appleboy/scp-action@master
-        with:
-          host: ${{ secrets.HOST }}
-          username: ${{ secrets.USERNAME }}
-          password: ${{ secrets.PASSWORD }}
-          source: csharp_dev.tar.gz
-          target: "/tmp"
+      # - name: Copy image to server
+      #   uses: appleboy/scp-action@master
+      #   with:
+      #     host: ${{ secrets.HOST }}
+      #     username: ${{ secrets.USERNAME }}
+      #     password: ${{ secrets.PASSWORD }}
+      #     source: csharp_dev.tar.gz
+      #     target: "/tmp"
+
+      # - name: Deploy on server
+      #   uses: appleboy/ssh-action@master
+      #   with:
+          # host: ${{ secrets.HOST }}
+          # username: ${{ secrets.USERNAME }}
+          # password: ${{ secrets.PASSWORD }}
+      #     script: |
+      #       gunzip -c /tmp/csharp_dev.tar.gz | docker load
+      #       rm -f /tmp/csharp_dev.tar.gz
+      #       cd ~/hng_boilerplate_csharp_web
+      #       docker compose -p csharp_dev up -d
 
-      - name: Deploy on server
-        uses: appleboy/ssh-action@master
+      - name: SSH into server and deploy
+        uses: appleboy/ssh-action@v1.2.1
         with:
           host: ${{ secrets.HOST }}
           username: ${{ secrets.USERNAME }}
           password: ${{ secrets.PASSWORD }}
           script: |
-            gunzip -c /tmp/csharp_dev.tar.gz | docker load
-            rm -f /tmp/csharp_dev.tar.gz
-            cd ~/hng_boilerplate_csharp_web
-            docker compose -p csharp_dev up -d
\ No newline at end of file
+            mkdir -p ~/csharp/backend
+            cd ~/csharp/backend
+            git pull origin dev
+            docker compose -p csharp_dev up -d
diff --git a/src/Hng.Application.Test/Features/Job/UpdateJobCommandShould.cs b/src/Hng.Application.Test/Features/Job/UpdateJobCommandShould.cs
deleted file mode 100644
index 6eea192..0000000
--- a/src/Hng.Application.Test/Features/Job/UpdateJobCommandShould.cs
+++ /dev/null
@@ -1,108 +0,0 @@
-using Hng.Infrastructure.Repository.Interface;
-using Moq;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using AutoMapper;
-using Hng.Application.Features.Jobs.Handlers;
-using Xunit;
-using Hng.Domain.Entities;
-using Hng.Application.Features.Jobs.Dtos;
-using Hng.Application.Features.Jobs.Commands;
-using Microsoft.AspNetCore.Http;
-
-namespace Hng.Application.Test.Features.Job
-{
-    public class UpdateJobCommandShould
-    {
-        private readonly Mock<IRepository<Domain.Entities.Job>> _mockJobRepository;
-        private readonly Mock<IMapper> _mockMapper;
-        private readonly UpdateJobCommandHandler _handler;
-
-        public UpdateJobCommandShould()
-        {
-            _mockJobRepository = new Mock<IRepository<Domain.Entities.Job>>();
-            _mockMapper = new Mock<IMapper>();
-            _handler = new UpdateJobCommandHandler(_mockJobRepository.Object, _mockMapper.Object);
-        }
-
-        [Fact]
-        public async Task Handle_JobExists_UpdatesJobSuccessfully()
-        {
-            // Arrange - Create existing job
-            var existingJob = new Domain.Entities.Job
-            {
-                Id = Guid.NewGuid(),
-                Title = "Software Developer",
-                Description = "Develop software",
-                Location = "Lagos",
-                Salary = 30_000,
-                Company = "HNG",
-                DatePosted = DateTime.Now,
-                Level = Domain.Enums.ExperienceLevel.Junior
-
-            };
-
-            var updateJob = new UpdateJobDto
-            {
-                Title = "Backend Developer",
-                Description = "Develop software",
-                Level = Domain.Enums.ExperienceLevel.Senior
-            };
-
-            var command = new UpdateJobCommand(updateJob, existingJob.Id);
-
-            _mockJobRepository.Setup(repo => repo.GetAsync(existingJob.Id)).ReturnsAsync(existingJob);
-            _mockMapper
-                .Setup(mapper => mapper.Map(updateJob, existingJob))
-                .Callback<UpdateJobDto, Domain.Entities.Job>((src, dest) =>
-                 {
-                     dest.Title = src.Title;
-                     dest.Description = src.Description;
-                     dest.Level = src.Level.Value;
-                 });
-
-            // Act
-            var response = await _handler.Handle(command, CancellationToken.None);
-
-            // Assert - Ensure the job was updated and the response is correct
-            Assert.NotNull(response.Data);
-            Assert.True(response.Success);
-            Assert.Equal(StatusCodes.Status200OK, response.StatusCode);
-            Assert.Equal(updateJob.Title, existingJob.Title);
-            _mockJobRepository.Verify(repo => repo.UpdateAsync(existingJob), Times.Once);
-            _mockJobRepository.Verify(repo => repo.SaveChanges(), Times.Once);
-        }
-
-        [Fact]
-        public async Task Handle_JobDoesNotExist_ReturnsNotFound()
-        {
-            // Arrange = Simulate job not existing
-            var existingJobId = Guid.NewGuid();
-
-            var updateJob = new UpdateJobDto
-            {
-                Title = "Backend Developer",
-                Description = "Develop software",
-                Level = Domain.Enums.ExperienceLevel.Senior
-            };
-
-            var command = new UpdateJobCommand(updateJob, existingJobId);
-            
-            _mockJobRepository.Setup(repo => repo.GetAsync(existingJobId)).ReturnsAsync((Domain.Entities.Job)null);
-
-            // Act
-            var response = await _handler.Handle(command, CancellationToken.None);
-
-            // Assert - Check response for not found
-            Assert.Null(response.Data);
-            Assert.False(response.Success);
-            Assert.Equal(StatusCodes.Status404NotFound, response.StatusCode);
-            Assert.Equal("Job not found", response.Message);
-            Assert.Null(response.Data);
-
-        }
-    }
-}
diff --git a/src/Hng.Application.Test/Features/NewsLetterSubscription/AddSubscriberCommandHandlerShould.cs b/src/Hng.Application.Test/Features/NewsLetterSubscription/AddSubscriberCommandHandlerShould.cs
new file mode 100644
index 0000000..087e63e
--- /dev/null
+++ b/src/Hng.Application.Test/Features/NewsLetterSubscription/AddSubscriberCommandHandlerShould.cs
@@ -0,0 +1,82 @@
+using AutoMapper;
+using Hng.Application.Features.NewsLetterSubscription.Commands;
+using Hng.Application.Features.NewsLetterSubscription.Dtos;
+using Hng.Application.Features.NewsLetterSubscription.Handlers;
+using Hng.Domain.Entities;
+using Hng.Infrastructure.Repository.Interface;
+using Moq;
+using Xunit;
+
+namespace Hng.Application.Test.Features.NewsLetterSubscription
+{
+    public class AddSubscriberHandlerShould
+    {
+        private readonly Mock<IRepository<NewsLetterSubscriber>> _mockRepository;
+        private readonly AddSubscriberHandler _handler;
+        private readonly IMapper _mapper;
+
+        public AddSubscriberHandlerShould()
+        {
+            _mockRepository = new Mock<IRepository<NewsLetterSubscriber>>();
+
+            var mapperConfig = new MapperConfiguration(cfg =>
+            {
+                cfg.CreateMap<NewsLetterSubscriptionDto, NewsLetterSubscriber>();
+            });
+            _mapper = mapperConfig.CreateMapper();
+
+            _handler = new AddSubscriberHandler(_mockRepository.Object, _mapper);
+        }
+
+        [Fact]
+        public async Task Handle_ShouldAddSubscriber_WhenSubscriberDoesNotExist()
+        {
+            // Arrange
+            var email = "new_subscriber@gmail.com";
+            var subscriber = new NewsLetterSubscriptionDto { Email = email };
+            var command = new AddSubscriberCommand(subscriber);
+
+            _mockRepository.Setup(r => r.GetBySpec(It.IsAny<System.Linq.Expressions.Expression<Func<NewsLetterSubscriber, bool>>>(), It.IsAny<System.Linq.Expressions.Expression<Func<NewsLetterSubscriber, object>>[]>()))
+                .ReturnsAsync((NewsLetterSubscriber)null);
+
+            _mockRepository.Setup(r => r.AddAsync(It.IsAny<NewsLetterSubscriber>()))
+                .ReturnsAsync((NewsLetterSubscriber)null);
+
+            _mockRepository.Setup(r => r.SaveChanges())
+                .Returns(Task.CompletedTask);
+
+            // Act
+            var result = await _handler.Handle(command, CancellationToken.None);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(email, result.Email);
+            _mockRepository.Verify(r => r.AddAsync(It.IsAny<NewsLetterSubscriber>()), Times.Once);
+            _mockRepository.Verify(r => r.SaveChanges(), Times.Once);
+        }
+
+        [Fact]
+        public async Task Handle_ShouldReturnNull_WhenSubscriberAlreadyExists()
+        {
+            // Arrange
+            var email = "existing_subscriber@gmail.com";
+            var subscriberDto = new NewsLetterSubscriptionDto { Email = email };
+            var command = new AddSubscriberCommand(subscriberDto);
+
+            var existingSubscriber = new NewsLetterSubscriber { Email = email };
+
+            _mockRepository.Setup(r => r.GetBySpec(It.IsAny<System.Linq.Expressions.Expression<Func<NewsLetterSubscriber, bool>>>(), It.IsAny<System.Linq.Expressions.Expression<Func<NewsLetterSubscriber, object>>[]>()))
+                .ReturnsAsync(existingSubscriber);
+
+            // Act
+            var result = await _handler.Handle(command, CancellationToken.None);
+
+            // Assert
+            Assert.Null(result);
+            _mockRepository.Verify(r => r.AddAsync(It.IsAny<NewsLetterSubscriber>()), Times.Never);
+            _mockRepository.Verify(r => r.SaveChanges(), Times.Never);
+        }
+
+
+    }
+}
diff --git a/src/Hng.Application.Test/Features/NewsLetterSubscription/DeleteSubscriberCommandHandlerShould.cs b/src/Hng.Application.Test/Features/NewsLetterSubscription/DeleteSubscriberCommandHandlerShould.cs
new file mode 100644
index 0000000..3f189e3
--- /dev/null
+++ b/src/Hng.Application.Test/Features/NewsLetterSubscription/DeleteSubscriberCommandHandlerShould.cs
@@ -0,0 +1,70 @@
+using Hng.Application.Features.NewsLetterSubscription.Commands;
+using Hng.Application.Features.NewsLetterSubscription.Handlers;
+using Hng.Domain.Entities;
+using Hng.Infrastructure.Repository.Interface;
+using Moq;
+using Xunit;
+
+namespace Hng.Application.Test.Features.NewsLetterSubscription
+{
+    public class DeleteSubscriberHandlerShould
+    {
+        private readonly Mock<IRepository<NewsLetterSubscriber>> _mockRepository;
+        private readonly DeleteSubscriberHandler _handler;
+
+        public DeleteSubscriberHandlerShould()
+        {
+            _mockRepository = new Mock<IRepository<NewsLetterSubscriber>>();
+            _handler = new DeleteSubscriberHandler(_mockRepository.Object);
+        }
+
+        [Fact]
+        public async Task Handle_ShouldDeleteSubscriber_WhenSubscriberExists()
+        {
+            var subscriberId = Guid.NewGuid();
+            var subscriber = new NewsLetterSubscriber { Id = subscriberId };
+            var command = new DeleteSubscriberCommand(subscriberId);
+
+            _mockRepository.Setup(r => r.GetAsync(subscriberId))
+                .ReturnsAsync(subscriber);
+
+            _mockRepository.Setup(r => r.UpdateAsync(It.IsAny<NewsLetterSubscriber>()))
+                .Returns(Task.CompletedTask);
+
+            _mockRepository.Setup(r => r.SaveChanges())
+                .Returns(Task.CompletedTask);
+
+            // Act
+            var result = await _handler.Handle(command, CancellationToken.None);
+
+            // Assert
+            Assert.Equal(200, result.StatusCode);
+            Assert.Equal("Subscriber deleted successfully.", result.Message);
+
+            _mockRepository.Verify(r => r.GetAsync(subscriberId), Times.Once);
+            _mockRepository.Verify(r => r.UpdateAsync(subscriber), Times.Once);
+            _mockRepository.Verify(r => r.SaveChanges(), Times.Once);
+        }
+
+        [Fact]
+        public async Task Handle_ShouldReturnNotFound_WhenSubscriberDoesNotExist()
+        {
+            var subscriberId = Guid.NewGuid();
+            var command = new DeleteSubscriberCommand(subscriberId);
+
+            _mockRepository.Setup(r => r.GetAsync(subscriberId))
+                .ReturnsAsync((NewsLetterSubscriber)null);
+
+            // Act
+            var result = await _handler.Handle(command, CancellationToken.None);
+
+            // Assert
+            Assert.Equal(404, result.StatusCode);
+            Assert.Equal("Subscriber not found.", result.Message);
+
+            _mockRepository.Verify(r => r.GetAsync(subscriberId), Times.Once);
+            _mockRepository.Verify(r => r.UpdateAsync(It.IsAny<NewsLetterSubscriber>()), Times.Never);
+            _mockRepository.Verify(r => r.SaveChanges(), Times.Never);
+        }
+    }
+}
diff --git a/src/Hng.Application.Test/Features/Organization/UpdateOrganizationShould.cs b/src/Hng.Application.Test/Features/Organization/UpdateOrganizationShould.cs
new file mode 100644
index 0000000..470bdc7
--- /dev/null
+++ b/src/Hng.Application.Test/Features/Organization/UpdateOrganizationShould.cs
@@ -0,0 +1,184 @@
+using AutoMapper;
+using Hng.Application.Features.Organisations.Commands;
+using Hng.Application.Features.Organisations.Dtos;
+using Hng.Application.Features.Organisations.Handlers;
+using Hng.Application.Features.Organisations.Mappers;
+using Hng.Infrastructure.Repository.Interface;
+using Hng.Infrastructure.Services.Interfaces;
+using Microsoft.AspNetCore.Http;
+using Moq;
+using System.Linq.Expressions;
+using Xunit;
+
+namespace Hng.Application.Test.Features.Organization
+{
+    public class UpdateOrganizationShould
+    {
+        private readonly Mock<IRepository<Domain.Entities.Organization>> _repositoryMock;
+        private readonly Mock<IAuthenticationService> _authenticationServiceMock;
+        private readonly UpdateOrganizationCommandHandler _handler;
+        private readonly IMapper _mapper;
+
+        public UpdateOrganizationShould()
+        {
+            // Setup mapper with proper profile
+            var mappingProfile = new OrganizationMapperProfile();
+            var configuration = new MapperConfiguration(cfg => cfg.AddProfile(mappingProfile));
+            _mapper = new Mapper(configuration);
+
+            // Setup repository and authentication mocks
+            _repositoryMock = new Mock<IRepository<Domain.Entities.Organization>>();
+            _authenticationServiceMock = new Mock<IAuthenticationService>();
+
+            // Initialize the handler with mocks
+            _handler = new UpdateOrganizationCommandHandler(
+                _repositoryMock.Object,
+                _mapper,
+                _authenticationServiceMock.Object
+            );
+        }
+
+        [Fact]
+        public async Task Handle_ShouldReturn200_WhenOrganizationUpdatedSuccessfully()
+        {
+            // Arrange
+            var userId = Guid.NewGuid();
+            var organizationId = Guid.NewGuid();
+
+            var updateDto = new UpdateOrganizationDto
+            {
+                Name = "Updated Org",
+                Description = "Updated Description",
+                Email = "updated@example.com",
+                Industry = "Tech",
+                Type = "Enterprise",
+                Country = "Updated Country",
+                Address = "Updated Address",
+                State = "Updated State"
+            };
+
+            var existingOrganization = new Domain.Entities.Organization
+            {
+                Id = organizationId,
+                OwnerId = userId,
+                Name = "Old Org",
+                Description = "Old Description",
+                Email = "old@example.com",
+                Industry = "Old Industry",
+                Type = "Old Type",
+                Country = "Old Country",
+                Address = "Old Address",
+                State = "Old State"
+            };
+
+            // Setup authentication to return the current user
+            _authenticationServiceMock
+                .Setup(a => a.GetCurrentUserAsync())
+                .ReturnsAsync(userId);
+
+            // Setup repository to return existing organization when GetBySpec is called
+            _repositoryMock
+                .Setup(r => r.GetBySpec(It.IsAny<Expression<Func<Domain.Entities.Organization, bool>>>()))
+                .ReturnsAsync(existingOrganization);
+
+            // Setup UpdateAsync to do nothing (void return)
+            _repositoryMock
+                .Setup(r => r.UpdateAsync(It.IsAny<Domain.Entities.Organization>()))
+                .Returns(Task.CompletedTask);
+
+            // Setup SaveChanges to return success
+            _repositoryMock
+                .Setup(r => r.SaveChanges())
+                .Returns(Task.FromResult(true));
+
+            var command = new UpdateOrganizationCommand(organizationId, updateDto);
+
+            // Act
+            var result = await _handler.Handle(command, CancellationToken.None);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(StatusCodes.Status200OK, result.StatusCode);
+            Assert.Equal("Organization updated successfully", result.Message);
+            Assert.NotNull(result.Data);
+
+            // Verify all properties were mapped correctly
+            Assert.Equal(updateDto.Name, result.Data.Name);
+            Assert.Equal(updateDto.Description, result.Data.Description);
+            Assert.Equal(updateDto.Email, result.Data.Email);
+            Assert.Equal(updateDto.Industry, result.Data.Industry);
+            Assert.Equal(updateDto.Type, result.Data.Type);
+            Assert.Equal(updateDto.Country, result.Data.Country);
+            Assert.Equal(updateDto.Address, result.Data.Address);
+            Assert.Equal(updateDto.State, result.Data.State);
+
+            // Verify repository methods were called
+            _repositoryMock.Verify(r => r.UpdateAsync(It.IsAny<Domain.Entities.Organization>()), Times.Once);
+            _repositoryMock.Verify(r => r.SaveChanges(), Times.Once);
+        }
+
+        [Fact]
+        public async Task Handle_ShouldReturn404_WhenOrganizationNotFound()
+        {
+            // Arrange
+            var organizationId = Guid.NewGuid();
+            var updateDto = new UpdateOrganizationDto { Name = "Updated Org" };
+            var command = new UpdateOrganizationCommand(organizationId, updateDto);
+
+            // Setup repository to return null (organization not found)
+            _repositoryMock
+                .Setup(r => r.GetBySpec(It.IsAny<Expression<Func<Domain.Entities.Organization, bool>>>()))
+                .ReturnsAsync((Domain.Entities.Organization)null);
+
+            // Act
+            var result = await _handler.Handle(command, CancellationToken.None);
+
+            // Assert
+            Assert.Equal(StatusCodes.Status404NotFound, result.StatusCode);
+            Assert.Equal("Organization not found", result.Message);
+
+            // Verify Update/Save were never called
+            _repositoryMock.Verify(r => r.UpdateAsync(It.IsAny<Domain.Entities.Organization>()), Times.Never);
+            _repositoryMock.Verify(r => r.SaveChanges(), Times.Never);
+        }
+
+        [Fact]
+        public async Task Handle_ShouldReturn403_WhenUnauthorizedUpdateAttempt()
+        {
+            // Arrange
+            var organizationId = Guid.NewGuid();
+            var ownerId = Guid.NewGuid();
+            var unauthorizedUserId = Guid.NewGuid(); // Different from owner
+            var updateDto = new UpdateOrganizationDto { Name = "Updated Org" };
+            var command = new UpdateOrganizationCommand(organizationId, updateDto);
+
+            var organization = new Domain.Entities.Organization
+            {
+                Id = organizationId,
+                OwnerId = ownerId  // This is the owner
+            };
+
+            // Setup authentication to return unauthorized user
+            _authenticationServiceMock
+                .Setup(a => a.GetCurrentUserAsync())
+                .ReturnsAsync(unauthorizedUserId);  // Different from owner
+
+            // Setup repositor