test: Add comprehensive test coverage for continuous aggregate policies

Add unit tests for previously untested components: builder validation,                                                                                                                                                                                                                                         model extractor, annotation applier, and convention error handling. These tests cover input validation, default value handling, schema                                                                                                                                                                                                                      resolution, annotation application, and fluent API method chaining.

Author: sebastian-ederer

samples/Eftdb.Samples.Shared/Configurations/TradeAggregateConfiguration.cs

@@ -21,7 +21,6 @@ public void Configure(EntityTypeBuilder<TradeAggregate> builder)
                 .Where("\"ticker\" = 'MCRS'")
                 .MaterializedOnly()
                 .WithRefreshPolicy(startOffset: "7 days", endOffset: "1 hour", scheduleInterval: "1 hour")
-                .WithTimezone("UTC")
                 .WithRefreshNewestFirst(true);
         }
     }

samples/Eftdb.Samples.Shared/Models/WeatherAggregate.cs

@@ -23,7 +23,6 @@ namespace CmdScale.EntityFrameworkCore.TimescaleDB.Example.DataAccess.Models
         StartOffset = "30 days",
         EndOffset = "1 day",
         ScheduleInterval = "1 hour",
-        Timezone = "UTC",
         RefreshNewestFirst = true)]
     public class WeatherAggregate
     {

src/Eftdb.Design/Scaffolding/ContinuousAggregatePolicyAnnotationApplier.cs

@@ -36,12 +36,6 @@ public void ApplyAnnotations(DatabaseTable table, object featureInfo)
                 table[ContinuousAggregatePolicyAnnotations.ScheduleInterval] = info.ScheduleInterval;
             }
 
-            // Apply timezone
-            if (!string.IsNullOrWhiteSpace(info.Timezone))
-            {
-                table[ContinuousAggregatePolicyAnnotations.Timezone] = info.Timezone;
-            }
-
             // Apply initial_start
             if (info.InitialStart.HasValue)
             {

src/Eftdb.Design/Scaffolding/ContinuousAggregatePolicyScaffoldingExtractor.cs

@@ -13,7 +13,6 @@ public sealed record ContinuousAggregatePolicyInfo(
             string? StartOffset,
             string? EndOffset,
             string? ScheduleInterval,
-            string? Timezone,
             DateTime? InitialStart,
             bool? IncludeTieredData,
             int? BucketsPerBatch,
@@ -36,7 +35,6 @@ public sealed record ContinuousAggregatePolicyInfo(
                 using (DbCommand command = connection.CreateCommand())
                 {
                     // Query continuous aggregate policies from TimescaleDB jobs table
-                    // The config column contains JSONB with start_offset, end_offset, timezone, mat_hypertable_id and other policy parameters
                     command.CommandText = @"
                         SELECT
                             ca.user_view_schema,
@@ -61,7 +59,6 @@ INNER JOIN _timescaledb_catalog.continuous_agg ca
                         // Parse the JSONB config to extract policy parameters
                         string? startOffset = null;
                         string? endOffset = null;
-                        string? timezone = null;
                         bool? includeTieredData = null;
                         int? bucketsPerBatch = null;
                         int? maxBatchesPerExecution = null;
@@ -75,20 +72,13 @@ INNER JOIN _timescaledb_catalog.continuous_agg ca
                             // Extract start_offset
                             if (root.TryGetProperty("start_offset", out JsonElement startOffsetElement))
                             {
-                                startOffset = ParseIntervalOrInteger(startOffsetElement);
+                                startOffset = IntervalParsingHelper.ParseIntervalOrInteger(startOffsetElement);
                             }
 
                             // Extract end_offset
                             if (root.TryGetProperty("end_offset", out JsonElement endOffsetElement))
                             {
-                                endOffset = ParseIntervalOrInteger(endOffsetElement);
-                            }
-
-                            // Extract timezone
-                            if (root.TryGetProperty("timezone", out JsonElement timezoneElement)
-                                && timezoneElement.ValueKind == JsonValueKind.String)
-                            {
-                                timezone = timezoneElement.GetString();
+                                endOffset = IntervalParsingHelper.ParseIntervalOrInteger(endOffsetElement);
                             }
 
                             // Extract include_tiered_data (optional)
@@ -124,7 +114,6 @@ INNER JOIN _timescaledb_catalog.continuous_agg ca
                             StartOffset: startOffset,
                             EndOffset: endOffset,
                             ScheduleInterval: scheduleInterval,
-                            Timezone: timezone,
                             InitialStart: initialStart,
                             IncludeTieredData: includeTieredData,
                             BucketsPerBatch: bucketsPerBatch,
@@ -148,80 +137,5 @@ INNER JOIN _timescaledb_catalog.continuous_agg ca
                 }
             }
         }
-
-        /// <summary>
-        /// Parses an interval or integer value from JSONB.
-        /// TimescaleDB stores intervals as strings (e.g., "1 mon", "7 days")
-        /// or integers for integer-based time columns.
-        /// </summary>
-        private static string? ParseIntervalOrInteger(JsonElement element)
-        {
-            if (element.ValueKind == JsonValueKind.Null)
-            {
-                return null;
-            }
-
-            if (element.ValueKind == JsonValueKind.String)
-            {
-                string value = element.GetString() ?? string.Empty;
-                // TimescaleDB stores intervals in PostgreSQL format (e.g., "1 mon", "7 days", "01:00:00")
-                // We need to normalize these to a format that matches what users would write
-                return NormalizeInterval(value);
-            }
-
-            if (element.ValueKind == JsonValueKind.Number)
-            {
-                // Integer-based time column
-                return element.GetInt64().ToString();
-            }
-
-            return null;
-        }
-
-        /// <summary>
-        /// Normalizes PostgreSQL interval format to user-friendly format.
-        /// </summary>
-        /// <remarks>
-        /// PostgreSQL stores intervals in formats like:
-        /// - "1 mon" for 1 month
-        /// - "7 days" for 7 days
-        /// - "01:00:00" for 1 hour
-        /// We normalize these to match the format users would use in Fluent API:
-        /// - "1 month"
-        /// - "7 days"
-        /// - "1 hour"
-        /// </remarks>
-        private static string NormalizeInterval(string pgInterval)
-        {
-            if (string.IsNullOrWhiteSpace(pgInterval))
-            {
-                return pgInterval;
-            }
-
-            string normalized = pgInterval.Trim();
-
-            // Replace "mon" with "month"
-            normalized = normalized.Replace(" mon", " month");
-
-            // Convert time-only intervals (HH:MM:SS) to hour/minute format
-            if (TimeSpan.TryParse(normalized, out TimeSpan timeSpan))
-            {
-                if (timeSpan.TotalMinutes < 60 && timeSpan.Minutes > 0 && timeSpan.Hours == 0)
-                {
-                    return $"{timeSpan.Minutes} minute{(timeSpan.Minutes > 1 ? "s" : "")}";
-                }
-                if (timeSpan.TotalHours < 24 && timeSpan.Hours > 0)
-                {
-                    return $"{timeSpan.Hours} hour{(timeSpan.Hours > 1 ? "s" : "")}";
-                }
-                // For days, use the total days
-                if (timeSpan.Days > 0)
-                {
-                    return $"{timeSpan.Days} day{(timeSpan.Days > 1 ? "s" : "")}";
-                }
-            }
-
-            return normalized;
-        }
     }
 }

