elias/booking-microservices
1
0
Fork 0
mirror of https://github.com/meysamhadeli/booking-microservices.git synced 2026-04-25 14:54:06 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor test-base

Browse Source
This commit is contained in:
meysamhadeli 2022-11-18 19:22:11 +03:30
parent 143600d4f9
commit 63e065338e
26 changed files with 107 additions and 532 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
src/BuildingBlocks/TestBase/IntegrationTestBase.cs
View File

@ -6,6 +6,7 @@ using BuildingBlocks.MassTransit;
using BuildingBlocks.Mongo;
using BuildingBlocks.PersistMessageProcessor;
using BuildingBlocks.Web;
using DotNet.Testcontainers.Containers;
using Grpc.Net.Client;
using MassTransit;
using MassTransit.Testing;
@ -26,7 +27,7 @@ using Xunit.Abstractions;
namespace BuildingBlocks.TestBase;
public class IntegrationTestFixture<TEntryPoint> : IAsyncLifetime
public class IntegrationTestFactory<TEntryPoint> : IAsyncLifetime
where TEntryPoint : class
{
private readonly WebApplicationFactory<TEntryPoint> _factory;
@ -39,8 +40,7 @@ public class IntegrationTestFixture<TEntryPoint> : IAsyncLifetime
public IServiceProvider ServiceProvider => _factory.Services;
public IConfiguration Configuration => _factory.Services.GetRequiredService<IConfiguration>();
public IntegrationTestFixture()
public IntegrationTestFactory()
{
_factory = new WebApplicationFactory<TEntryPoint>()
.WithWebHostBuilder(builder =>
@ -69,6 +69,7 @@ public class IntegrationTestFixture<TEntryPoint> : IAsyncLifetime
});
}
public Task InitializeAsync()
{
return Task.CompletedTask;
@ -195,7 +196,7 @@ public class IntegrationTestFixture<TEntryPoint> : IAsyncLifetime
}
}
public class IntegrationTestFixture<TEntryPoint, TWContext> : IntegrationTestFixture<TEntryPoint>
public class IntegrationTestFactory<TEntryPoint, TWContext> : IntegrationTestFactory<TEntryPoint>
where TEntryPoint : class
where TWContext : DbContext
{
@ -302,7 +303,7 @@ public class IntegrationTestFixture<TEntryPoint, TWContext> : IntegrationTestFix
}
}
public class IntegrationTestFixture<TEntryPoint, TWContext, TRContext> : IntegrationTestFixture<TEntryPoint, TWContext>
public class IntegrationTestFactory<TEntryPoint, TWContext, TRContext> : IntegrationTestFactory<TEntryPoint, TWContext>
where TEntryPoint : class
where TWContext : DbContext
where TRContext : MongoDbContext
@ -325,28 +326,36 @@ public class IntegrationTestFixtureCore<TEntryPoint> : IAsyncLifetime
private Checkpoint _checkpointPersistMessageDB;
private MongoDbRunner _mongoRunner;
private string DefaultConnectionString
{
get => Fixture.ServiceProvider.GetRequiredService<IOptions<ConnectionStrings>>()?.Value.DefaultConnection;
set => Fixture.ServiceProvider.GetRequiredService<IOptions<ConnectionStrings>>().Value.DefaultConnection =
value;
}
private string PersistConnectionString
{
get => Fixture.ServiceProvider.GetRequiredService<IOptions<PersistMessageOptions>>()?.Value.ConnectionString;
set => Fixture.ServiceProvider.GetRequiredService<IOptions<PersistMessageOptions>>().Value.ConnectionString =
value;
}
private string MongoConnectionString
{
get => Fixture.ServiceProvider.GetRequiredService<IOptions<MongoOptions>>()?.Value?.ConnectionString;
set => Fixture.ServiceProvider.GetRequiredService<IOptions<MongoOptions>>().Value.ConnectionString = value;
}
private string PersistConnectionString => Fixture.ServiceProvider
.GetRequiredService<IOptions<PersistMessageOptions>>()?.Value.ConnectionString;
private string DefaultConnectionString => Fixture.Configuration?.GetConnectionString("DefaultConnection");
public IntegrationTestFixtureCore(IntegrationTestFixture<TEntryPoint> integrationTestFixture)
public IntegrationTestFixtureCore(IntegrationTestFactory<TEntryPoint> integrationTestFixture)
{
Fixture = integrationTestFixture;
integrationTestFixture.RegisterServices(services => RegisterTestsServices(services));
}
public IntegrationTestFixture<TEntryPoint> Fixture { get; }
public IntegrationTestFactory<TEntryPoint> Fixture { get; }
public async Task InitializeAsync()
{
//Todo: upgrade to new version Respawn
_checkpointDefaultDB = new Checkpoint {TablesToIgnore = new[] {"__EFMigrationsHistory"}};
_checkpointPersistMessageDB = new Checkpoint {TablesToIgnore = new[] {"__EFMigrationsHistory"}};
@ -355,6 +364,10 @@ public class IntegrationTestFixtureCore<TEntryPoint> : IAsyncLifetime
if (MongoConnectionString != null)
MongoConnectionString = _mongoRunner.ConnectionString;
// DefaultConnectionString = TestContainers.SqlTestContainer?.ConnectionString;
// PersistConnectionString = TestContainers.SqlPersistTestContainer?.ConnectionString;
// MongoConnectionString = TestContainers.MongoTestContainer?.ConnectionString;
await SeedDataAsync();
}
@ -366,7 +379,8 @@ public class IntegrationTestFixtureCore<TEntryPoint> : IAsyncLifetime
if (!string.IsNullOrEmpty(PersistConnectionString))
await _checkpointPersistMessageDB.Reset(PersistConnectionString);
_mongoRunner.Dispose();
if (!string.IsNullOrEmpty(PersistConnectionString))
_mongoRunner.Dispose();
}
protected virtual void RegisterTestsServices(IServiceCollection services)
@ -383,43 +397,43 @@ public class IntegrationTestFixtureCore<TEntryPoint> : IAsyncLifetime
}
public abstract class IntegrationTestBase<TEntryPoint> : IntegrationTestFixtureCore<TEntryPoint>,
IClassFixture<IntegrationTestFixture<TEntryPoint>>
IClassFixture<IntegrationTestFactory<TEntryPoint>>
where TEntryPoint : class
{
protected IntegrationTestBase(
IntegrationTestFixture<TEntryPoint> integrationTestFixture) : base(integrationTestFixture)
IntegrationTestFactory<TEntryPoint> integrationTestFixture) : base(integrationTestFixture)
{
Fixture = integrationTestFixture;
}
public new IntegrationTestFixture<TEntryPoint> Fixture { get; }
public new IntegrationTestFactory<TEntryPoint> Fixture { get; }
}
public abstract class IntegrationTestBase<TEntryPoint, TWContext> : IntegrationTestFixtureCore<TEntryPoint>,
IClassFixture<IntegrationTestFixture<TEntryPoint, TWContext>>
IClassFixture<IntegrationTestFactory<TEntryPoint, TWContext>>
where TEntryPoint : class
where TWContext : DbContext
{
protected IntegrationTestBase(
IntegrationTestFixture<TEntryPoint, TWContext> integrationTestFixture) : base(integrationTestFixture)
IntegrationTestFactory<TEntryPoint, TWContext> integrationTestFixture) : base(integrationTestFixture)
{
Fixture = integrationTestFixture;
}
public new IntegrationTestFixture<TEntryPoint, TWContext> Fixture { get; }
public new IntegrationTestFactory<TEntryPoint, TWContext> Fixture { get; }
}
public abstract class IntegrationTestBase<TEntryPoint, TWContext, TRContext> : IntegrationTestFixtureCore<TEntryPoint>,
IClassFixture<IntegrationTestFixture<TEntryPoint, TWContext, TRContext>>
IClassFixture<IntegrationTestFactory<TEntryPoint, TWContext, TRContext>>
where TEntryPoint : class
where TWContext : DbContext
where TRContext : MongoDbContext
{
protected IntegrationTestBase(
IntegrationTestFixture<TEntryPoint, TWContext, TRContext> integrationTestFixture) : base(integrationTestFixture)
IntegrationTestFactory<TEntryPoint, TWContext, TRContext> integrationTestFixture) : base(integrationTestFixture)
{
Fixture = integrationTestFixture;
}
public new IntegrationTestFixture<TEntryPoint, TWContext, TRContext> Fixture { get; }
public new IntegrationTestFactory<TEntryPoint, TWContext, TRContext> Fixture { get; }
}

