AddressServiceTests.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using ParcelTracking.Application.Services;
using ParcelTracking.Infrastructure.Data;
using ParcelTracking.Application.DTOs.Addresses.Requests;
using ParcelTracking.Application.DTOs.Common;
using ParcelTracking.Domain.Entities;
using ParcelTracking.Domain.Enums;
using Xunit;

namespace ParcelTracking.Application.Tests
{
    /// <summary>
    /// Unit tests for the AddressService class.
    /// Tests cover all CRUD operations, pagination, and error handling.
    /// Uses in-memory database for isolation and speed.
    /// </summary>
    public class AddressServiceTests
    {
        private ParcelTrackingDbContext CreateDbContext()
        {
            var options = new DbContextOptionsBuilder<ParcelTrackingDbContext>()
                .UseInMemoryDatabase(Guid.NewGuid().ToString())
                .Options;

            return new ParcelTrackingDbContext(options);
        }

        #region GetAllAsync Tests

        [Fact]
        public async Task GetAllAsync_WithEmptyDatabase_ReturnsEmptyPagedResult()
        {
            // Arrange
            await using var db = CreateDbContext();
            var service = new AddressService(db, new NullLogger<AddressService>());

            // Act
            var result = await service.GetAllAsync();

            // Assert
            result.Should().NotBeNull();
            result.Items.Should().BeEmpty();
            result.TotalCount.Should().Be(0);
            result.Page.Should().Be(1);
            result.PageSize.Should().Be(50);
        }

        [Fact]
        public async Task GetAllAsync_WithCustomPageSize_ReturnsPaginatedResults()
        {
            // Arrange
            await using var db = CreateDbContext();
            var addresses = CreateTestAddresses(25);
            db.Addresses.AddRange(addresses);
            await db.SaveChangesAsync();

            var service = new AddressService(db, new NullLogger<AddressService>());

            // Act
            var result = await service.GetAllAsync(page: 1, pageSize: 10);

            // Assert
            result.Should().NotBeNull();
            result.Items.Should().HaveCount(10);
            result.TotalCount.Should().Be(25);
            result.Page.Should().Be(1);
            result.PageSize.Should().Be(10);
        }

        [Fact]
        public async Task GetAllAsync_WithSecondPage_ReturnsCorrectItems()
        {
            // Arrange
            await using var db = CreateDbContext();
            var addresses = CreateTestAddresses(25);
            db.Addresses.AddRange(addresses);
            await db.SaveChangesAsync();

            var service = new AddressService(db, new NullLogger<AddressService>());

            // Act
            var page1 = await service.GetAllAsync(page: 1, pageSize: 10);
            var page2 = await service.GetAllAsync(page: 2, pageSize: 10);

            // Assert
            page1.Items.Should().HaveCount(10);
            page2.Items.Should().HaveCount(10);
            foreach (var item1 in page1.Items)
            {
                page2.Items.Should().NotContain(item1);
            }
        }

        [Fact]
        public async Task GetAllAsync_SortsAddressesByCity()
        {
            // Arrange
            await using var db = CreateDbContext();
            var addresses = new List<Address>
            {
                new Address
                {
                    Id = Guid.NewGuid(),
                    Street1 = "Main St",
                    City = "Zebra City",
                    State = "ZZ",
                    PostalCode = "00001",
                    CountryCode = "US",
                    ContactName = "John Doe",
                    Phone = "555-0001"
                },
                new Address
                {
                    Id = Guid.NewGuid(),
                    Street1 = "Oak Ave",
                    City = "Alpha City",
                    State = "AA",
                    PostalCode = "00002",
                    CountryCode = "US",
                    ContactName = "Jane Doe",
                    Phone = "555-0002"
                },
                new Address
                {
                    Id = Guid.NewGuid(),
                    Street1 = "Maple Ave",
                    City = "Beta City",
                    State = "BB",
                    PostalCode = "00003",
                    CountryCode = "US",
                    ContactName = "Bob Smith",
                    Phone = "555-0003"
                }
            };

            db.Addresses.AddRange(addresses);
            await db.SaveChangesAsync();

            var service = new AddressService(db, new NullLogger<AddressService>());

            // Act
            var result = await service.GetAllAsync(page: 1, pageSize: 50);

            // Assert
            result.Items.Select(a => a.City).Should().BeInAscendingOrder();
        }

