DeliveryEstimateControllerIntegrationTests.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Json;
using System.Threading.Tasks;
using FluentAssertions;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using ParcelTracking.Application.DTOs.EstimatedDelivery;
using ParcelTracking.Domain.Entities;
using ParcelTracking.Domain.Enums;
using ParcelTracking.Infrastructure.Data;
using Xunit;

namespace ParcelTracking.API.IntegrationTests
{
    /// <summary>
    /// Integration tests for the DeliveryEstimate Controller endpoints.
    ///
    /// These tests require a PostgreSQL database. To run with Docker:
    /// docker run -d --name parceltrack-test-db -e POSTGRES_USER=test -e POSTGRES_PASSWORD=test -e POSTGRES_DB=parceltracking_test -p 5433:5432 postgres:15
    ///
    /// Then update the connection string in this test class to point to your database instance.
    /// </summary>
    public class DeliveryEstimateControllerIntegrationTests : IAsyncLifetime
    {
        private WebApplicationFactory<Program>? _factory;
        private HttpClient? _client;
        private string? _connectionString;

        public async Task InitializeAsync()
        {
            // Use a connection string pointing to a running Postgres instance
            // Set via environment variable or use default test database
            _connectionString = Environment.GetEnvironmentVariable("PARCELTRACK_TEST_DB")
                ?? "Host=localhost;Port=5433;Database=parceltracking_test;Username=test;Password=test;Pooling=false;";

            try
            {
                _factory = new WebApplicationFactory<Program>()
                    .WithWebHostBuilder(builder =>
                    {
                        builder.ConfigureAppConfiguration((context, cfg) =>
                        {
                            var inMemConfig = new Dictionary<string, string?>
                            {
                                {"ConnectionStrings:DefaultConnection", _connectionString}
                            };
                            cfg.AddInMemoryCollection(inMemConfig);
                        });
                    });

                _client = _factory.CreateClient();

                // Ensure database is created and migrated
                var options = new DbContextOptionsBuilder<ParcelTrackingDbContext>()
                    .UseNpgsql(_connectionString)
                    .Options;

                using (var db = new ParcelTrackingDbContext(options))
                {
                    db.Database.EnsureCreated();
                }
            }
            catch (Exception)
            {
                // If Docker PostgreSQL is not available, silently skip these tests
                _connectionString = null;
                _factory?.Dispose();
                _factory = null;
                _client = null;
            }
        }

        public async Task DisposeAsync()
        {
            _client?.Dispose();
            _factory?.Dispose();
        }

        [Fact]
        public async Task GetEstimate_WithValidParcelId_Returns200WithEstimate()
        {
            // Skip test if Docker database is not available
            if (_client == null || _connectionString == null)
            {
                throw new SkipTestException("PostgreSQL database not available. Start Docker container with: docker run -d --name parceltrack-test-db -e POSTGRES_USER=test -e POSTGRES_PASSWORD=test -e POSTGRES_DB=parceltracking_test -p 5433:5432 postgres:15");
            }

            // Arrange: seed test data
            var options = new DbContextOptionsBuilder<ParcelTrackingDbContext>()
                .UseNpgsql(_connectionString)
                .Options;

            Guid parcelId;
            using (var db = new ParcelTrackingDbContext(options))
            {
                // Clear existing data
                db.TrackingEvents.RemoveRange(db.TrackingEvents);
                db.Parcels.RemoveRange(db.Parcels);
                db.Addresses.RemoveRange(db.Addresses);
                await db.SaveChangesAsync();

                var shipper = new Address
                {
                    Id = Guid.NewGuid(),
                    CountryCode = "US",
                    City = "New York",
                    Street1 = "123 Main St"
                };
                var recipient = new Address
                {
                    Id = Guid.NewGuid(),
                    CountryCode = "US",
                    City = "Los Angeles",
                    Street1 = "456 Oak Ave"
                };

                var parcel = new Parcel
                {
                    Id = Guid.NewGuid(),
                    TrackingNumber = "TEST_ESTIMATE_001",
                    ShipperAddressId = shipper.Id,
                    RecipientAddressId = recipient.Id,
                    ServiceType = ServiceType.Standard,
                    Status = ParcelStatus.InTransit,
                    CreatedAt = DateTime.UtcNow.AddDays(-2),
                    Weight = 1.5m,
                    WeightUnit = WeightUnit.Kg,
                    Length = 30,
                    Width = 20,
                    Height = 10,
                    DimensionUnit = DimensionUnit.Cm,
                    DeclaredValue = 100.00m,
                    Currency = "USD"
                };

                db.Addresses.Add(shipper);
                db.Addresses.Add(recipient);
                db.Parcels.Add(parcel);
                await db.SaveChangesAsync();

                parcelId = parcel.Id;
            }

            // Act
            var response = await _client.GetAsync($"/api/v1/DeliveryEstimate/{parcelId}");

            // Assert
            response.StatusCode.Should().Be(HttpStatusCode.OK);

            var estimate = await response.Content.ReadFromJsonAsync<EstimatedDeliveryDto>();
            estimate.Should().NotBeNull();
            estimate.ServiceType.Should().Be("Standard");
            estimate.IsInternational.Should().BeFalse();
            estimate.Confidence.Should().Be("Medium"); // InTransit status
            estimate.EarliestDelivery.Should().BeAfter(DateOnly.FromDateTime(DateTime.UtcNow));
            estimate.LatestDelivery.Should().BeOnOrAfter(estimate.EarliestDelivery);
        }