484
src/BuildingBlocks/TestBase/TestContainer/IntegrationTestBase.cs
View File

@ -1,484 +0,0 @@
using Ardalis.GuardClauses;
using BuildingBlocks.Core.Event;
using BuildingBlocks.Core.Model;
using BuildingBlocks.EFCore;
using BuildingBlocks.MassTransit;
using BuildingBlocks.Mongo;
using BuildingBlocks.PersistMessageProcessor;
using BuildingBlocks.PersistMessageProcessor.Data;
using BuildingBlocks.Web;
using DotNet.Testcontainers.Builders;
using DotNet.Testcontainers.Configurations;
using DotNet.Testcontainers.Containers;
using Grpc.Net.Client;
using MassTransit;
using MassTransit.Testing;
using MediatR;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using NSubstitute;
using Serilog;
using Xunit;
using Xunit.Abstractions;
namespace BuildingBlocks.TestBase.TestContainer;
public class IntegrationTestFactory<TEntryPoint> : IAsyncLifetime
where TEntryPoint : class
{
private readonly WebApplicationFactory<TEntryPoint> _factory;
private int Timeout => 180;
public Action<IServiceCollection> TestRegistrationServices { set; get; }
public HttpClient HttpClient => _factory.CreateClient();
public ITestHarness TestHarness => CreateHarness();
public GrpcChannel Channel => CreateChannel();
public IServiceProvider ServiceProvider => _factory.Services;
public IConfiguration Configuration => _factory.Services.GetRequiredService<IConfiguration>();
public TestcontainerDatabase ContainerSqlDatabase;
public TestcontainerDatabase ContainerSqlPersistDatabase;
public TestcontainerDatabase ContainerMongoDatabase;
public string MongoConnectionString;
public string SqlConnectionString;
public string SqlPersistConnectionString;
public IntegrationTestFactory()
{
ContainerSqlDatabase = new TestcontainersBuilder<MsSqlTestcontainer>()
.WithDatabase(new MsSqlTestcontainerConfiguration {Database = "sql_test_db", Password = "localpassword#123uuuuu"})
.WithImage("mcr.microsoft.com/mssql/server:2017-latest")
.WithCleanUp(true)
.Build();
ContainerSqlPersistDatabase = new TestcontainersBuilder<MsSqlTestcontainer>()
.WithDatabase(new MsSqlTestcontainerConfiguration {Database = "sql_test_persist_db", Password = "localpassword#123oooo",})
.WithImage("mcr.microsoft.com/mssql/server:2017-latest")
.WithCleanUp(true)
.Build();
ContainerMongoDatabase = new TestcontainersBuilder<MongoDbTestcontainer>()
.WithDatabase(new MongoDbTestcontainerConfiguration() {Database = "mongo_test_db", Username = "mongo_db", Password = "mongo_db_pass"})
.WithImage("mongo")
.WithCleanUp(true)
.Build();
_factory = new WebApplicationFactory<TEntryPoint>()
.WithWebHostBuilder(builder =>
{
builder.UseEnvironment("test");
builder.ConfigureServices(services =>
{
TestRegistrationServices?.Invoke(services);
services.ReplaceSingleton(AddHttpContextAccessorMock);
services.AddMassTransitTestHarness(x =>
{
x.UsingRabbitMq((context, cfg) =>
{
var rabbitMqOptions = services.GetOptions<RabbitMqOptions>("RabbitMq");
var host = rabbitMqOptions.HostName;
cfg.Host(host, h =>
{
h.Username(rabbitMqOptions.UserName);
h.Password(rabbitMqOptions.Password);
});
cfg.ConfigureEndpoints(context);
});
});
});
});
}
public async Task InitializeAsync()
{
await ContainerSqlDatabase.StartAsync();
await ContainerSqlPersistDatabase.StartAsync();
await ContainerMongoDatabase.StartAsync();
MongoConnectionString = ContainerMongoDatabase?.ConnectionString;
SqlConnectionString = ContainerSqlDatabase?.ConnectionString;
SqlPersistConnectionString = ContainerSqlPersistDatabase?.ConnectionString;
}
public async Task DisposeAsync()
{
await ContainerSqlDatabase.StopAsync();
await ContainerSqlPersistDatabase.StopAsync();
await ContainerMongoDatabase.StopAsync();
await _factory.DisposeAsync();
}
public virtual void RegisterServices(Action<IServiceCollection> services)
{
TestRegistrationServices = services;
}
// ref: https://github.com/trbenning/serilog-sinks-xunit
public ILogger CreateLogger(ITestOutputHelper output)
{
if (output != null)
{
return new LoggerConfiguration()
.WriteTo.TestOutput(output)
.CreateLogger();
}
return null;
}
public async Task ExecuteScopeAsync(Func<IServiceProvider, Task> action)
{
using var scope = ServiceProvider.CreateScope();
await action(scope.ServiceProvider);
}
public async Task<T> ExecuteScopeAsync<T>(Func<IServiceProvider, Task<T>> action)
{
using var scope = ServiceProvider.CreateScope();
var result = await action(scope.ServiceProvider);
return result;
}
public Task<TResponse> SendAsync<TResponse>(IRequest<TResponse> request)
{
return ExecuteScopeAsync(sp =>
{
var mediator = sp.GetRequiredService<IMediator>();
return mediator.Send(request);
});
}
public Task SendAsync(IRequest request)
{
return ExecuteScopeAsync(sp =>
{
var mediator = sp.GetRequiredService<IMediator>();
return mediator.Send(request);
});
}
// Ref: https://tech.energyhelpline.com/in-memory-testing-with-masstransit/
public async ValueTask WaitUntilConditionMet(Func<Task<bool>> conditionToMet, int? timeoutSecond = null)
{
var time = timeoutSecond ?? Timeout;
var startTime = DateTime.Now;
var timeoutExpired = false;
var meet = await conditionToMet.Invoke();
while (!meet)
{
if (timeoutExpired) throw new TimeoutException("Condition not met for the test.");
await Task.Delay(100);
meet = await conditionToMet.Invoke();
timeoutExpired = DateTime.Now - startTime > TimeSpan.FromSeconds(time);
}
}
public async ValueTask ShouldProcessedPersistInternalCommand<TInternalCommand>()
where TInternalCommand : class, IInternalCommand
{
await WaitUntilConditionMet(async () =>
{
return await ExecuteScopeAsync(async sp =>
{
var persistMessageProcessor = sp.GetService<IPersistMessageProcessor>();
Guard.Against.Null(persistMessageProcessor, nameof(persistMessageProcessor));
var filter = await persistMessageProcessor.GetByFilterAsync(x =>
x.DeliveryType == MessageDeliveryType.Internal &&
typeof(TInternalCommand).ToString() == x.DataType);
var res = filter.Any(x => x.MessageStatus == MessageStatus.Processed);
return res;
});
});
}
private ITestHarness CreateHarness()
{
var harness = ServiceProvider.GetTestHarness();
return harness;
}
private GrpcChannel CreateChannel()
{
return GrpcChannel.ForAddress(HttpClient.BaseAddress!, new GrpcChannelOptions {HttpClient = HttpClient});
}
private IHttpContextAccessor AddHttpContextAccessorMock(IServiceProvider serviceProvider)
{
var httpContextAccessorMock = Substitute.For<IHttpContextAccessor>();
using var scope = serviceProvider.CreateScope();
httpContextAccessorMock.HttpContext = new DefaultHttpContext {RequestServices = scope.ServiceProvider};
httpContextAccessorMock.HttpContext.Request.Host = new HostString("localhost", 6012);
httpContextAccessorMock.HttpContext.Request.Scheme = "http";
return httpContextAccessorMock;
}
}
public class IntegrationTestFactory<TEntryPoint, TWContext> : IntegrationTestFactory<TEntryPoint>
where TEntryPoint : class
where TWContext : DbContext
{
public Task ExecuteDbContextAsync(Func<TWContext, Task> action)
{
return ExecuteScopeAsync(sp => action(sp.GetService<TWContext>()));
}
public Task ExecuteDbContextAsync(Func<TWContext, ValueTask> action)
{
return ExecuteScopeAsync(sp => action(sp.GetService<TWContext>()).AsTask());
}
public Task ExecuteDbContextAsync(Func<TWContext, IMediator, Task> action)
{
return ExecuteScopeAsync(sp => action(sp.GetService<TWContext>(), sp.GetService<IMediator>()));
}
public Task<T> ExecuteDbContextAsync<T>(Func<TWContext, Task<T>> action)
{
return ExecuteScopeAsync(sp => action(sp.GetService<TWContext>()));
}
public Task<T> ExecuteDbContextAsync<T>(Func<TWContext, ValueTask<T>> action)
{
return ExecuteScopeAsync(sp => action(sp.GetService<TWContext>()).AsTask());
}
public Task<T> ExecuteDbContextAsync<T>(Func<TWContext, IMediator, Task<T>> action)
{
return ExecuteScopeAsync(sp => action(sp.GetService<TWContext>(), sp.GetService<IMediator>()));
}
public Task InsertAsync<T>(params T[] entities) where T : class
{
return ExecuteDbContextAsync(db =>
{
foreach (var entity in entities) db.Set<T>().Add(entity);
return db.SaveChangesAsync();
});
}
public async Task InsertAsync<TEntity>(TEntity entity) where TEntity : class
{
await ExecuteDbContextAsync(db =>
{
db.Set<TEntity>().Add(entity);
return db.SaveChangesAsync();
});
}
public Task InsertAsync<TEntity, TEntity2>(TEntity entity, TEntity2 entity2)
where TEntity : class
where TEntity2 : class
{
return ExecuteDbContextAsync(db =>
{
db.Set<TEntity>().Add(entity);
db.Set<TEntity2>().Add(entity2);
return db.SaveChangesAsync();
});
}
public Task InsertAsync<TEntity, TEntity2, TEntity3>(TEntity entity, TEntity2 entity2, TEntity3 entity3)
where TEntity : class
where TEntity2 : class
where TEntity3 : class
{
return ExecuteDbContextAsync(db =>
{
db.Set<TEntity>().Add(entity);
db.Set<TEntity2>().Add(entity2);
db.Set<TEntity3>().Add(entity3);
return db.SaveChangesAsync();
});
}
public Task InsertAsync<TEntity, TEntity2, TEntity3, TEntity4>(TEntity entity, TEntity2 entity2, TEntity3 entity3,
TEntity4 entity4)
where TEntity : class
where TEntity2 : class
where TEntity3 : class
where TEntity4 : class
{
return ExecuteDbContextAsync(db =>
{
db.Set<TEntity>().Add(entity);
db.Set<TEntity2>().Add(entity2);
db.Set<TEntity3>().Add(entity3);
db.Set<TEntity4>().Add(entity4);
return db.SaveChangesAsync();
});
}
public Task<T> FindAsync<T>(long id)
where T : class, IAudit
{
return ExecuteDbContextAsync(db => db.Set<T>().FindAsync(id).AsTask());
}
}
public class
IntegrationTestFactory<TEntryPoint, TWContext, TRContext, PContext> : IntegrationTestFactory<TEntryPoint, TWContext,
TRContext>
where TEntryPoint : class
where TWContext : DbContext
where TRContext : MongoDbContext
where PContext : PersistMessageDbContext
{
}
public class IntegrationTestFactory<TEntryPoint, TWContext, TRContext> : IntegrationTestFactory<
TEntryPoint,
TWContext>
where TEntryPoint : class
where TWContext : DbContext
where TRContext : MongoDbContext
{
public Task ExecuteReadContextAsync(Func<TRContext, Task> action)
{
return ExecuteScopeAsync(sp => action(sp.GetRequiredService<TRContext>()));
}
public Task<T> ExecuteReadContextAsync<T>(Func<TRContext, Task<T>> action)
{
return ExecuteScopeAsync(sp => action(sp.GetRequiredService<TRContext>()));
}
}
public class IntegrationTestFixtureCore<TEntryPoint> : IAsyncLifetime
where TEntryPoint : class
{
private string MongoConnectionString
{
get => Fixture.ServiceProvider.GetRequiredService<IOptions<MongoOptions>>()?.Value?.ConnectionString;
set => Fixture.ServiceProvider.GetRequiredService<IOptions<MongoOptions>>().Value.ConnectionString = value;
}
private string PersistConnectionString
{
get => Fixture.ServiceProvider.GetRequiredService<IOptions<PersistMessageOptions>>()?.Value.ConnectionString;
set => Fixture.ServiceProvider.GetRequiredService<IOptions<PersistMessageOptions>>().Value.ConnectionString = value;
}
private string DefaultConnectionString
{
get => Fixture.ServiceProvider.GetRequiredService<IOptions<ConnectionStrings>>()?.Value.DefaultConnection;
set => Fixture.ServiceProvider.GetRequiredService<IOptions<ConnectionStrings>>().Value.DefaultConnection = value;
}
public IntegrationTestFixtureCore(IntegrationTestFactory<TEntryPoint> integrationTestFixture)
{
Fixture = integrationTestFixture;
integrationTestFixture.RegisterServices(services => RegisterTestsServices(services));
}
public IntegrationTestFactory<TEntryPoint> Fixture { get; }
public async Task InitializeAsync()
{
MongoConnectionString = Fixture.MongoConnectionString;
DefaultConnectionString = Fixture.SqlConnectionString;
PersistConnectionString = Fixture.SqlPersistConnectionString;
await SeedDataAsync();
}
public async Task DisposeAsync()
{
await Task.CompletedTask;
}
protected virtual void RegisterTestsServices(IServiceCollection services)
{
}
private async Task SeedDataAsync()
{
using var scope = Fixture.ServiceProvider.CreateScope();
var seeders = scope.ServiceProvider.GetServices<IDataSeeder>();
foreach (var seeder in seeders) await seeder.SeedAllAsync();
}
}
public abstract class IntegrationTestBase<TEntryPoint> : IntegrationTestFixtureCore<TEntryPoint>,
IClassFixture<IntegrationTestFactory<TEntryPoint>>
where TEntryPoint : class
{
protected IntegrationTestBase(
IntegrationTestFactory<TEntryPoint> integrationTestFixture) : base(integrationTestFixture)
{
Fixture = integrationTestFixture;
}
public new IntegrationTestFactory<TEntryPoint> Fixture { get; }
}
public abstract class IntegrationTestBase<TEntryPoint, TWContext> : IntegrationTestFixtureCore<TEntryPoint>,
IClassFixture<IntegrationTestFactory<TEntryPoint, TWContext>>
where TEntryPoint : class
where TWContext : DbContext
{
protected IntegrationTestBase(
IntegrationTestFactory<TEntryPoint, TWContext> integrationTestFixture) : base(integrationTestFixture)
{
Fixture = integrationTestFixture;
}
public new IntegrationTestFactory<TEntryPoint, TWContext> Fixture { get; }
}
public abstract class IntegrationTestBase<TEntryPoint, TWContext, TRContext> : IntegrationTestFixtureCore<TEntryPoint>,
IClassFixture<IntegrationTestFactory<TEntryPoint, TWContext, TRContext>>
where TEntryPoint : class
where TWContext : DbContext
where TRContext : MongoDbContext
{
protected IntegrationTestBase(
IntegrationTestFactory<TEntryPoint, TWContext, TRContext> integrationTestFixture) : base(integrationTestFixture)
{
Fixture = integrationTestFixture;
}
public new IntegrationTestFactory<TEntryPoint, TWContext, TRContext> Fixture { get; }
}
public abstract class IntegrationTestBase<TEntryPoint, TWContext, TRContext, PContext> :
IntegrationTestFixtureCore<TEntryPoint>,
IClassFixture<IntegrationTestFactory<TEntryPoint, TWContext, TRContext, PContext>>
where TEntryPoint : class
where TWContext : DbContext
where TRContext : MongoDbContext
where PContext : PersistMessageDbContext
{
protected IntegrationTestBase(
IntegrationTestFactory<TEntryPoint, TWContext, TRContext, PContext> integrationTestFixture) : base(
integrationTestFixture)
{
Fixture = integrationTestFixture;
}
public new IntegrationTestFactory<TEntryPoint, TWContext, TRContext, PContext> Fixture { get; }
}