        [Fact]
        public async Task GetAllAsync_WithInvalidPage_ReturnsEmptyResults()
        {
            // Arrange
            await using var db = CreateDbContext();
            var addresses = CreateTestAddresses(10);
            db.Addresses.AddRange(addresses);
            await db.SaveChangesAsync();

            var service = new AddressService(db, new NullLogger<AddressService>());

            // Act
            var result = await service.GetAllAsync(page: 100, pageSize: 10);

            // Assert
            result.Items.Should().BeEmpty();
            result.TotalCount.Should().Be(10);
        }

        #endregion

        #region GetByIdAsync Tests

        [Fact]
        public async Task GetByIdAsync_WithValidId_ReturnsAddress()
        {
            // Arrange
            await using var db = CreateDbContext();
            var address = CreateTestAddress(id: Guid.NewGuid());
            db.Addresses.Add(address);
            await db.SaveChangesAsync();

            var service = new AddressService(db, new NullLogger<AddressService>());

            // Act
            var result = await service.GetByIdAsync(address.Id);

            // Assert
            result.Should().NotBeNull();
            result!.Id.Should().Be(address.Id);
            result.ContactName.Should().Be(address.ContactName);
            result.City.Should().Be(address.City);
        }

        [Fact]
        public async Task GetByIdAsync_WithInvalidId_ReturnsNull()
        {
            // Arrange
            await using var db = CreateDbContext();
            var service = new AddressService(db, new NullLogger<AddressService>());
            var invalidId = Guid.NewGuid();

            // Act
            var result = await service.GetByIdAsync(invalidId);

            // Assert
            result.Should().BeNull();
        }

        [Fact]
        public async Task GetByIdAsync_MapsAllProperties()
        {
            // Arrange
            await using var db = CreateDbContext();
            var address = new Address
            {
                Id = Guid.NewGuid(),
                Street1 = "123 Main St",
                Street2 = "Suite 200",
                City = "Boston",
                State = "MA",
                PostalCode = "02101",
                CountryCode = "US",
                IsResidential = false,
                ContactName = "Acme Corp",
                CompanyName = "Acme Inc",
                Phone = "555-1234",
                Email = "info@acme.com"
            };

            db.Addresses.Add(address);
            await db.SaveChangesAsync();

            var service = new AddressService(db, new NullLogger<AddressService>());

            // Act
            var result = await service.GetByIdAsync(address.Id);

            // Assert
            result.Should().NotBeNull();
            result!.Street1.Should().Be(address.Street1);
            result.Street2.Should().Be(address.Street2);
            result.City.Should().Be(address.City);
            result.State.Should().Be(address.State);
            result.PostalCode.Should().Be(address.PostalCode);
            result.CountryCode.Should().Be(address.CountryCode);
            result.IsResidential.Should().Be(address.IsResidential);
            result.ContactName.Should().Be(address.ContactName);
            result.CompanyName.Should().Be(address.CompanyName);
            result.Phone.Should().Be(address.Phone);
            result.Email.Should().Be(address.Email);
        }

        #endregion

        #region CreateAsync Tests

        [Fact]
        public async Task CreateAsync_WithValidRequest_CreatesAddress()
        {
            // Arrange
            await using var db = CreateDbContext();
            var service = new AddressService(db, new NullLogger<AddressService>());

            var request = new CreateAddressRequest
            {
                Street1 = "456 Oak Ave",
                City = "New York",
                State = "NY",
                PostalCode = "10001",
                CountryCode = "US",
                IsResidential = true,
                ContactName = "John Shipper",
                Phone = "555-9999"
            };

            // Act
            var result = await service.CreateAsync(request);

            // Assert
            result.Should().NotBeNull();
            result.Id.Should().NotBe(Guid.Empty);
            result.Street1.Should().Be(request.Street1);
            result.City.Should().Be(request.City);
            result.ContactName.Should().Be(request.ContactName);

            // Verify it's actually in database
            var dbAddress = await db.Addresses.FindAsync(result.Id);
            dbAddress.Should().NotBeNull();
        }