src/Eftdb.Design/Scaffolding/IntervalParsingHelper.cs

@@ -0,0 +1,89 @@
+using System.Text.Json;
+
+namespace CmdScale.EntityFrameworkCore.TimescaleDB.Design.Scaffolding
+{
+    /// <summary>
+    /// Provides helper methods for parsing and normalizing TimescaleDB interval values.
+    /// </summary>
+    public static class IntervalParsingHelper
+    {
+        /// <summary>
+        /// Parses an interval or integer value from a JSON element.
+        /// </summary>
+        /// <param name="element">The JSON element to parse.</param>
+        /// <returns>
+        /// A normalized interval string for string-based intervals,
+        /// or a string representation of the integer for integer-based time columns,
+        /// or null if the element is null or cannot be parsed.
+        /// </returns>
+        /// <remarks>
+        /// TimescaleDB stores intervals as strings (e.g., "1 mon", "7 days")
+        /// or integers for integer-based time columns.
+        /// </remarks>
+        public static string? ParseIntervalOrInteger(JsonElement element)
+        {
+            if (element.ValueKind == JsonValueKind.Null)
+            {
+                return null;
+            }
+
+            if (element.ValueKind == JsonValueKind.String)
+            {
+                string value = element.GetString() ?? string.Empty;
+                return NormalizeInterval(value);
+            }
+
+            if (element.ValueKind == JsonValueKind.Number)
+            {
+                return element.GetInt64().ToString();
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Normalizes PostgreSQL interval format to a user-friendly format.
+        /// </summary>
+        /// <param name="pgInterval">The PostgreSQL interval string to normalize.</param>
+        /// <returns>A normalized interval string.</returns>
+        /// <remarks>
+        /// PostgreSQL stores intervals in formats like:
+        /// - "1 mon" for 1 month
+        /// - "7 days" for 7 days
+        /// - "01:00:00" for 1 hour
+        /// This method normalizes these to match the format users would use in Fluent API:
+        /// - "1 month"
+        /// - "7 days"
+        /// - "1 hour"
+        /// </remarks>
+        public static string NormalizeInterval(string pgInterval)
+        {
+            if (string.IsNullOrWhiteSpace(pgInterval))
+            {
+                return pgInterval;
+            }
+
+            string normalized = pgInterval.Trim();
+
+            normalized = normalized.Replace(" mon", " month");
+
+            if (TimeSpan.TryParse(normalized, out TimeSpan timeSpan))
+            {
+                if (timeSpan.TotalMinutes < 60 && timeSpan.Minutes > 0 && timeSpan.Hours == 0)
+                {
+                    return $"{timeSpan.Minutes} minute{(timeSpan.Minutes > 1 ? "s" : "")}";
+                }
+                if (timeSpan.TotalHours < 24 && timeSpan.Hours > 0)
+                {
+                    return $"{timeSpan.Hours} hour{(timeSpan.Hours > 1 ? "s" : "")}";
+                }
+                if (timeSpan.Days > 0)
+                {
+                    return $"{timeSpan.Days} day{(timeSpan.Days > 1 ? "s" : "")}";
+                }
+            }
+
+            return normalized;
+        }
+    }
+}

src/Eftdb/Configuration/ContinuousAggregatePolicy/ContinuousAggregateBuilderPolicyExtensions.cs

@@ -21,7 +21,6 @@ public static class ContinuousAggregateBuilderPolicyExtensions
         /// <code>
         /// builder.IsContinuousAggregate&lt;HourlyMetric, Metric&gt;("hourly_metrics", "1 hour", x => x.Timestamp)
         ///     .WithRefreshPolicy(startOffset: "1 month", endOffset: "1 hour", scheduleInterval: "1 hour")
-        ///     .WithTimezone("UTC")
         ///     .WithRefreshNewestFirst(true);
         /// </code>
         /// </example>

src/Eftdb/Configuration/ContinuousAggregatePolicy/ContinuousAggregatePolicyAnnotations.cs

@@ -38,11 +38,6 @@ public static class ContinuousAggregatePolicyAnnotations
         /// </summary>
         public const string IfNotExists = "TimescaleDB:ContinuousAggregatePolicy:IfNotExists";
 
-        /// <summary>
-        /// Timezone to mitigate daylight savings alignment shifts. Stored as string (e.g., "UTC", "America/New_York").
-        /// </summary>
-        public const string Timezone = "TimescaleDB:ContinuousAggregatePolicy:Timezone";
-
         /// <summary>
         /// Override tiered read settings. Stored as nullable bool.
         /// </summary>

src/Eftdb/Configuration/ContinuousAggregatePolicy/ContinuousAggregatePolicyAttribute.cs

@@ -70,14 +70,6 @@ public sealed class ContinuousAggregatePolicyAttribute : Attribute
         /// </summary>
         public bool IfNotExists { get; set; } = false;
 
-        /// <summary>
-        /// Gets or sets the timezone to mitigate daylight savings alignment shifts.
-        /// </summary>
-        /// <example>
-        /// "UTC", "America/New_York", "Europe/London"
-        /// </example>
-        public string? Timezone { get; set; }
-
         /// <summary>
         /// Gets or sets a value indicating whether to override tiered read settings.
         /// NULL means use default behavior.

src/Eftdb/Configuration/ContinuousAggregatePolicy/ContinuousAggregatePolicyBuilder.cs

@@ -51,20 +51,6 @@ public ContinuousAggregatePolicyBuilder<TEntity, TSourceEntity> WithIfNotExists(
             return this;
         }
 
-        /// <summary>
-        /// Sets the timezone for the continuous aggregate refresh policy to mitigate daylight savings alignment shifts.
-        /// </summary>
-        /// <param name="timezone">The timezone (e.g., "UTC", "America/New_York", "Europe/London").</param>
-        /// <returns>The builder for method chaining.</returns>
-        public ContinuousAggregatePolicyBuilder<TEntity, TSourceEntity> WithTimezone(string timezone)
-        {
-            if (string.IsNullOrWhiteSpace(timezone))
-                throw new ArgumentException("Timezone must be provided.", nameof(timezone));
-
-            EntityTypeBuilder.HasAnnotation(ContinuousAggregatePolicyAnnotations.Timezone, timezone);
-            return this;
-        }
-
         /// <summary>
         /// Configures whether to override tiered read settings for the continuous aggregate refresh policy.
         /// </summary>

src/Eftdb/Configuration/ContinuousAggregatePolicy/ContinuousAggregatePolicyConvention.cs

@@ -60,10 +60,6 @@ public void ProcessEntityTypeAdded(IConventionEntityTypeBuilder entityTypeBuilde
             if (attribute.IfNotExists)
                 entityTypeBuilder.HasAnnotation(ContinuousAggregatePolicyAnnotations.IfNotExists, attribute.IfNotExists);
 
-            // Apply timezone
-            if (!string.IsNullOrWhiteSpace(attribute.Timezone))
-                entityTypeBuilder.HasAnnotation(ContinuousAggregatePolicyAnnotations.Timezone, attribute.Timezone);
-
             // Apply include_tiered_data if explicitly set
             if (attribute.IncludeTieredData.HasValue)
                 entityTypeBuilder.HasAnnotation(ContinuousAggregatePolicyAnnotations.IncludeTieredData, attribute.IncludeTieredData.Value);