test: expand branch coverage across renderers, differs, generators and helpers

Author: sebastian-ederer

src/Eftdb.Design/TimescaleCSharpMigrationOperationGenerator.cs

@@ -13,70 +13,51 @@ protected override void Generate(MigrationOperation operation, IndentedStringBui
             ArgumentNullException.ThrowIfNull(operation);
             ArgumentNullException.ThrowIfNull(builder);
 
-            HypertableCSharpGenerator? hypertableCSharpGenerator = null;
-            ReorderPolicyCSharpGenerator? reorderPolicyCSharpGenerator = null;
-            RetentionPolicyCSharpGenerator? retentionPolicyCSharpGenerator = null;
-            ContinuousAggregateCSharpGenerator? continuousAggregateCSharpGenerator = null;
-            ContinuousAggregatePolicyCSharpGenerator? continuousAggregatePolicyCSharpGenerator = null;
-
             switch (operation)
             {
                 case CreateHypertableOperation create:
-                    hypertableCSharpGenerator ??= new(Dependencies.CSharpHelper);
-                    hypertableCSharpGenerator.Generate(create, builder);
+                    new HypertableCSharpGenerator(Dependencies.CSharpHelper).Generate(create, builder);
                     return;
                 case AlterHypertableOperation alter:
-                    hypertableCSharpGenerator ??= new(Dependencies.CSharpHelper);
-                    hypertableCSharpGenerator.Generate(alter, builder);
+                    new HypertableCSharpGenerator(Dependencies.CSharpHelper).Generate(alter, builder);
                     return;
 
                 case AddReorderPolicyOperation addReorder:
-                    reorderPolicyCSharpGenerator ??= new(Dependencies.CSharpHelper);
-                    reorderPolicyCSharpGenerator.Generate(addReorder, builder);
+                    new ReorderPolicyCSharpGenerator(Dependencies.CSharpHelper).Generate(addReorder, builder);
                     return;
                 case AlterReorderPolicyOperation alterReorder:
-                    reorderPolicyCSharpGenerator ??= new(Dependencies.CSharpHelper);
-                    reorderPolicyCSharpGenerator.Generate(alterReorder, builder);
+                    new ReorderPolicyCSharpGenerator(Dependencies.CSharpHelper).Generate(alterReorder, builder);
                     return;
                 case DropReorderPolicyOperation dropReorder:
-                    reorderPolicyCSharpGenerator ??= new(Dependencies.CSharpHelper);
-                    reorderPolicyCSharpGenerator.Generate(dropReorder, builder);
+                    new ReorderPolicyCSharpGenerator(Dependencies.CSharpHelper).Generate(dropReorder, builder);
                     return;
 
                 case AddRetentionPolicyOperation addRetention:
-                    retentionPolicyCSharpGenerator ??= new(Dependencies.CSharpHelper);
-                    retentionPolicyCSharpGenerator.Generate(addRetention, builder);
+                    new RetentionPolicyCSharpGenerator(Dependencies.CSharpHelper).Generate(addRetention, builder);
                     return;
                 case AlterRetentionPolicyOperation alterRetention:
-                    retentionPolicyCSharpGenerator ??= new(Dependencies.CSharpHelper);
-                    retentionPolicyCSharpGenerator.Generate(alterRetention, builder);
+                    new RetentionPolicyCSharpGenerator(Dependencies.CSharpHelper).Generate(alterRetention, builder);
                     return;
                 case DropRetentionPolicyOperation dropRetention:
-                    retentionPolicyCSharpGenerator ??= new(Dependencies.CSharpHelper);
-                    retentionPolicyCSharpGenerator.Generate(dropRetention, builder);
+                    new RetentionPolicyCSharpGenerator(Dependencies.CSharpHelper).Generate(dropRetention, builder);
                     return;
 
                 case CreateContinuousAggregateOperation createContinuousAggregate:
-                    continuousAggregateCSharpGenerator ??= new(Dependencies.CSharpHelper);
-                    continuousAggregateCSharpGenerator.Generate(createContinuousAggregate, builder);
+                    new ContinuousAggregateCSharpGenerator(Dependencies.CSharpHelper).Generate(createContinuousAggregate, builder);
                     return;
                 case AlterContinuousAggregateOperation alterContinuousAggregate:
-                    continuousAggregateCSharpGenerator ??= new(Dependencies.CSharpHelper);
-                    continuousAggregateCSharpGenerator.Generate(alterContinuousAggregate, builder);
+                    new ContinuousAggregateCSharpGenerator(Dependencies.CSharpHelper).Generate(alterContinuousAggregate, builder);
                     return;
                 case DropContinuousAggregateOperation dropContinuousAggregate:
-                    continuousAggregateCSharpGenerator ??= new(Dependencies.CSharpHelper);
-                    continuousAggregateCSharpGenerator.Generate(dropContinuousAggregate, builder);
+                    new ContinuousAggregateCSharpGenerator(Dependencies.CSharpHelper).Generate(dropContinuousAggregate, builder);
                     return;
 
                 case AddContinuousAggregatePolicyOperation addContinuousAggregatePolicy:
-                    continuousAggregatePolicyCSharpGenerator ??= new(Dependencies.CSharpHelper);
-                    continuousAggregatePolicyCSharpGenerator.Generate(addContinuousAggregatePolicy, builder);
+                    new ContinuousAggregatePolicyCSharpGenerator(Dependencies.CSharpHelper).Generate(addContinuousAggregatePolicy, builder);
                     return;
 
                 case RemoveContinuousAggregatePolicyOperation removeContinuousAggregatePolicy:
-                    continuousAggregatePolicyCSharpGenerator ??= new(Dependencies.CSharpHelper);
-                    continuousAggregatePolicyCSharpGenerator.Generate(removeContinuousAggregatePolicy, builder);
+                    new ContinuousAggregatePolicyCSharpGenerator(Dependencies.CSharpHelper).Generate(removeContinuousAggregatePolicy, builder);
                     return;
 
                 default:

tests/Eftdb.Tests/Configuration/RetentionPolicyAttributeTests.cs

@@ -230,6 +230,28 @@ public void AllProperties_CanBeSetTogether()
 
     #endregion
 
+    #region Should_Throw_When_DropAfter_WhitespaceOnly
+
+    [Fact]
+    public void Constructor2_With_WhitespaceOnly_DropAfter_ThrowsInvalidOperationException()
+    {
+        // Arrange & Act & Assert
+        InvalidOperationException ex = Assert.Throws<InvalidOperationException>(
+            () => new RetentionPolicyAttribute(dropAfter: "   ", dropCreatedBefore: null));
+        Assert.Contains("exactly one", ex.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void Constructor2_With_WhitespaceOnly_DropCreatedBefore_ThrowsInvalidOperationException()
+    {
+        // Arrange & Act & Assert
+        InvalidOperationException ex = Assert.Throws<InvalidOperationException>(
+            () => new RetentionPolicyAttribute(dropAfter: null, dropCreatedBefore: "\t  "));
+        Assert.Contains("exactly one", ex.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    #endregion
+
     #region Constructor2 Empty and Whitespace String Tests
 
     [Fact]

tests/Eftdb.Tests/Conventions/ContinuousAggregateConventionTests.cs

@@ -960,4 +960,156 @@ public void Should_Not_Set_GroupByColumns_Annotation_Without_Attributes()
     }
 
     #endregion
+
+    #region Should_Not_Set_TimeBucket_Annotations_When_TimeBucket_Attribute_Absent
+
+    [Hypertable("Timestamp")]
+    private class NoTimeBucketSourceEntity
+    {
+        public DateTime Timestamp { get; set; }
+        public double Value { get; set; }
+    }
+
+    [ContinuousAggregate(MaterializedViewName = "no_timebucket_view", ParentName = "no_timebucket_source")]
+    private class NoTimeBucketCaEntity
+    {
+        [Aggregate(EAggregateFunction.Avg, "Value")]
+        public double AvgValue { get; set; }
+    }
+
+    private class NoTimeBucketContext : DbContext
+    {
+        public DbSet<NoTimeBucketSourceEntity> Sources => Set<NoTimeBucketSourceEntity>();
+        public DbSet<NoTimeBucketCaEntity> Aggregates => Set<NoTimeBucketCaEntity>();
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+            => optionsBuilder.UseNpgsql("Host=localhost;Database=test;Username=test;Password=test")
+                            .UseTimescaleDb();
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<NoTimeBucketSourceEntity>(entity =>
+            {
+                entity.HasNoKey();
+                entity.ToTable("no_timebucket_source");
+            });
+
+            modelBuilder.Entity<NoTimeBucketCaEntity>(entity =>
+            {
+                entity.HasNoKey();
+            });
+        }
+    }
+
+    [Fact]
+    public void Should_Not_Set_TimeBucket_Annotations_When_TimeBucket_Attribute_Absent()
+    {
+        using NoTimeBucketContext context = new();
+
+        // Act
+        IModel model = GetModel(context);
+        IEntityType entityType = model.FindEntityType(typeof(NoTimeBucketCaEntity))!;
+
+        // Assert
+        Assert.NotNull(entityType.FindAnnotation(ContinuousAggregateAnnotations.MaterializedViewName));
+        Assert.Null(entityType.FindAnnotation(ContinuousAggregateAnnotations.TimeBucketWidth));
+        Assert.Null(entityType.FindAnnotation(ContinuousAggregateAnnotations.TimeBucketSourceColumn));
+    }
+
+    #endregion
+
+    #region Should_Use_Property_Name_As_Source_Column_When_AggregateAttribute_SourceColumn_Not_Provided
+
+    [Hypertable("Timestamp")]
+    private class DefaultSourceColSourceEntity
+    {
+        public DateTime Timestamp { get; set; }
+        public double Revenue { get; set; }
+    }
+
+    [ContinuousAggregate(MaterializedViewName = "default_src_col_view", ParentName = "default_src_col_source")]
+    [TimeBucket("1 day", "Timestamp")]
+    private class DefaultSourceColCaEntity
+    {
+        [Aggregate(EAggregateFunction.Count)]
+        public long EventCount { get; set; }
+    }
+
+    private class DefaultSourceColContext : DbContext
+    {
+        public DbSet<DefaultSourceColSourceEntity> Sources => Set<DefaultSourceColSourceEntity>();
+        public DbSet<DefaultSourceColCaEntity> Aggregates => Set<DefaultSourceColCaEntity>();
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+            => optionsBuilder.UseNpgsql("Host=localhost;Database=test;Username=test;Password=test")
+                            .UseTimescaleDb();
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<DefaultSourceColSourceEntity>(entity =>
+            {
+                entity.HasNoKey();
+                entity.ToTable("default_src_col_source");
+            });
+
+            modelBuilder.Entity<DefaultSourceColCaEntity>(entity =>
+            {
+                entity.HasNoKey();
+            });
+        }
+    }
+
+    [Fact]
+    public void Should_Use_Property_Name_As_Source_Column_When_AggregateAttribute_SourceColumn_Not_Provided()
+    {
+        // Arrange
+        using DefaultSourceColContext context = new();
+
+        // Act
+        IModel model = GetModel(context);
+        IEntityType entityType = model.FindEntityType(typeof(DefaultSourceColCaEntity))!;
+        List<string>? aggregateFunctions = entityType
+            .FindAnnotation(ContinuousAggregateAnnotations.AggregateFunctions)?.Value as List<string>;
+
+        // Assert
+        Assert.NotNull(aggregateFunctions);
+        Assert.Contains(aggregateFunctions, e => e.StartsWith("EventCount:Count:*", StringComparison.Ordinal));
+    }
+
+    #endregion
+
+    #region Should_Skip_CA_Annotations_For_Property_Bag_Entity
+
+    private class PropertyBagCaContext : DbContext
+    {
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+            => optionsBuilder.UseNpgsql("Host=localhost;Database=test;Username=test;Password=test")
+                            .UseTimescaleDb();
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity("PropertyBagCaTestEntity", b =>
+            {
+                b.HasNoKey();
+                b.ToTable("prop_bag_ca_test");
+                b.Property<int>("Id");
+            });
+        }
+    }
+
+    [Fact]
+    public void Should_Skip_CA_Annotations_For_Property_Bag_Entity()
+    {
+        // Arrange
+        using PropertyBagCaContext context = new();
+        IModel model = GetModel(context);
+        IEntityType entityType = model.FindEntityType("PropertyBagCaTestEntity")!;
+
+        // Act + Assert
+        Assert.NotNull(entityType);
+        Assert.Null(entityType.FindAnnotation(ContinuousAggregateAnnotations.MaterializedViewName));
+        Assert.Null(entityType.FindAnnotation(ContinuousAggregateAnnotations.ParentName));
+    }
+
+    #endregion
 }