Functional expressions

.github/workflows/dotnetpull.yml

@@ -5,11 +5,9 @@ on:
     branches: [master]
   pull_request:
     branches: [master]
-
 jobs:
   build:
     runs-on: ubuntu-latest
-
     services:
       sqlserver:
         image: mcr.microsoft.com/mssql/server:2019-latest
@@ -23,21 +21,20 @@ jobs:
           --health-interval=10s
           --health-timeout=5s
           --health-retries=10
-
       postgres:
         image: postgres:13
         ports:
           - 5432:5432
         env:
           POSTGRES_USER: testuser
           POSTGRES_PASSWORD: testpass
-          POSTGRES_DB: testdb
+          # As of v16 we can use:
+          # POSTGRES_INITDB_ARGS: "-c max_connections=300"
         options: >-
           --health-cmd="pg_isready -U testuser"
           --health-interval=10s
           --health-timeout=5s
           --health-retries=5
-
       oracle:
         image: gvenzl/oracle-free:latest
         ports:
@@ -49,7 +46,6 @@ jobs:
           --health-interval 10s
           --health-timeout 5s
           --health-retries 10
-
       mysql:
         image: mysql:8.0
         ports:
@@ -64,7 +60,6 @@ jobs:
           --health-interval=10s
           --health-timeout=5s
           --health-retries=10
-
     steps:
       - uses: actions/checkout@v4
       - uses: gvenzl/setup-oracle-sqlcl@v1

src/Migrator.Tests/Database/DerivedDatabaseIntegrationTestServices/PostgreSqlDatabaseIntegrationTestService.cs

@@ -54,9 +54,8 @@ public override async Task<DatabaseInfo> CreateTestDatabaseAsync(DatabaseConnect
             await context.ExecuteAsync($"CREATE DATABASE \"{newDatabaseName}\"", cancellationToken);
         }
 
-        var connectionStringBuilder2 = new NpgsqlConnectionStringBuilder
+        var connectionStringBuilder2 = new NpgsqlConnectionStringBuilder(clonedDatabaseConnectionConfig.ConnectionString)
         {
-            ConnectionString = clonedDatabaseConnectionConfig.ConnectionString,
             Database = newDatabaseName
         };
 

src/Migrator.Tests/Dialects/PostgreSQLDialectTests.cs

@@ -0,0 +1,45 @@
+using DotNetProjects.Migrator.Providers.Impl.PostgreSQL;
+using DotNetProjects.Migrator.Providers.Models.Indexes.Enums;
+using NUnit.Framework;
+
+namespace Migrator.Tests.Dialects;
+
+[TestFixture]
+[Category("Postgre")]
+public class PostgreDialectTests
+{
+    private PostgreSQLDialect _postgreSQLDialect;
+
+    [SetUp]
+    public void SetUp()
+    {
+        // Since Dialect is abstract we use PostgreSQLDialect
+        _postgreSQLDialect = new PostgreSQLDialect();
+    }
+
+    [TestCase(FilterType.EqualTo, "=")]
+    [TestCase(FilterType.GreaterThanOrEqualTo, ">=")]
+    [TestCase(FilterType.SmallerThanOrEqualTo, "<=")]
+    [TestCase(FilterType.SmallerThan, "<")]
+    [TestCase(FilterType.GreaterThan, ">")]
+    [TestCase(FilterType.NotEqualTo, "<>")]
+    public void GetComparisonStringByFilterType_Success(FilterType filterType, string expectedString)
+    {
+        var result = _postgreSQLDialect.GetComparisonStringByFilterType(filterType);
+
+        Assert.That(result, Is.EqualTo(expectedString));
+    }
+
+    [TestCase("=", FilterType.EqualTo)]
+    [TestCase(">=", FilterType.GreaterThanOrEqualTo)]
+    [TestCase("<=", FilterType.SmallerThanOrEqualTo)]
+    [TestCase("<", FilterType.SmallerThan)]
+    [TestCase(">", FilterType.GreaterThan)]
+    [TestCase("<>", FilterType.NotEqualTo)]
+    public void GetFilterTypeByComparisonString_Success(string comparisonString, FilterType expectedFilterType)
+    {
+        var result = _postgreSQLDialect.GetFilterTypeByComparisonString(comparisonString);
+
+        Assert.That(result, Is.EqualTo(expectedFilterType));
+    }
+}

src/Migrator.Tests/Providers/Base/TransformationProviderBase.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Data;
 using System.Threading;
 using System.Threading.Tasks;
 using DotNetProjects.Migrator.Framework;
@@ -13,6 +14,7 @@
 using Migrator.Tests.Settings;
 using Migrator.Tests.Settings.Config;
 using Migrator.Tests.Settings.Models;
