DeliveryEstimationServiceTests.cs

using FluentAssertions;
using ParcelTracking.Application.DTOs.EstimatedDelivery;
using ParcelTracking.Application.Services;
using ParcelTracking.Domain.Entities;
using ParcelTracking.Domain.Enums;
using System;
using Xunit;

namespace ParcelTracking.Application.Tests
{
    public class DeliveryEstimationServiceTests
    {
        private readonly DeliveryEstimationService _service;

        public DeliveryEstimationServiceTests()
        {
            _service = new DeliveryEstimationService();
        }

        [Theory]
        [InlineData(ServiceType.Economy, false, 5, 7)]
        [InlineData(ServiceType.Standard, false, 3, 5)]
        [InlineData(ServiceType.Express, false, 1, 2)]
        [InlineData(ServiceType.Overnight, false, 1, 1)]
        [InlineData(ServiceType.Economy, true, 8, 12)]
        [InlineData(ServiceType.Standard, true, 6, 10)]
        [InlineData(ServiceType.Express, true, 4, 7)]
        [InlineData(ServiceType.Overnight, true, 4, 6)]
        public void Calculate_ReturnsCorrectTransitTimes(ServiceType serviceType, bool isInternational, int expectedMin, int expectedMax)
        {
            // Arrange
            var createdAt = new DateTimeOffset(2023, 1, 1, 10, 0, 0, TimeSpan.Zero); // Monday
            var parcel = new Parcel
            {
                Id = Guid.NewGuid(),
                CreatedAt = createdAt,
                ServiceType = serviceType,
                Status = ParcelStatus.LabelCreated,
                ShipperAddress = new Address { CountryCode = isInternational ? "US" : "CA" },
                RecipientAddress = new Address { CountryCode = "CA" }
            };

            // Act
            var result = _service.Calculate(parcel);

            // Assert
            var expectedEarliest = AddBusinessDays(DateOnly.FromDateTime(createdAt.DateTime), expectedMin);
            var expectedLatest = AddBusinessDays(DateOnly.FromDateTime(createdAt.DateTime), expectedMax);

            result.EarliestDelivery.Should().Be(expectedEarliest);
            result.LatestDelivery.Should().Be(expectedLatest);
            result.Confidence.Should().Be(DeliveryConfidenceLevel.Low);
        }

        [Theory]
        [InlineData(ParcelStatus.LabelCreated, DeliveryConfidenceLevel.Low)]
        [InlineData(ParcelStatus.InTransit, DeliveryConfidenceLevel.Medium)]
        [InlineData(ParcelStatus.OutForDelivery, DeliveryConfidenceLevel.High)]
        [InlineData(ParcelStatus.Delivered, DeliveryConfidenceLevel.High)]
        public void Calculate_ReturnsCorrectConfidence(ParcelStatus status, DeliveryConfidenceLevel expectedConfidence)
        {
            // Arrange
            var parcel = new Parcel
            {
                Id = Guid.NewGuid(),
                CreatedAt = DateTimeOffset.UtcNow,
                ServiceType = ServiceType.Standard,
                Status = status,
                ShipperAddress = new Address { CountryCode = "US" },
                RecipientAddress = new Address { CountryCode = "US" }
            };

            // Act
            var result = _service.Calculate(parcel);

            // Assert
            result.Confidence.Should().Be(expectedConfidence);
        }

        [Fact]
        public void Calculate_HandlesInternationalShipping()
        {
            // Arrange
            var parcel = new Parcel
            {
                Id = Guid.NewGuid(),
                CreatedAt = new DateTimeOffset(2023, 1, 1, 10, 0, 0, TimeSpan.Zero),
                ServiceType = ServiceType.Standard,
                Status = ParcelStatus.LabelCreated,
                ShipperAddress = new Address { CountryCode = "US" },
                RecipientAddress = new Address { CountryCode = "CA" }
            };

            // Act
            var result = _service.Calculate(parcel);

            // Assert - Standard domestic is 3-5, international adds 3-5, so 6-10
            var expectedEarliest = AddBusinessDays(DateOnly.FromDateTime(parcel.CreatedAt.DateTime), 6);
            var expectedLatest = AddBusinessDays(DateOnly.FromDateTime(parcel.CreatedAt.DateTime), 10);

            result.EarliestDelivery.Should().Be(expectedEarliest);
            result.LatestDelivery.Should().Be(expectedLatest);
        }

        [Fact]
        public void Recalculate_AdjustsBasedOnElapsedTime()
        {
            // Arrange
            var createdAt = new DateTimeOffset(2023, 1, 1, 10, 0, 0, TimeSpan.Zero); // Monday
            var fromDate = DateOnly.FromDateTime(createdAt.AddDays(2).DateTime); // Wednesday, 2 business days elapsed
            var parcel = new Parcel
            {
                Id = Guid.NewGuid(),
                CreatedAt = createdAt,
                ServiceType = ServiceType.Standard, // 3-5 days domestic
                Status = ParcelStatus.InTransit,
                ShipperAddress = new Address { CountryCode = "US" },
                RecipientAddress = new Address { CountryCode = "US" }
            };

            // Act
            var result = _service.Recalculate(parcel, fromDate);

            // Assert - Remaining time: max(1, 3-2)=1 to max(1, 5-2)=3
            var expectedEarliest = AddBusinessDays(fromDate, 1);
            var expectedLatest = AddBusinessDays(fromDate, 3);

            result.EarliestDelivery.Should().Be(expectedEarliest);
            result.LatestDelivery.Should().Be(expectedLatest);
            result.Confidence.Should().Be(DeliveryConfidenceLevel.Medium);
        }

        [Fact]
        public void Recalculate_NeverGoesBelowOneDay()
        {
            // Arrange
            var createdAt = new DateTimeOffset(2023, 1, 1, 10, 0, 0, TimeSpan.Zero);
            var fromDate = DateOnly.FromDateTime(createdAt.AddDays(10).DateTime); // Way past original estimate
            var parcel = new Parcel
            {
                Id = Guid.NewGuid(),
                CreatedAt = createdAt,
                ServiceType = ServiceType.Express, // 1-2 days
                Status = ParcelStatus.InTransit,
                ShipperAddress = new Address { CountryCode = "US" },
                RecipientAddress = new Address { CountryCode = "US" }
            };

            // Act
            var result = _service.Recalculate(parcel, fromDate);

            // Assert - Remaining time should be at least 1 day
            var expectedEarliest = AddBusinessDays(fromDate, 1);
            var expectedLatest = AddBusinessDays(fromDate, 1); // max(1, 2-10)=1

            result.EarliestDelivery.Should().Be(expectedEarliest);
            result.LatestDelivery.Should().Be(expectedLatest);
        }

        private static DateOnly AddBusinessDays(DateOnly startDate, int businessDays)
        {
            var current = startDate;
            var added = 0;

            while (added < businessDays)
            {
                current = current.AddDays(1);

                if (current.DayOfWeek is not DayOfWeek.Saturday
                    and not DayOfWeek.Sunday)
                {
                    added++;
                }
            }

            return current;
        }
    }
}