33
src/BuildingBlocks/TestBase/TestContainers.cs Normal file
View File

@ -0,0 +1,33 @@
using DotNet.Testcontainers.Builders;
using DotNet.Testcontainers.Configurations;
using DotNet.Testcontainers.Containers;
namespace BuildingBlocks.TestBase;
public static class TestContainers
{
public static MsSqlTestcontainer SqlTestContainer => new TestcontainersBuilder<MsSqlTestcontainer>()
.WithDatabase(
new MsSqlTestcontainerConfiguration {Database = "sql_test_db", Password = "localpassword#123uuuuu"})
.WithImage("mcr.microsoft.com/mssql/server:2017-latest")
.WithCleanUp(true)
.Build();
public static MsSqlTestcontainer SqlPersistTestContainer => new TestcontainersBuilder<MsSqlTestcontainer>()
.WithDatabase(new MsSqlTestcontainerConfiguration
{
Database = "sql_test_persist_db", Password = "localpassword#123oooo"
})
.WithImage("mcr.microsoft.com/mssql/server:2017-latest")
.WithCleanUp(true)
.Build();
public static MongoDbTestcontainer MongoTestContainer => new TestcontainersBuilder<MongoDbTestcontainer>()
.WithDatabase(new MongoDbTestcontainerConfiguration()
{
Database = "mongo_test_db", Username = "mongo_db", Password = "mongo_db_pass"
})
.WithImage("mongo")
.WithCleanUp(true)
.Build();
}