        [Fact]
        public async Task CreateAsync_WithOptionalFields_CreatesAddressWithNulls()
        {
            // Arrange
            await using var db = CreateDbContext();
            var service = new AddressService(db, new NullLogger<AddressService>());

            var request = new CreateAddressRequest
            {
                Street1 = "789 Elm St",
                Street2 = null,
                City = "Boston",
                State = "MA",
                PostalCode = "02101",
                CountryCode = "US",
                IsResidential = false,
                ContactName = "Business Name",
                CompanyName = null,
                Phone = "555-1111",
                Email = null
            };

            // Act
            var result = await service.CreateAsync(request);

            // Assert
            result.Street2.Should().BeNull();
            result.CompanyName.Should().BeNull();
            result.Email.Should().BeNull();
        }

        [Fact]
        public async Task CreateAsync_GeneratesUniqueIds()
        {
            // Arrange
            await using var db = CreateDbContext();
            var service = new AddressService(db, new NullLogger<AddressService>());

            var request1 = CreateTestCreateRequest();
            var request2 = CreateTestCreateRequest();

            // Act
            var result1 = await service.CreateAsync(request1);
            var result2 = await service.CreateAsync(request2);

            // Assert
            result1.Id.Should().NotBe(result2.Id);
        }

        [Fact]
        public async Task CreateAsync_PersistsToDatabase()
        {
            // Arrange
            await using var db = CreateDbContext();
            var service = new AddressService(db, new NullLogger<AddressService>());

            var request = CreateTestCreateRequest();

            // Act
            var createdDto = await service.CreateAsync(request);

            // Assert - retrieve from database to verify persistence
            var dbAddress = await db.Addresses.FirstAsync();
            dbAddress.Id.Should().Be(createdDto.Id);
            dbAddress.ContactName.Should().Be(request.ContactName);
        }

        #endregion

        #region UpdateAsync Tests

        [Fact]
        public async Task UpdateAsync_WithValidId_UpdatesAddress()
        {
            // Arrange
            await using var db = CreateDbContext();
            var address = CreateTestAddress();
            db.Addresses.Add(address);
            await db.SaveChangesAsync();

            var service = new AddressService(db, new NullLogger<AddressService>());

            var updateRequest = new UpdateAddressRequest
            {
                Street1 = "999 New Street",
                City = "Updated City",
                State = "XX",
                PostalCode = "99999",
                CountryCode = "US",
                IsResidential = false,
                ContactName = "Updated Name",
                Phone = "555-9999"
            };

            // Act
            var result = await service.UpdateAsync(address.Id, updateRequest);

            // Assert
            result.Should().NotBeNull();
            result!.Street1.Should().Be(updateRequest.Street1);
            result.City.Should().Be(updateRequest.City);
            result.ContactName.Should().Be(updateRequest.ContactName);
        }

        [Fact]
        public async Task UpdateAsync_WithInvalidId_ReturnsNull()
        {
            // Arrange
            await using var db = CreateDbContext();
            var service = new AddressService(db, new NullLogger<AddressService>());

            var updateRequest = new UpdateAddressRequest
            {
                Street1 = "999 New Street",
                City = "Updated City",
                State = "XX",
                PostalCode = "99999",
                CountryCode = "US",
                ContactName = "Updated Name",
                Phone = "555-9999"
            };

            // Act
            var result = await service.UpdateAsync(Guid.NewGuid(), updateRequest);

            // Assert
            result.Should().BeNull();
        }

        [Fact]
        public async Task UpdateAsync_PersistsChangesToDatabase()
        {
            // Arrange
            await using var db = CreateDbContext();
            var address = CreateTestAddress();
            db.Addresses.Add(address);
            await db.SaveChangesAsync();

            var service = new AddressService(db, new NullLogger<AddressService>());

            var updateRequest = new UpdateAddressRequest
            {
                Street1 = "Updated Street",
                City = "Updated City",
                State = "UC",
                PostalCode = "00000",
                CountryCode = "CA",
                ContactName = "New Contact",
                Phone = "555-5555"
            };

            // Act
            var result = await service.UpdateAsync(address.Id, updateRequest);

            // Assert - query database again to verify persistence
            var dbAddress = await db.Addresses.FindAsync(address.Id);
            dbAddress.Should().NotBeNull();
            dbAddress!.Street1.Should().Be(updateRequest.Street1);
            dbAddress.City.Should().Be(updateRequest.City);
        }

