From 4edc90b464b100095caee85c6e6c560a361b086f Mon Sep 17 00:00:00 2001 From: "fabien.menager" Date: Sun, 1 Jun 2025 08:42:46 +0200 Subject: [PATCH] Split merge tests and code cleanup --- .../Tests/Basic/BasicTestsBase.cs | 258 +---------------- .../Tests/Merge/MergeTestsBase.cs | 264 ++++++++++++++++++ .../Tests/Merge/MergeTestsMySql.cs | 12 + .../Tests/Merge/MergeTestsPostgreSql.cs | 12 + .../Tests/Merge/MergeTestsSqlServer.cs | 12 + .../Tests/Merge/MergeTestsSqlite.cs | 12 + 6 files changed, 323 insertions(+), 247 deletions(-) create mode 100644 tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsBase.cs create mode 100644 tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsMySql.cs create mode 100644 tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsPostgreSql.cs create mode 100644 tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsSqlServer.cs create mode 100644 tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsSqlite.cs diff --git a/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Basic/BasicTestsBase.cs b/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Basic/BasicTestsBase.cs index 0607f81..86b47ce 100644 --- a/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Basic/BasicTestsBase.cs +++ b/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Basic/BasicTestsBase.cs @@ -3,7 +3,6 @@ using PhenX.EntityFrameworkCore.BulkInsert.Enums; using PhenX.EntityFrameworkCore.BulkInsert.Extensions; using PhenX.EntityFrameworkCore.BulkInsert.MySql; -using PhenX.EntityFrameworkCore.BulkInsert.Options; using PhenX.EntityFrameworkCore.BulkInsert.SqlServer; using PhenX.EntityFrameworkCore.BulkInsert.Tests.DbContainer; using PhenX.EntityFrameworkCore.BulkInsert.Tests.DbContext; @@ -45,7 +44,7 @@ public async Task InsertsEntities(InsertStrategy strategy) // Assert insertedEntities.Should().BeEquivalentTo(entities, - o => o.RespectingRuntimeTypes().Excluding((TestEntity e) => e.Id)); + o => o.RespectingRuntimeTypes().Excluding(e => e.Id)); } [SkippableTheory] @@ -64,7 +63,7 @@ public async Task InsertEntities_WithJson(InsertStrategy strategy) // Assert insertedEntities.Should().BeEquivalentTo(entities, - o => o.RespectingRuntimeTypes().Excluding((TestEntityWithJson e) => e.Id)); + o => o.RespectingRuntimeTypes().Excluding(e => e.Id)); } [SkippableFact] @@ -90,100 +89,7 @@ public async Task InsertEntities_AndReturn_AsyncEnumerable() // Assert insertedEntities.Should().BeEquivalentTo(entities, - o => o.RespectingRuntimeTypes().Excluding((TestEntity e) => e.Id)); - } - - [SkippableTheory] - [CombinatorialData] - public async Task InsertEntities_MultipleTimes(InsertStrategy strategy) - { - Skip.If(_context.IsProvider(ProviderType.PostgreSql)); - Skip.If(_context.IsProvider(ProviderType.SqlServer)); - - // Arrange - var entities = new List - { - new TestEntity { TestRun = _run, Name = $"{_run}_Entity1" }, - new TestEntity { TestRun = _run, Name = $"{_run}_Entity2" } - }; - - // Act - await _context.InsertWithStrategyAsync(strategy, entities); - - foreach (var entity in entities) - { - entity.NumericEnumValue = NumericEnum.Second; - } - - var insertedEntities = await _context.InsertWithStrategyAsync(strategy, entities, - onConflict: new OnConflictOptions - { - Update = e => e, - }); - - // Assert - insertedEntities.Should().BeEquivalentTo(entities, - o => o.RespectingRuntimeTypes().Excluding((TestEntity e) => e.Id)); - } - - [SkippableTheory] - [CombinatorialData] - public async Task InsertEntities_MultipleTimes_WithGuidId(InsertStrategy strategy) - { - // Arrange - var entities = new List - { - new TestEntityWithGuidId { Id = Guid.NewGuid(), Name = $"{_run}_Entity1" }, - new TestEntityWithGuidId { Id = Guid.NewGuid(), Name = $"{_run}_Entity2" } - }; - - // Act - await _context.ExecuteBulkInsertAsync(entities); - - foreach (var entity in entities) - { - entity.Name = $"Updated_{entity.Name}"; - } - - var insertedEntities = await _context.InsertWithStrategyAsync(strategy, entities, - onConflict: new OnConflictOptions - { - Update = e => e, - }); - - // Assert - insertedEntities.Should().BeEquivalentTo(entities, - o => o.RespectingRuntimeTypes().Excluding((TestEntityWithGuidId e) => e.Id)); - } - - [SkippableTheory] - [CombinatorialData] - public async Task InsertEntities_MultipleTimes_With_Conflict_On_Id(InsertStrategy strategy) - { - // Arrange - var entities = new List - { - new TestEntity { Name = $"{_run}_Entity1" }, - new TestEntity { Name = $"{_run}_Entity2" } - }; - - // Act - var insertedEntities0 = await _context.InsertWithStrategyAsync(strategy, entities); - foreach (var entity in insertedEntities0) - { - entity.Name = $"Updated_{entity.Name}"; - } - - var insertedEntities1 = await _context.InsertWithStrategyAsync(strategy, insertedEntities0, - o => o.CopyGeneratedColumns = true, - onConflict: new OnConflictOptions - { - Update = e => e, - }); - - // Assert - insertedEntities1.Should().BeEquivalentTo(insertedEntities0, - o => o.RespectingRuntimeTypes().Excluding((TestEntity e) => e.Id)); + o => o.RespectingRuntimeTypes().Excluding(e => e.Id)); } [SkippableTheory] @@ -205,149 +111,7 @@ public async Task InsertEntities_MoveRows(InsertStrategy strategy) // Assert insertedEntities.Should().BeEquivalentTo(entities, - o => o.RespectingRuntimeTypes().Excluding((TestEntity e) => e.Id)); - } - - [SkippableTheory] - [InlineData(InsertStrategy.InsertReturn)] - [InlineData(InsertStrategy.InsertReturnAsync)] - public async Task InsertEntities_WithConflict_SingleColumn(InsertStrategy strategy) - { - Skip.If(_context.IsProvider(ProviderType.MySql)); - - // Arrange - _context.TestEntities.Add(new TestEntity { Name = $"{_run}_Entity1" }); - _context.SaveChanges(); - _context.ChangeTracker.Clear(); - - var entities = new List - { - new TestEntity { Name = $"{_run}_Entity1" }, - new TestEntity { TestRun = _run, Name = $"{_run}_Entity2" }, - }; - - // Act - var insertedEntities = await _context.InsertWithStrategyAsync(strategy, entities, o => - { - o.MoveRows = true; - }, new OnConflictOptions - { - Match = e => new - { - e.Name, - }, - Update = e => new TestEntity - { - Name = e.Name + " - Conflict", - }, - }); - - // Assert - Assert.Equal(2, insertedEntities.Count); - Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity1 - Conflict"); - Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity2"); - } - - [SkippableTheory] - [InlineData(InsertStrategy.Insert)] - [InlineData(InsertStrategy.InsertAsync)] - public async Task InsertEntities_WithConflict_DoNothing(InsertStrategy strategy) - { - Skip.If(_context.IsProvider(ProviderType.MySql)); - - // Arrange - _context.TestEntities.Add(new TestEntity { TestRun = _run, Name = $"{_run}_Entity1" }); - _context.SaveChanges(); - _context.ChangeTracker.Clear(); - - var entities = new List - { - new TestEntity { TestRun = _run, Name = $"{_run}_Entity1" }, - new TestEntity { TestRun = _run, Name = $"{_run}_Entity2" }, - }; - - // Act - var insertedEntities = await _context.InsertWithStrategyAsync(strategy, entities, o => - { - o.MoveRows = true; - }, new OnConflictOptions - { - Match = e => new { e.Name } - }); - - // Assert - Assert.Equal(2, insertedEntities.Count); - Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity1"); - Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity2"); - } - - [SkippableTheory] - [InlineData(InsertStrategy.InsertReturn)] - [InlineData(InsertStrategy.InsertReturnAsync)] - public async Task InsertEntities_WithConflict_Condition(InsertStrategy strategy) - { - Skip.If(_context.IsProvider(ProviderType.MySql)); - - // Arrange - _context.TestEntities.Add(new TestEntity { TestRun = _run, Name = $"{_run}_Entity1", Price = 10 }); - _context.SaveChanges(); - _context.ChangeTracker.Clear(); - - var entities = new List - { - new TestEntity { TestRun = _run, Name = $"{_run}_Entity1", Price = 20 }, - new TestEntity { TestRun = _run, Name = $"{_run}_Entity2", Price = 30 }, - }; - - // Act - var insertedEntities = await _context.InsertWithStrategyAsync(strategy, entities, o => - { - o.MoveRows = true; - }, new OnConflictOptions - { - Match = e => new { e.Name }, - Update = e => new TestEntity { Price = e.Price }, - Condition = "EXCLUDED.some_price > test_entity.some_price" - }); - - // Assert - Assert.Equal(2, insertedEntities.Count); - Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity1" && e.Price == 20); - Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity2" && e.Price == 30); - } - - [SkippableTheory] - [InlineData(InsertStrategy.InsertReturn)] - [InlineData(InsertStrategy.InsertReturnAsync)] - public async Task InsertEntities_WithConflict_MultipleColumns(InsertStrategy strategy) - { - Skip.If(_context.IsProvider(ProviderType.MySql)); - - // Arrange - _context.TestEntities.Add(new TestEntity { TestRun = _run, Name = $"{_run}_Entity1", Price = 10 }); - _context.SaveChanges(); - _context.ChangeTracker.Clear(); - - var entities = new List - { - new TestEntity { TestRun = _run, Name = $"{_run}_Entity1", Price = 20, Identifier = Guid.NewGuid() }, - new TestEntity { TestRun = _run, Name = $"{_run}_Entity2", Price = 30, Identifier = Guid.NewGuid() }, - }; - - // Act - var insertedEntities = await _context.InsertWithStrategyAsync(strategy, entities, o => - { - o.MoveRows = true; - }, new OnConflictOptions - { - Match = e => new { e.Name }, - Update = e => new TestEntity { Name = e.Name + " - Conflict", Price = 0 } - }); - - // Assert - Assert.Equal(2, insertedEntities.Count); - Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity2"); - Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity1 - Conflict" && e.Price == 0); + o => o.RespectingRuntimeTypes().Excluding(e => e.Id)); } [SkippableTheory] @@ -370,7 +134,7 @@ public async Task InsertEntities_DoesNothing_WhenEntitiesAreEmpty(InsertStrategy public async Task InsertEntities_Many(InsertStrategy strategy) { // Arrange - const int count = 156055; + const int count = 56055; var entities = Enumerable.Range(1, count).Select(i => new TestEntity { @@ -411,7 +175,7 @@ public async Task InsertEntities_AndReturn_WithEntityWithValueConverters(InsertS // Assert insertedEntities.Should().BeEquivalentTo(entities, - o => o.RespectingRuntimeTypes().Excluding((TestEntityWithConverters e) => e.Id)); + o => o.RespectingRuntimeTypes().Excluding(e => e.Id)); } [SkippableTheory] @@ -432,7 +196,7 @@ public async Task InsertEntities_WithOpenTransaction_CommitsSuccessfully(InsertS // Assert insertedEntities.Should().BeEquivalentTo(entities, - o => o.RespectingRuntimeTypes().Excluding((TestEntity e) => e.Id)); + o => o.RespectingRuntimeTypes().Excluding(e => e.Id)); } [SkippableTheory] @@ -456,7 +220,7 @@ public async Task InsertEntities_WithOpenTransaction_RollsBackOnFailure(InsertSt var insertedEntities = _context.TestEntities.Where(x => x.TestRun == _run).ToList(); Assert.Empty(insertedEntities); } - + [SkippableFact] public async Task ThrowsWhenUsingWrongConfigurationType() { @@ -474,7 +238,7 @@ public async Task ThrowsWhenUsingWrongConfigurationType() if (_context.IsProvider(ProviderType.SqlServer)) { await Assert.ThrowsAsync(async () => - await _context.ExecuteBulkInsertAsync(entities, (MySqlBulkInsertOptions o) => + await _context.ExecuteBulkInsertAsync(entities, (MySqlBulkInsertOptions _) => { })); } @@ -482,7 +246,7 @@ await _context.ExecuteBulkInsertAsync(entities, (MySqlBulkInsertOptions o) => if (_context.IsProvider(ProviderType.MySql)) { await Assert.ThrowsAsync(async () => - await _context.ExecuteBulkInsertAsync(entities, (SqlServerBulkInsertOptions o) => + await _context.ExecuteBulkInsertAsync(entities, (SqlServerBulkInsertOptions _) => { })); } @@ -490,7 +254,7 @@ await _context.ExecuteBulkInsertAsync(entities, (SqlServerBulkInsertOptions o) = if (_context.IsProvider(ProviderType.PostgreSql)) { await Assert.ThrowsAsync(async () => - await _context.ExecuteBulkInsertAsync(entities, (SqlServerBulkInsertOptions o) => + await _context.ExecuteBulkInsertAsync(entities, (SqlServerBulkInsertOptions _) => { })); } diff --git a/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsBase.cs b/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsBase.cs new file mode 100644 index 0000000..6433f8e --- /dev/null +++ b/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsBase.cs @@ -0,0 +1,264 @@ +using FluentAssertions; + +using PhenX.EntityFrameworkCore.BulkInsert.Enums; +using PhenX.EntityFrameworkCore.BulkInsert.Extensions; +using PhenX.EntityFrameworkCore.BulkInsert.Options; +using PhenX.EntityFrameworkCore.BulkInsert.Tests.DbContainer; +using PhenX.EntityFrameworkCore.BulkInsert.Tests.DbContext; + +using Xunit; + +namespace PhenX.EntityFrameworkCore.BulkInsert.Tests.Tests.Merge; + +public abstract class MergeTestsBase(TestDbContainer dbContainer) : IAsyncLifetime + where TDbContext : TestDbContext, new() +{ + private readonly Guid _run = Guid.NewGuid(); + private TDbContext _context = null!; + + public async Task InitializeAsync() + { + _context = await dbContainer.CreateContextAsync("basic"); + } + + public Task DisposeAsync() + { + _context.Dispose(); + return Task.CompletedTask; + } + + [SkippableTheory] + [CombinatorialData] + public async Task InsertEntities_MultipleTimes(InsertStrategy strategy) + { + Skip.If(_context.IsProvider(ProviderType.PostgreSql)); + Skip.If(_context.IsProvider(ProviderType.SqlServer)); + + // Arrange + var entities = new List + { + new TestEntity { TestRun = _run, Name = $"{_run}_Entity1" }, + new TestEntity { TestRun = _run, Name = $"{_run}_Entity2" } + }; + + // Act + await _context.InsertWithStrategyAsync(strategy, entities); + + foreach (var entity in entities) + { + entity.NumericEnumValue = NumericEnum.Second; + } + + var insertedEntities = await _context.InsertWithStrategyAsync(strategy, entities, + onConflict: new OnConflictOptions + { + Update = e => e, + }); + + // Assert + insertedEntities.Should().BeEquivalentTo(entities, + o => o.RespectingRuntimeTypes().Excluding(e => e.Id)); + } + + [SkippableTheory] + [CombinatorialData] + public async Task InsertEntities_MultipleTimes_WithGuidId(InsertStrategy strategy) + { + // Arrange + var entities = new List + { + new TestEntityWithGuidId { Id = Guid.NewGuid(), Name = $"{_run}_Entity1" }, + new TestEntityWithGuidId { Id = Guid.NewGuid(), Name = $"{_run}_Entity2" } + }; + + // Act + await _context.ExecuteBulkInsertAsync(entities); + + foreach (var entity in entities) + { + entity.Name = $"Updated_{entity.Name}"; + } + + var insertedEntities = await _context.InsertWithStrategyAsync(strategy, entities, + onConflict: new OnConflictOptions + { + Update = e => e, + }); + + // Assert + insertedEntities.Should().BeEquivalentTo(entities, + o => o.RespectingRuntimeTypes().Excluding(e => e.Id)); + } + + [SkippableTheory] + [CombinatorialData] + public async Task InsertEntities_MultipleTimes_With_Conflict_On_Id(InsertStrategy strategy) + { + // Arrange + var entities = new List + { + new TestEntity { Name = $"{_run}_Entity1" }, + new TestEntity { Name = $"{_run}_Entity2" } + }; + + // Act + var insertedEntities0 = await _context.InsertWithStrategyAsync(strategy, entities); + foreach (var entity in insertedEntities0) + { + entity.Name = $"Updated_{entity.Name}"; + } + + var insertedEntities1 = await _context.InsertWithStrategyAsync(strategy, insertedEntities0, + o => o.CopyGeneratedColumns = true, + onConflict: new OnConflictOptions + { + Update = e => e, + }); + + // Assert + insertedEntities1.Should().BeEquivalentTo(insertedEntities0, + o => o.RespectingRuntimeTypes().Excluding(e => e.Id)); + } + + [SkippableTheory] + [InlineData(InsertStrategy.InsertReturn)] + [InlineData(InsertStrategy.InsertReturnAsync)] + public async Task InsertEntities_WithConflict_SingleColumn(InsertStrategy strategy) + { + Skip.If(_context.IsProvider(ProviderType.MySql)); + + // Arrange + _context.TestEntities.Add(new TestEntity { Name = $"{_run}_Entity1" }); + _context.SaveChanges(); + _context.ChangeTracker.Clear(); + + var entities = new List + { + new TestEntity { Name = $"{_run}_Entity1" }, + new TestEntity { TestRun = _run, Name = $"{_run}_Entity2" }, + }; + + // Act + var insertedEntities = await _context.InsertWithStrategyAsync(strategy, entities, o => + { + o.MoveRows = true; + }, new OnConflictOptions + { + Match = e => new + { + e.Name, + }, + Update = e => new TestEntity + { + Name = e.Name + " - Conflict", + }, + }); + + // Assert + Assert.Equal(2, insertedEntities.Count); + Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity1 - Conflict"); + Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity2"); + } + + [SkippableTheory] + [InlineData(InsertStrategy.Insert)] + [InlineData(InsertStrategy.InsertAsync)] + public async Task InsertEntities_WithConflict_DoNothing(InsertStrategy strategy) + { + Skip.If(_context.IsProvider(ProviderType.MySql)); + + // Arrange + _context.TestEntities.Add(new TestEntity { TestRun = _run, Name = $"{_run}_Entity1" }); + _context.SaveChanges(); + _context.ChangeTracker.Clear(); + + var entities = new List + { + new TestEntity { TestRun = _run, Name = $"{_run}_Entity1" }, + new TestEntity { TestRun = _run, Name = $"{_run}_Entity2" }, + }; + + // Act + var insertedEntities = await _context.InsertWithStrategyAsync(strategy, entities, o => + { + o.MoveRows = true; + }, new OnConflictOptions + { + Match = e => new { e.Name } + }); + + // Assert + Assert.Equal(2, insertedEntities.Count); + Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity1"); + Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity2"); + } + + [SkippableTheory] + [InlineData(InsertStrategy.InsertReturn)] + [InlineData(InsertStrategy.InsertReturnAsync)] + public async Task InsertEntities_WithConflict_Condition(InsertStrategy strategy) + { + Skip.If(_context.IsProvider(ProviderType.MySql)); + + // Arrange + _context.TestEntities.Add(new TestEntity { TestRun = _run, Name = $"{_run}_Entity1", Price = 10 }); + _context.SaveChanges(); + _context.ChangeTracker.Clear(); + + var entities = new List + { + new TestEntity { TestRun = _run, Name = $"{_run}_Entity1", Price = 20 }, + new TestEntity { TestRun = _run, Name = $"{_run}_Entity2", Price = 30 }, + }; + + // Act + var insertedEntities = await _context.InsertWithStrategyAsync(strategy, entities, o => + { + o.MoveRows = true; + }, new OnConflictOptions + { + Match = e => new { e.Name }, + Update = e => new TestEntity { Price = e.Price }, + Condition = "EXCLUDED.some_price > test_entity.some_price" + }); + + // Assert + Assert.Equal(2, insertedEntities.Count); + Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity1" && e.Price == 20); + Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity2" && e.Price == 30); + } + + [SkippableTheory] + [InlineData(InsertStrategy.InsertReturn)] + [InlineData(InsertStrategy.InsertReturnAsync)] + public async Task InsertEntities_WithConflict_MultipleColumns(InsertStrategy strategy) + { + Skip.If(_context.IsProvider(ProviderType.MySql)); + + // Arrange + _context.TestEntities.Add(new TestEntity { TestRun = _run, Name = $"{_run}_Entity1", Price = 10 }); + _context.SaveChanges(); + _context.ChangeTracker.Clear(); + + var entities = new List + { + new TestEntity { TestRun = _run, Name = $"{_run}_Entity1", Price = 20, Identifier = Guid.NewGuid() }, + new TestEntity { TestRun = _run, Name = $"{_run}_Entity2", Price = 30, Identifier = Guid.NewGuid() }, + }; + + // Act + var insertedEntities = await _context.InsertWithStrategyAsync(strategy, entities, o => + { + o.MoveRows = true; + }, new OnConflictOptions + { + Match = e => new { e.Name }, + Update = e => new TestEntity { Name = e.Name + " - Conflict", Price = 0 } + }); + + // Assert + Assert.Equal(2, insertedEntities.Count); + Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity2"); + Assert.Contains(insertedEntities, e => e.Name == $"{_run}_Entity1 - Conflict" && e.Price == 0); + } +} diff --git a/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsMySql.cs b/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsMySql.cs new file mode 100644 index 0000000..2f80947 --- /dev/null +++ b/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsMySql.cs @@ -0,0 +1,12 @@ +using PhenX.EntityFrameworkCore.BulkInsert.Tests.DbContainer; +using PhenX.EntityFrameworkCore.BulkInsert.Tests.DbContext; + +using Xunit; + +namespace PhenX.EntityFrameworkCore.BulkInsert.Tests.Tests.Merge; + +[Trait("Category", "MySql")] +[Collection(TestDbContainerMySqlCollection.Name)] +public class MergeTestsMySql(TestDbContainerMySql dbContainer) : MergeTestsBase(dbContainer) +{ +} diff --git a/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsPostgreSql.cs b/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsPostgreSql.cs new file mode 100644 index 0000000..92fa909 --- /dev/null +++ b/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsPostgreSql.cs @@ -0,0 +1,12 @@ +using PhenX.EntityFrameworkCore.BulkInsert.Tests.DbContainer; +using PhenX.EntityFrameworkCore.BulkInsert.Tests.DbContext; + +using Xunit; + +namespace PhenX.EntityFrameworkCore.BulkInsert.Tests.Tests.Merge; + +[Trait("Category", "PostgreSql")] +[Collection(TestDbContainerPostgreSqlCollection.Name)] +public class MergeTestsPostgreSql(TestDbContainerPostgreSql dbContainer) : MergeTestsBase(dbContainer) +{ +} diff --git a/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsSqlServer.cs b/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsSqlServer.cs new file mode 100644 index 0000000..512d2ef --- /dev/null +++ b/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsSqlServer.cs @@ -0,0 +1,12 @@ +using PhenX.EntityFrameworkCore.BulkInsert.Tests.DbContainer; +using PhenX.EntityFrameworkCore.BulkInsert.Tests.DbContext; + +using Xunit; + +namespace PhenX.EntityFrameworkCore.BulkInsert.Tests.Tests.Merge; + +[Trait("Category", "SqlServer")] +[Collection(TestDbContainerSqlServerCollection.Name)] +public class MergeTestsSqlServer(TestDbContainerSqlServer dbContainer) : MergeTestsBase(dbContainer) +{ +} diff --git a/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsSqlite.cs b/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsSqlite.cs new file mode 100644 index 0000000..4c66b64 --- /dev/null +++ b/tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsSqlite.cs @@ -0,0 +1,12 @@ +using PhenX.EntityFrameworkCore.BulkInsert.Tests.DbContainer; +using PhenX.EntityFrameworkCore.BulkInsert.Tests.DbContext; + +using Xunit; + +namespace PhenX.EntityFrameworkCore.BulkInsert.Tests.Tests.Merge; + +[Trait("Category", "Sqlite")] +[Collection(TestDbContainerSqliteCollection.Name)] +public class MergeTestsSqlite(TestDbContainerSqlite dbContainer) : MergeTestsBase(dbContainer) +{ +}