2
src/Services/Booking/tests/IntegrationTest/Booking/Features/CreateBookingTests.cs
View File

@ -27,7 +27,7 @@ public class CreateBookingTests : IntegrationTestBase<Program, PersistMessageDbC
private readonly ITestHarness _testHarness;
public CreateBookingTests(
IntegrationTestFixture<Program, PersistMessageDbContext, BookingReadDbContext> integrationTestFixture) : base(
IntegrationTestFactory<Program, PersistMessageDbContext, BookingReadDbContext> integrationTestFixture) : base(
integrationTestFixture)
{
_testHarness = Fixture.TestHarness;

2
src/Services/Flight/src/Flight/Extensions/Infrastructure/ProblemDetailsExtensions.cs
View File

@ -5,7 +5,7 @@ using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace Flight.Extensions;
namespace Flight.Extensions.Infrastructure;
public static class ProblemDetailsExtensions
{

4
src/Services/Flight/src/Flight/Flights/Features/GetAvailableFlights/Endpoints/V1/GetAvailableFlightsEndpoint.cs
View File

@ -10,6 +10,8 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
using Swashbuckle.AspNetCore.Annotations;
namespace Flight.Flights.Features.GetAvailableFlights.Endpoints.V1;
public class GetAvailableFlightsEndpoint : IMinimalEndpoint
{
public IEndpointRouteBuilder MapEndpoint(IEndpointRouteBuilder endpoints)
@ -34,4 +36,4 @@ public class GetAvailableFlightsEndpoint : IMinimalEndpoint
return Results.Ok(result);
}
}
}