        [Fact]
        public async Task UpdateAsync_UpdatesAllFields()
        {
            // Arrange
            await using var db = CreateDbContext();
            var address = new Address
            {
                Id = Guid.NewGuid(),
                Street1 = "Old St1",
                Street2 = "Old St2",
                City = "Old City",
                State = "OO",
                PostalCode = "00000",
                CountryCode = "US",
                IsResidential = true,
                ContactName = "Old Name",
                CompanyName = "Old Company",
                Phone = "555-0000",
                Email = "old@example.com"
            };

            db.Addresses.Add(address);
            await db.SaveChangesAsync();

            var service = new AddressService(db, new NullLogger<AddressService>());

            var updateRequest = new UpdateAddressRequest
            {
                Street1 = "New St1",
                Street2 = "New St2",
                City = "New City",
                State = "NN",
                PostalCode = "11111",
                CountryCode = "CA",
                IsResidential = false,
                ContactName = "New Name",
                CompanyName = "New Company",
                Phone = "555-1111",
                Email = "new@example.com"
            };

            // Act
            var result = await service.UpdateAsync(address.Id, updateRequest);

            // Assert
            result.Should().NotBeNull();
            result!.Street1.Should().Be(updateRequest.Street1);
            result.Street2.Should().Be(updateRequest.Street2);
            result.City.Should().Be(updateRequest.City);
            result.State.Should().Be(updateRequest.State);
            result.PostalCode.Should().Be(updateRequest.PostalCode);
            result.CountryCode.Should().Be(updateRequest.CountryCode);
            result.IsResidential.Should().Be(updateRequest.IsResidential);
            result.ContactName.Should().Be(updateRequest.ContactName);
            result.CompanyName.Should().Be(updateRequest.CompanyName);
            result.Phone.Should().Be(updateRequest.Phone);
            result.Email.Should().Be(updateRequest.Email);
        }

        #endregion

        #region DeleteAsync Tests

        [Fact]
        public async Task DeleteAsync_WithValidId_DeletesAddress()
        {
            // Arrange
            await using var db = CreateDbContext();
            var address = CreateTestAddress();
            db.Addresses.Add(address);
            await db.SaveChangesAsync();

            var service = new AddressService(db, new NullLogger<AddressService>());

            // Act
            var result = await service.DeleteAsync(address.Id);

            // Assert
            result.Should().BeTrue();
            var deletedAddress = await db.Addresses.FindAsync(address.Id);
            deletedAddress.Should().BeNull();
        }

        [Fact]
        public async Task DeleteAsync_WithInvalidId_ReturnsFalse()
        {
            // Arrange
            await using var db = CreateDbContext();
            var service = new AddressService(db, new NullLogger<AddressService>());

            // Act
            var result = await service.DeleteAsync(Guid.NewGuid());

            // Assert
            result.Should().BeFalse();
        }

        [Fact]
        public async Task DeleteAsync_WhenAddressReferencedByParcel_ThrowsInvalidOperationException()
        {
            // Arrange
            await using var db = CreateDbContext();
            var address = CreateTestAddress();
            var parcel = new Parcel
            {
                Id = Guid.NewGuid(),
                TrackingNumber = "TEST-001",
                ShipperAddressId = address.Id,
                RecipientAddressId = Guid.NewGuid(),
                Weight = 1,
                WeightUnit = WeightUnit.Kg,
                Length = 10,
                Width = 10,
                Height = 10,
                DimensionUnit = DimensionUnit.Cm,
                DeclaredValue = 100,
                Currency = "USD",
                ServiceType = ServiceType.Standard,
                Status = ParcelStatus.LabelCreated
            };

            var recipientAddress = CreateTestAddress(Guid.NewGuid());

            db.Addresses.Add(address);
            db.Addresses.Add(recipientAddress);
            parcel.RecipientAddressId = recipientAddress.Id;
            db.Parcels.Add(parcel);
            await db.SaveChangesAsync();

            var service = new AddressService(db, new NullLogger<AddressService>());

            // Act & Assert
            var ex = await Assert.ThrowsAsync<InvalidOperationException>(
                () => service.DeleteAsync(address.Id));

            ex.Message.Should().Contain("referenced by existing parcels");
        }