        [Fact]
        public async Task GetEstimate_WithInvalidParcelId_Returns404()
        {
            // Skip test if Docker database is not available
            if (_client == null || _connectionString == null)
            {
                throw new SkipTestException("PostgreSQL database not available. Start Docker container with: docker run -d --name parceltrack-test-db -e POSTGRES_USER=test -e POSTGRES_PASSWORD=test -e POSTGRES_DB=parceltracking_test -p 5433:5432 postgres:15");
            }

            // Act
            var response = await _client.GetAsync($"/api/v1/DeliveryEstimate/{Guid.NewGuid()}");

            // Assert
            response.StatusCode.Should().Be(HttpStatusCode.NotFound);

            var problemDetails = await response.Content.ReadFromJsonAsync<ProblemDetails>();
            problemDetails.Should().NotBeNull();
            problemDetails.Title.Should().Be("Parcel Not Found");
            problemDetails.Status.Should().Be(404);
        }

        [Fact]
        public async Task GetEstimate_WithDeliveredParcel_ReturnsActualDeliveryDate()
        {
            // Skip test if Docker database is not available
            if (_client == null || _connectionString == null)
            {
                throw new SkipTestException("PostgreSQL database not available. Start Docker container with: docker run -d --name parceltrack-test-db -e POSTGRES_USER=test -e POSTGRES_PASSWORD=test -e POSTGRES_DB=parceltracking_test -p 5433:5432 postgres:15");
            }

            // Arrange: seed test data
            var options = new DbContextOptionsBuilder<ParcelTrackingDbContext>()
                .UseNpgsql(_connectionString)
                .Options;

            Guid parcelId;
            var actualDeliveryDate = new DateTimeOffset(2023, 12, 15, 14, 30, 0, TimeSpan.Zero);

            using (var db = new ParcelTrackingDbContext(options))
            {
                // Clear existing data
                db.TrackingEvents.RemoveRange(db.TrackingEvents);
                db.Parcels.RemoveRange(db.Parcels);
                db.Addresses.RemoveRange(db.Addresses);
                await db.SaveChangesAsync();

                var shipper = new Address
                {
                    Id = Guid.NewGuid(),
                    CountryCode = "US",
                    City = "New York",
                    Street1 = "123 Main St"
                };
                var recipient = new Address
                {
                    Id = Guid.NewGuid(),
                    CountryCode = "CA",
                    City = "Toronto",
                    Street1 = "456 Oak Ave"
                };

                var parcel = new Parcel
                {
                    Id = Guid.NewGuid(),
                    TrackingNumber = "TEST_DELIVERED_001",
                    ShipperAddressId = shipper.Id,
                    RecipientAddressId = recipient.Id,
                    ServiceType = ServiceType.Express,
                    Status = ParcelStatus.Delivered,
                    ActualDeliveryDate = actualDeliveryDate,
                    CreatedAt = DateTime.UtcNow.AddDays(-5),
                    Weight = 2.0m,
                    WeightUnit = WeightUnit.Kg,
                    Length = 40,
                    Width = 30,
                    Height = 20,
                    DimensionUnit = DimensionUnit.Cm,
                    DeclaredValue = 200.00m,
                    Currency = "USD"
                };

                db.Addresses.Add(shipper);
                db.Addresses.Add(recipient);
                db.Parcels.Add(parcel);
                await db.SaveChangesAsync();

                parcelId = parcel.Id;
            }

            // Act
            var response = await _client.GetAsync($"/api/v1/DeliveryEstimate/{parcelId}");

            // Assert
            response.StatusCode.Should().Be(HttpStatusCode.OK);

            var estimate = await response.Content.ReadFromJsonAsync<EstimatedDeliveryDto>();
            estimate.Should().NotBeNull();
            estimate.EarliestDelivery.Should().Be(DateOnly.FromDateTime(actualDeliveryDate.DateTime));
            estimate.LatestDelivery.Should().Be(DateOnly.FromDateTime(actualDeliveryDate.DateTime));
            estimate.Confidence.Should().Be("High");
            estimate.ServiceType.Should().Be("Express");
            estimate.IsInternational.Should().BeTrue(); // US to CA
        }