5
src/Services/Flight/src/Flight/Flights/Features/GetFlightById/Endpoints/V1/GetFlightByIdEndpoint.cs
View File

@ -24,7 +24,6 @@
// }
// }
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using BuildingBlocks.Web;
@ -36,6 +35,8 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
using Swashbuckle.AspNetCore.Annotations;
namespace Flight.Flights.Features.GetFlightById.Endpoints.V1;
public class GetFlightByIdEndpoint : IMinimalEndpoint
{
public IEndpointRouteBuilder MapEndpoint(IEndpointRouteBuilder endpoints)
@ -60,4 +61,4 @@ public class GetFlightByIdEndpoint : IMinimalEndpoint
return Results.Ok(result);
}
}
}

4
src/Services/Flight/src/Flight/Flights/Features/UpdateFlight/Endpoints/V1/UpdateFlightEndpoint.cs
View File

@ -9,6 +9,8 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
using Swashbuckle.AspNetCore.Annotations;
namespace Flight.Flights.Features.UpdateFlight.Endpoints.V1;
public class UpdateFlightEndpoint : IMinimalEndpoint
{
public IEndpointRouteBuilder MapEndpoint(IEndpointRouteBuilder endpoints)
@ -33,4 +35,4 @@ public class UpdateFlightEndpoint : IMinimalEndpoint
return Results.Ok(result);
}
}
}

