chore: initial git load of code space

tests/Strata.SqlTools.PostgreSql.Tests/PostgreSql/StatementReaderTests.cs

@@ -0,0 +1,223 @@
+using Strata.SqlTools.SqlBreakdown.Enums.SQL;
+using Strata.SqlTools.SqlBreakdown.Exceptions;
+using Strata.SqlTools.SqlBreakdown.Exceptions;
+using StatementReader = Strata.SqlTools.Statements.PostgreSql.StatementReader;
+
+namespace Strata.SqlTools.SqlBreakdown.Tests.PostgreSql;
+
+[TestFixture]
+public class StatementReaderTests
+{
+    [Test]
+    public void StatementReader_ParsesCalculationString()
+    {
+        // Arrange
+        var calculationString = "(1 + 2) / SUM(column_id) + SUM(other_column) - SUM(another_column) * 2.3";
+        var sqlReader = new StatementReader(calculationString);
+        var tokens = new List<(TokenType Type, string Value)>();
+
+        // Act
+        while (sqlReader.Read())
+        {
+            tokens.Add((sqlReader.TokenType, sqlReader.TokenValue));
+        }
+
+        // Assert
+        Assert.That(tokens, Is.Not.Empty);
+        Assert.That(tokens[0].Type, Is.EqualTo(TokenType.LeftParenthesis));
+        Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Number));
+        Assert.That(tokens[1].Value, Is.EqualTo("1"));
+    }
+
+    [Test]
+    public void StatementReader_ParsesDoubleQuotedIdentifiers()
+    {
+        // Arrange - PostgreSQL-specific double-quoted identifiers (case-sensitive)
+        var calculationString = "\"COLUMN_1\" + \"COLUMN_2\" * 2";
+        var sqlReader = new StatementReader(calculationString);
+        var tokens = new List<(TokenType Type, string Value)>();
+
+        // Act
+        while (sqlReader.Read())
+        {
+            tokens.Add((sqlReader.TokenType, sqlReader.TokenValue));
+        }
+
+        // Assert
+        Assert.That(tokens, Has.Count.EqualTo(5)); // "COLUMN_1" + "COLUMN_2" * 2
+        Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+        Assert.That(tokens[0].Value, Is.EqualTo("COLUMN_1"));
+        Assert.That(tokens[1].Type, Is.EqualTo(TokenType.Plus));
+        Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+    }
+
+    [Test]
+    public void StatementReader_ParsesDoubleQuotedIdentifiersWithCase()
+    {
+        // Arrange - PostgreSQL preserves case in double-quoted identifiers
+        var calculationString = "\"MyColumn\" + \"AnotherColumn\"";
+        var sqlReader = new StatementReader(calculationString);
+        var tokens = new List<(TokenType Type, string Value)>();
+
+        // Act
+        while (sqlReader.Read())
+        {
+            tokens.Add((sqlReader.TokenType, sqlReader.TokenValue));
+        }
+
+        // Assert
+        Assert.That(tokens[0].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+        Assert.That(tokens[0].Value, Is.EqualTo("MyColumn"));
+        Assert.That(tokens[2].Type, Is.EqualTo(TokenType.ColumnIdentifier));
+        Assert.That(tokens[2].Value, Is.EqualTo("AnotherColumn"));
+    }
+
+    [Test]
+    public void StatementReader_ParsesPositionalParameters()
+    {
+        // Arrange - PostgreSQL positional parameters ($1, $2, etc.)
+        var calculationString = "column_id = $1 AND status = $2";
+        var sqlReader = new StatementReader(calculationString);
+        var tokens = new List<(TokenType Type, string Value)>();
+
+        // Act
+        while (sqlReader.Read())
+        {
+            tokens.Add((sqlReader.TokenType, sqlReader.TokenValue));
+        }
+
+        // Assert
+        Assert.That(tokens.Count, Is.GreaterThan(0));
+        var paramTokens = tokens.Where(t => t.Type == TokenType.Parameter).ToList();
+        Assert.That(paramTokens.Count, Is.EqualTo(2));
+        Assert.That(paramTokens[0].Value, Is.EqualTo("$1"));
+        Assert.That(paramTokens[1].Value, Is.EqualTo("$2"));
+    }
+
+    [Test]
+    public void StatementReader_ParsesUnderscorePrefixedIdentifiers()
+    {
+        // Arrange - PostgreSQL allows underscores to start identifiers
+        var calculationString = "_internal_column + _private_field";
+        var sqlReader = new StatementReader(calculationString);
+        var tokens = new List<(TokenType Type, string Value)>();
+
+        // Act
+        while (sqlReader.Read())
+        {
+            tokens.Add((sqlReader.TokenType, sqlReader.TokenValue));
+        }
+
+        // Assert
+        var identifierTokens = tokens.Where(t => t.Type == TokenType.ColumnIdentifier).ToList();
+        Assert.That(identifierTokens.Count, Is.GreaterThanOrEqualTo(2));
+    }
+
+    [Test]
+    public void StatementReader_ParsesComplexExpression()
+    {
+        // Arrange - Complex PostgreSQL expression
+        var calculationString = "(\"Price\" * quantity) - discount WHERE user_id = $1";
+        var sqlReader = new StatementReader(calculationString);
+        var tokens = new List<(TokenType Type, string Value)>();
+
+        // Act
+        while (sqlReader.Read())
+        {
+            tokens.Add((sqlReader.TokenType, sqlReader.TokenValue));
+        }
+
+        // Assert
+        Assert.That(tokens, Is.Not.Empty);
+        var identifierCount = tokens.Count(t => t.Type == TokenType.ColumnIdentifier);
+        Assert.That(identifierCount, Is.GreaterThan(0));
+    }
+
+    [Test]
+    public void StatementReader_ThrowsOnUnclosedDoubleQuote()
+    {
+        // Arrange
+        var calculationString = "\"UNCLOSED_IDENTIFIER + 1";
+        var sqlReader = new StatementReader(calculationString);
+
+        // Act & Assert
+        Assert.Throws<InvalidSyntaxException>(() =>
+        {
+            while (sqlReader.Read()) { }
+        });
+    }
+
+    [Test]
+    public void StatementReader_ParsesWhitespace()
+    {
+        // Arrange
+        var calculationString = "  column_1   +   column_2  ";
+        var sqlReader = new StatementReader(calculationString);
+        var tokens = new List<(TokenType Type, string Value)>();
+
+        // Act
+        while (sqlReader.Read())
+        {
+            tokens.Add((sqlReader.TokenType, sqlReader.TokenValue));
+        }
+
+        // Assert
+        Assert.That(tokens.Count, Is.GreaterThan(0));
+    }
+
+    [Test]
+    public void StatementReader_ParsesOperators()
+    {
+        // Arrange
+        var calculationString = "a = b";
+        var sqlReader = new StatementReader(calculationString);
+        var tokens = new List<(TokenType Type, string Value)>();
+
+        // Act
+        while (sqlReader.Read())
+        {
+            tokens.Add((sqlReader.TokenType, sqlReader.TokenValue));
+        }
+
+        // Assert
+        Assert.That(tokens.Count, Is.GreaterThan(0));
+    }
+
+    [Test]
+    public void StatementReader_ParsesStrings()
+    {
+        // Arrange
+        var calculationString = "column = 'string value' AND other = 'another string'";
+        var sqlReader = new StatementReader(calculationString);
+        var tokens = new List<(TokenType Type, string Value)>();
+
+        // Act
+        while (sqlReader.Read())
+        {
+            tokens.Add((sqlReader.TokenType, sqlReader.TokenValue));
+        }
+
+        // Assert
+        var stringTokens = tokens.Where(t => t.Type == TokenType.String).ToList();
+        Assert.That(stringTokens.Count, Is.GreaterThanOrEqualTo(2));
+    }
+
+    [Test]
+    public void StatementReader_ParsesNumbers()
+    {
+        // Arrange
+        var calculationString = "42 + 3.14 - 100";
+        var sqlReader = new StatementReader(calculationString);
+        var tokens = new List<(TokenType Type, string Value)>();
+
+        // Act
+        while (sqlReader.Read())
+        {
+            tokens.Add((sqlReader.TokenType, sqlReader.TokenValue));
+        }
+
+        // Assert
+        var numberTokens = tokens.Where(t => t.Type == TokenType.Number).ToList();
+        Assert.That(numberTokens.Count, Is.GreaterThan(0));
+    }
+}