        [Fact]
        public async Task DeleteAsync_WhenAddressReferencedAsRecipient_ThrowsInvalidOperationException()
        {
            // Arrange
            await using var db = CreateDbContext();
            var shipperAddress = CreateTestAddress(Guid.NewGuid());
            var recipientAddress = CreateTestAddress(Guid.NewGuid());

            var parcel = new Parcel
            {
                Id = Guid.NewGuid(),
                TrackingNumber = "TEST-002",
                ShipperAddressId = shipperAddress.Id,
                RecipientAddressId = recipientAddress.Id,
                Weight = 1,
                WeightUnit = WeightUnit.Kg,
                Length = 10,
                Width = 10,
                Height = 10,
                DimensionUnit = DimensionUnit.Cm,
                DeclaredValue = 100,
                Currency = "USD",
                ServiceType = ServiceType.Standard,
                Status = ParcelStatus.LabelCreated
            };

            db.Addresses.Add(shipperAddress);
            db.Addresses.Add(recipientAddress);
            db.Parcels.Add(parcel);
            await db.SaveChangesAsync();

            var service = new AddressService(db, new NullLogger<AddressService>());

            // Act & Assert
            var ex = await Assert.ThrowsAsync<InvalidOperationException>(
                () => service.DeleteAsync(recipientAddress.Id));

            ex.Message.Should().Contain("referenced by existing parcels");
        }

        [Fact]
        public async Task DeleteAsync_WhenAddressNotReferenced_SucceedsEvenWithOtherAddresses()
        {
            // Arrange
            await using var db = CreateDbContext();
            var addressToDelete = CreateTestAddress(Guid.NewGuid());
            var otherAddress1 = CreateTestAddress(Guid.NewGuid());
            var otherAddress2 = CreateTestAddress(Guid.NewGuid());

            db.Addresses.Add(addressToDelete);
            db.Addresses.Add(otherAddress1);
            db.Addresses.Add(otherAddress2);
            await db.SaveChangesAsync();

            var service = new AddressService(db, new NullLogger<AddressService>());

            // Act
            var result = await service.DeleteAsync(addressToDelete.Id);

            // Assert
            result.Should().BeTrue();
            var remaining = await db.Addresses.ToListAsync();
            remaining.Should().HaveCount(2);
            remaining.Should().AllSatisfy(a => a.Id.Should().NotBe(addressToDelete.Id));
        }

        #endregion

        #region Helper Methods

        private Address CreateTestAddress(Guid? id = null)
        {
            return new Address
            {
                Id = id ?? Guid.NewGuid(),
                Street1 = "123 Test St",
                Street2 = null,
                City = "Test City",
                State = "TS",
                PostalCode = "12345",
                CountryCode = "US",
                IsResidential = true,
                ContactName = "Test Contact",
                CompanyName = null,
                Phone = "555-1234",
                Email = "test@example.com"
            };
        }

        private List<Address> CreateTestAddresses(int count)
        {
            var addresses = new List<Address>();
            for (int i = 0; i < count; i++)
            {
                addresses.Add(new Address
                {
                    Id = Guid.NewGuid(),
                    Street1 = $"{i} Test Street",
                    City = $"City {i:D2}",
                    State = "TS",
                    PostalCode = $"{i:D5}",
                    CountryCode = "US",
                    ContactName = $"Contact {i}",
                    Phone = $"555-{i:D4}"
                });
            }
            return addresses;
        }

        private CreateAddressRequest CreateTestCreateRequest()
        {
            return new CreateAddressRequest
            {
                Street1 = "123 Test St",
                City = "Test City",
                State = "TS",
                PostalCode = "12345",
                CountryCode = "US",
                ContactName = "Test Contact",
                Phone = "555-1234"
            };
        }

        #endregion
    }
}