4
src/Services/Flight/src/Flight/Seats/Features/CreateSeat/Endpoints/V1/CreateSeatEndpoint.cs
View File

@ -35,6 +35,8 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
using Swashbuckle.AspNetCore.Annotations;
namespace Flight.Seats.Features.CreateSeat.Endpoints.V1;
public class CreateSeatEndpoint : IMinimalEndpoint
{
public IEndpointRouteBuilder MapEndpoint(IEndpointRouteBuilder endpoints)
@ -59,4 +61,4 @@ public class CreateSeatEndpoint : IMinimalEndpoint
return Results.Ok(result);
}
}
}

5
src/Services/Flight/src/Flight/Seats/Features/GetAvailableSeats/Endpoints/V1/GetAvailableSeatsEndpoint.cs
View File

@ -2,7 +2,6 @@ using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using BuildingBlocks.Web;
using Flight.Flights.Dtos;
using Flight.Seats.Dtos;
using Flight.Seats.Features.GetAvailableSeats.Queries.V1;
using MediatR;
@ -11,6 +10,8 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
using Swashbuckle.AspNetCore.Annotations;
namespace Flight.Seats.Features.GetAvailableSeats.Endpoints.V1;
public class GetAvailableSeatsEndpoint : IMinimalEndpoint
{
public IEndpointRouteBuilder MapEndpoint(IEndpointRouteBuilder endpoints)
@ -35,4 +36,4 @@ public class GetAvailableSeatsEndpoint : IMinimalEndpoint
return Results.Ok(result);
}
}
}