+using Npgsql;
 using NUnit.Framework;
 
 namespace Migrator.Tests.Providers.Base;
@@ -22,12 +24,24 @@ namespace Migrator.Tests.Providers.Base;
 /// </summary>
 public abstract class TransformationProviderBase
 {
+    private IDbConnection _dbConnection;
+
     [TearDown]
     public virtual void TearDown()
     {
         DropTestTables();
 
         Provider?.Rollback();
+
+        if (_dbConnection != null)
+        {
+            if (_dbConnection.State == ConnectionState.Open)
+            {
+                _dbConnection.Close();
+            }
+
+            _dbConnection.Dispose();
+        }
     }
 
     protected void DropTestTables()
@@ -108,7 +122,10 @@ protected async Task BeginPostgreSQLTransactionAsync()
         var postgreIntegrationTestService = databaseIntegrationTestServiceFactory.Create(DatabaseProviderType.Postgres);
         var databaseInfo = await postgreIntegrationTestService.CreateTestDatabaseAsync(databaseConnectionConfig, cts.Token);
 
-        Provider = new PostgreSQLTransformationProvider(new PostgreSQLDialect(), databaseInfo.DatabaseConnectionConfig.ConnectionString, null, "default", "Npgsql");
+
+        _dbConnection = new NpgsqlConnection(databaseInfo.DatabaseConnectionConfig.ConnectionString);
+
+        Provider = new PostgreSQLTransformationProvider(new PostgreSQLDialect(), _dbConnection, null, "default", "Npgsql");
         Provider.BeginTransaction();
 
         await Task.CompletedTask;

src/Migrator.Tests/Providers/Generic/Generic_AddIndexTestsBase.cs

@@ -0,0 +1,126 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Globalization;
+using System.Linq;
+using DotNetProjects.Migrator.Framework;
+using DotNetProjects.Migrator.Providers.Models.Indexes;
+using DotNetProjects.Migrator.Providers.Models.Indexes.Enums;
+using Migrator.Tests.Providers.Base;
+using NUnit.Framework;
+using Index = DotNetProjects.Migrator.Framework.Index;
+
+namespace Migrator.Tests.Providers.Generic;
+
+public abstract class Generic_AddIndexTestsBase : TransformationProviderBase
+{
+    [Test]
+    public void AddIndex_TableDoesNotExist()
+    {
+        // Act
+        Assert.Throws<MigrationException>(() => Provider.AddIndex("NotExistingTable", new Index()));
+        Assert.Throws<MigrationException>(() => Provider.AddIndex("NotExistingIndex", "NotExistingTable", "column"));
+    }
+
+    [Test]
+    public void AddIndex_AddAlreadyExistingIndex_Throws()
+    {
+        // Arrange
+        const string tableName = "TestTable";
+        const string columnName = "TestColumn";
+        const string indexName = "TestIndexName";
+
+        Provider.AddTable(tableName, new Column(columnName, DbType.Int32));
+        Provider.AddIndex(tableName, new Index { Name = indexName, KeyColumns = [columnName] });
+
+        // Act/Assert
+        // Add already existing index
+        Assert.Throws<MigrationException>(() => Provider.AddIndex(tableName, new Index { Name = indexName, KeyColumns = [columnName] }));
+    }
+
+    [Test]
+    public void AddIndex_IncludeColumnsContainsColumnThatExistInKeyColumns_Throws()
+    {
+        // Arrange
+        const string tableName = "TestTable";
+        const string columnName1 = "TestColumn1";
+        const string indexName = "TestIndexName";
+
+        Provider.AddTable(tableName, new Column(columnName1, DbType.Int32));
+
+        Assert.Throws<MigrationException>(() => Provider.AddIndex(tableName,
+            new Index
+            {
+                Name = indexName,
+                KeyColumns = [columnName1],
+                IncludeColumns = [columnName1]
+            }));
+    }
+
+    [Test]
+    public void AddIndex_ColumnNameUsedInFilterItemDoesNotExistInKeyColumns_Throws()
+    {
+        // Arrange
+        const string tableName = "TestTable";
+        const string columnName1 = "TestColumn1";
+        const string columnName2 = "TestColumn2";
+        const string indexName = "TestIndexName";
+
+        Provider.AddTable(tableName,
+            new Column(columnName1, DbType.Int32),
+            new Column(columnName2, DbType.Int32)
+        );
+
+        Assert.Throws<MigrationException>(() => Provider.AddIndex(tableName,
+            new Index
+            {
+                Name = indexName,
+                KeyColumns = [columnName1],
+                FilterItems = [new FilterItem { Filter = FilterType.GreaterThan, ColumnName = columnName2, Value = 12 }]
+            }));
+    }
+
+    [Test]
+    public void AddIndex_UsingIndexInstanceOverload_NonUnique_ShouldBeReadable()
+    {
+        // Arrange
+        const string tableName = "TestTable";
+        const string columnName = "TestColumn";
+        const string indexName = "TestIndexName";
+
+        Provider.AddTable(tableName, new Column(columnName, DbType.Int32));
+
+        // Act
+        Provider.AddIndex(tableName, new Index { Name = indexName, KeyColumns = [columnName] });
+
+        // Assert
+        var indexes = Provider.GetIndexes(tableName);
+
+        var index = indexes.Single();
+
+        Assert.That(index.Name, Is.EqualTo(indexName).IgnoreCase);
+        Assert.That(index.KeyColumns.Single(), Is.EqualTo(columnName).IgnoreCase);
+    }
+
+    [Test]
+    public void AddIndex_UsingNonIndexInstanceOverload_NonUnique_ShouldBeReadable()
+    {
+        // Arrange
+        const string tableName = "TestTable";
+        const string columnName = "TestColumn";
+        const string indexName = "TestIndexName";
+
+        Provider.AddTable(tableName, new Column(columnName, DbType.Int32));
+
+        // Act
+        Provider.AddIndex(indexName, tableName, columnName);
+
+        // Assert
+        var indexes = Provider.GetIndexes(tableName);
+
+        var index = indexes.Single();
+
+        Assert.That(index.Name, Is.EqualTo(indexName).IgnoreCase);
+        Assert.That(index.KeyColumns.Single(), Is.EqualTo(columnName).IgnoreCase);
+    }
+}

src/Migrator.Tests/Providers/Generic/Generic_GetIndexesTestsBase.cs

@@ -0,0 +1,55 @@
+using System.Data;
+using System.Linq;
+using DotNetProjects.Migrator.Framework;
+using DotNetProjects.Migrator.Providers.Models.Indexes.Enums;
+using Migrator.Tests.Providers.Base;
+using NUnit.Framework;
+using Index = DotNetProjects.Migrator.Framework.Index;
+
+namespace Migrator.Tests.Providers.Generic;
+
+public abstract class Generic_GetIndexesTestsBase : TransformationProviderBase
+{
+    [Test]
+    public void AddIndex_FilteredIndexGreaterOrEqualThanNumber_Success()
+    {
+        // Arrange
+        const string tableName = "TestTable";
+        const string columnName = "TestColumn";
+        const string columnName2 = "TestColumn2";
+        const string columnName3 = "TestColumn3";
+        const string indexName = "TestIndexName";
+
+        Provider.AddTable(tableName,
+            new Column(columnName, DbType.Int32),
+            new Column(columnName2, DbType.String),
+            new Column(columnName3, DbType.Int32)
+        );
+
+        Provider.AddIndex(tableName,
+            new Index
+            {
+                Name = indexName,
+                KeyColumns = [columnName, columnName2],
+                Unique = true,
+                FilterItems = [
+                    new() { Filter = FilterType.GreaterThanOrEqualTo, ColumnName = columnName, Value = 100 },
+                    new() { Filter = FilterType.EqualTo, ColumnName = columnName2, Value = "Hello" },
+                ]
+            });
+
+        // Act
+        var indexes = Provider.GetIndexes(table: tableName);
+
+        var index = indexes.Single();
+
+        var filterItem1 = index.FilterItems.Single(x => x.ColumnName == columnName);
+        var filterItem2 = index.FilterItems.Single(x => x.ColumnName == columnName2);
+
+        Assert.That(filterItem1.Filter, Is.EqualTo(FilterType.GreaterThanOrEqualTo));
+        Assert.That((long)filterItem1.Value, Is.EqualTo(100));
+
+        Assert.That(filterItem2.Filter, Is.EqualTo(FilterType.EqualTo));
+        Assert.That((string)filterItem2.Value, Is.EqualTo("Hello"));
+    }
+}

src/Migrator.Tests/Providers/Generic/TransformationProviderGenericMiscConstraintBase.cs

@@ -44,14 +44,7 @@ public void CanAddPrimaryKey()
     {
         AddPrimaryKey();
 
-        if (Provider is SQLiteTransformationProvider)
-        {
-            Assert.Throws<NotSupportedException>(() => Provider.PrimaryKeyExists("Test", "PK_Test"));
-        }
-        else
-        {
-            Assert.That(Provider.PrimaryKeyExists("Test", "PK_Test"), Is.True);
-        }
+        Assert.That(Provider.PrimaryKeyExists("Test", "PK_Test"), Is.True);
     }
 
     // [Test]