        [Fact]
        public async Task GetEstimate_WithInternationalParcel_ReturnsCorrectEstimate()
        {
            // Skip test if Docker database is not available
            if (_client == null || _connectionString == null)
            {
                throw new SkipTestException("PostgreSQL database not available. Start Docker container with: docker run -d --name parceltrack-test-db -e POSTGRES_USER=test -e POSTGRES_PASSWORD=test -e POSTGRES_DB=parceltracking_test -p 5433:5432 postgres:15");
            }

            // Arrange: seed test data
            var options = new DbContextOptionsBuilder<ParcelTrackingDbContext>()
                .UseNpgsql(_connectionString)
                .Options;

            Guid parcelId;
            using (var db = new ParcelTrackingDbContext(options))
            {
                // Clear existing data
                db.TrackingEvents.RemoveRange(db.TrackingEvents);
                db.Parcels.RemoveRange(db.Parcels);
                db.Addresses.RemoveRange(db.Addresses);
                await db.SaveChangesAsync();

                var shipper = new Address
                {
                    Id = Guid.NewGuid(),
                    CountryCode = "US",
                    City = "New York",
                    Street1 = "123 Main St"
                };
                var recipient = new Address
                {
                    Id = Guid.NewGuid(),
                    CountryCode = "GB",
                    City = "London",
                    Street1 = "456 Oak Ave"
                };

                var parcel = new Parcel
                {
                    Id = Guid.NewGuid(),
                    TrackingNumber = "TEST_INTL_001",
                    ShipperAddressId = shipper.Id,
                    RecipientAddressId = recipient.Id,
                    ServiceType = ServiceType.Overnight,
                    Status = ParcelStatus.LabelCreated,
                    CreatedAt = DateTime.UtcNow,
                    Weight = 0.5m,
                    WeightUnit = WeightUnit.Kg,
                    Length = 25,
                    Width = 15,
                    Height = 5,
                    DimensionUnit = DimensionUnit.Cm,
                    DeclaredValue = 50.00m,
                    Currency = "USD"
                };

                db.Addresses.Add(shipper);
                db.Addresses.Add(recipient);
                db.Parcels.Add(parcel);
                await db.SaveChangesAsync();

                parcelId = parcel.Id;
            }

            // Act
            var response = await _client.GetAsync($"/api/v1/DeliveryEstimate/{parcelId}");

            // Assert
            response.StatusCode.Should().Be(HttpStatusCode.OK);

            var estimate = await response.Content.ReadFromJsonAsync<EstimatedDeliveryDto>();
            estimate.Should().NotBeNull();
            estimate.ServiceType.Should().Be("Overnight");
            estimate.IsInternational.Should().BeTrue(); // US to GB
            estimate.Confidence.Should().Be("Low"); // LabelCreated status
            estimate.EarliestDelivery.Should().BeAfter(DateOnly.FromDateTime(DateTime.UtcNow));
            estimate.LatestDelivery.Should().BeOnOrAfter(estimate.EarliestDelivery);
        }
    }
}