4
src/Services/Flight/src/Flight/Seats/Features/ReserveSeat/Endpoints/V1/ReserveSeatEndpoint.cs
View File

@ -9,6 +9,8 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
using Swashbuckle.AspNetCore.Annotations;
namespace Flight.Seats.Features.ReserveSeat.Endpoints.V1;
public class ReserveSeatEndpoint : IMinimalEndpoint
{
public IEndpointRouteBuilder MapEndpoint(IEndpointRouteBuilder endpoints)
@ -33,4 +35,4 @@ public class ReserveSeatEndpoint : IMinimalEndpoint
return Results.Ok(result);
}
}
}

2
src/Services/Flight/tests/IntegrationTest/Aircraft/Features/CreateAircraftTests.cs
View File

@ -17,7 +17,7 @@ public class CreateAircraftTests : IntegrationTestBase<Program, FlightDbContext,
{
private readonly ITestHarness _testHarness;
public CreateAircraftTests(IntegrationTestFixture<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(integrationTestFixture)
public CreateAircraftTests(IntegrationTestFactory<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(integrationTestFixture)
{
_testHarness = Fixture.TestHarness;
}

2
src/Services/Flight/tests/IntegrationTest/Airport/Features/CreateAirportTests.cs
View File

@ -17,7 +17,7 @@ public class CreateAirportTests : IntegrationTestBase<Program, FlightDbContext,
private readonly ITestHarness _testHarness;
public CreateAirportTests(
IntegrationTestFixture<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(
IntegrationTestFactory<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(
integrationTestFixture)
{
_testHarness = Fixture.TestHarness;

4
src/Services/Flight/tests/IntegrationTest/Fakes/FakeCreateSeatCommand.cs
View File

@ -1,6 +1,6 @@
using AutoBogus;
using BuildingBlocks.IdsGenerator;
using Flight.Seats.Features.CreateSeat;
using Flight.Seats.Enums;
using Flight.Seats.Features.CreateSeat.Commands.V1;
namespace Integration.Test.Fakes;
@ -11,5 +11,7 @@ public class FakeCreateSeatCommand : AutoFaker<CreateSeatCommand>
{
RuleFor(r => r.Id, _ => SnowFlakIdGenerator.NewId());
RuleFor(r => r.FlightId, _ => flightId);
RuleFor(r => r.Class, _ => SeatClass.Economy);
RuleFor(r => r.Type, _ => SeatType.Middle);
}
}

2
src/Services/Flight/tests/IntegrationTest/Flight/Features/CreateFlightTests.cs
View File

@ -17,7 +17,7 @@ public class CreateFlightTests : IntegrationTestBase<Program, FlightDbContext, F
private readonly ITestHarness _testHarness;
public CreateFlightTests(
IntegrationTestFixture<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(
IntegrationTestFactory<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(
integrationTestFixture)
{
_testHarness = Fixture.TestHarness;

2
src/Services/Flight/tests/IntegrationTest/Flight/Features/DeleteFlightTests.cs
View File

@ -20,7 +20,7 @@ public class DeleteFlightTests : IntegrationTestBase<Program, FlightDbContext, F
private readonly ITestHarness _testHarness;
public DeleteFlightTests(
IntegrationTestFixture<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(
IntegrationTestFactory<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(
integrationTestFixture)
{
_testHarness = Fixture.TestHarness;

2
src/Services/Flight/tests/IntegrationTest/Flight/Features/GetAvailableFlightsTests.cs
View File

@ -15,7 +15,7 @@ namespace Integration.Test.Flight.Features;
public class GetAvailableFlightsTests : IntegrationTestBase<Program, FlightDbContext, FlightReadDbContext>
{
public GetAvailableFlightsTests(
IntegrationTestFixture<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture)
IntegrationTestFactory<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture)
: base(integrationTestFixture)
{
}

2
src/Services/Flight/tests/IntegrationTest/Flight/Features/GetFlightByIdTests.cs
View File

@ -19,7 +19,7 @@ public class GetFlightByIdTests : IntegrationTestBase<Program, FlightDbContext,
private readonly GrpcChannel _channel;
public GetFlightByIdTests(
IntegrationTestFixture<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(
IntegrationTestFactory<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(
integrationTestFixture)
{
_channel = Fixture.Channel;

2
src/Services/Flight/tests/IntegrationTest/Flight/Features/UpdateFlightTests.cs
View File

@ -15,7 +15,7 @@ public class UpdateFlightTests : IntegrationTestBase<Program, FlightDbContext, F
{
private readonly ITestHarness _testHarness;
public UpdateFlightTests(IntegrationTestFixture<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(integrationTestFixture)
public UpdateFlightTests(IntegrationTestFactory<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(integrationTestFixture)
{
_testHarness = Fixture.TestHarness;
}

2
src/Services/Flight/tests/IntegrationTest/Seat/Features/GetAvailableSeatsTests.cs
View File

@ -16,7 +16,7 @@ public class GetAvailableSeatsTests : IntegrationTestBase<Program, FlightDbConte
{
private readonly GrpcChannel _channel;
public GetAvailableSeatsTests(IntegrationTestFixture<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(integrationTestFixture)
public GetAvailableSeatsTests(IntegrationTestFactory<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(integrationTestFixture)
{
_channel = Fixture.Channel;
}

2
src/Services/Flight/tests/IntegrationTest/Seat/Features/ReserveSeatTests.cs
View File

@ -17,7 +17,7 @@ public class ReserveSeatTests : IntegrationTestBase<Program, FlightDbContext, Fl
private readonly GrpcChannel _channel;
public ReserveSeatTests(
IntegrationTestFixture<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(
IntegrationTestFactory<Program, FlightDbContext, FlightReadDbContext> integrationTestFixture) : base(
integrationTestFixture)
{
_channel = Fixture.Channel;

2
src/Services/Identity/tests/IntegrationTest/Identity/Features/RegisterNewUserTests.cs
View File

@ -16,7 +16,7 @@ public class RegisterNewUserTests : IntegrationTestBase<Program, IdentityContext
{
private readonly ITestHarness _testHarness;
public RegisterNewUserTests(IntegrationTestFixture<Program, IdentityContext> integrationTestFixture) : base(integrationTestFixture)
public RegisterNewUserTests(IntegrationTestFactory<Program, IdentityContext> integrationTestFixture) : base(integrationTestFixture)
{
_testHarness = Fixture.TestHarness;
}

2
src/Services/Passenger/src/Passenger/Extensions/Infrastructure/MediatRExtensions.cs
View File

@ -4,7 +4,7 @@ using BuildingBlocks.Validation;
using MediatR;
using Microsoft.Extensions.DependencyInjection;
namespace Passenger.Extensions;
namespace Passenger.Extensions.Infrastructure;
public static class MediatRExtensions
{

2
src/Services/Passenger/src/Passenger/Extensions/Infrastructure/ProblemDetailsExtensions.cs
View File

@ -4,7 +4,7 @@ using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace Passenger.Extensions;
namespace Passenger.Extensions.Infrastructure;
public static class ProblemDetailsExtensions
{

2
src/Services/Passenger/tests/IntegrationTest/Passenger/Features/CompleteRegisterPassengerTests.cs
View File

@ -14,7 +14,7 @@ public class CompleteRegisterPassengerTests : IntegrationTestBase<Program, Passe
{
private readonly ITestHarness _testHarness;
public CompleteRegisterPassengerTests(IntegrationTestFixture<Program, PassengerDbContext> integrationTestFixture) :
public CompleteRegisterPassengerTests(IntegrationTestFactory<Program, PassengerDbContext> integrationTestFixture) :
base(integrationTestFixture)
{
_testHarness = Fixture.TestHarness;

2
src/Services/Passenger/tests/IntegrationTest/Passenger/Features/GetPassengerByIdTests.cs
View File

@ -20,7 +20,7 @@ public class GetPassengerByIdTests : IntegrationTestBase<Program, PassengerDbCon
private readonly ITestHarness _testHarness;
private readonly GrpcChannel _channel;
public GetPassengerByIdTests(IntegrationTestFixture<Program, PassengerDbContext> integrationTestFixture) : base(
public GetPassengerByIdTests(IntegrationTestFactory<Program, PassengerDbContext> integrationTestFixture) : base(
integrationTestFixture)
{
_channel = Fixture.Channel;