test: add complex calculation tests with filtered aggregates

Adds comprehensive tests for calculations that depend on filtered aggregates,
including keyset pagination scenarios and SQL fragment calculations with
COALESCE patterns. Includes migration for new test fields.

Author: DGollings

priv/test_repo/migrations/20251114200000_add_reading_time_calculation_fields.exs

@@ -0,0 +1,41 @@
+# SPDX-FileCopyrightText: 2019 ash_postgres contributors <https://github.com/ash-project/ash_postgres/graphs.contributors>
+#
+# SPDX-License-Identifier: MIT
+
+defmodule AshPostgres.TestRepo.Migrations.AddReadingTimeCalculationFields do
+  @moduledoc """
+  Adds fields needed for testing estimated_reading_time calculation pattern.
+
+  Manually created to test complex calculation with filtered aggregates.
+  """
+
+  use Ecto.Migration
+
+  def up do
+    alter table(:posts) do
+      add(:base_reading_time, :integer)
+    end
+
+    alter table(:comments) do
+      add(:edited_duration, :integer)
+      add(:planned_duration, :integer)
+      add(:reading_time, :integer)
+      add(:version, :text)
+      add(:status, :text)
+    end
+  end
+
+  def down do
+    alter table(:comments) do
+      remove(:status)
+      remove(:version)
+      remove(:reading_time)
+      remove(:planned_duration)
+      remove(:edited_duration)
+    end
+
+    alter table(:posts) do
+      remove(:base_reading_time)
+    end
+  end
+end

test/aggregate_test.exs

@@ -1891,7 +1891,7 @@ defmodule AshSql.AggregateTest do
       # (like last_read_message_id) in the subquery even if not explicitly selected.
 
       Chat
-      |> Ash.Query.select(:id)
+      |> Ash.Query.select([:id, :last_read_message_id])
       |> Ash.Query.load(:unread_message_count)
       |> Ash.Query.limit(10)
       |> Ash.read!()

test/calculation_test.exs

@@ -111,6 +111,34 @@ defmodule AshPostgres.CalculationTest do
     |> Ash.read!()
   end
 
+  test "runtime loading calculation with fragment referencing aggregate works correctly" do
+
+    post =
+      Post
+      |> Ash.Changeset.for_create(:create, %{title: "test post"})
+      |> Ash.create!()
+
+    Comment
+    |> Ash.Changeset.for_create(:create, %{title: "comment1", likes: 5})
+    |> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
+    |> Ash.create!()
+
+    Comment
+    |> Ash.Changeset.for_create(:create, %{title: "comment2", likes: 15})
+    |> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
+    |> Ash.create!()
+
+    result =
+      Post
+      |> Ash.Query.load([:comment_metric, :complex_comment_metric, :multi_agg_calc])
+      |> Ash.read!()
+
+    assert [post] = result
+    assert is_integer(post.comment_metric)
+    assert is_integer(post.complex_comment_metric)
+    assert is_integer(post.multi_agg_calc)
+  end
+
   test "expression calculations don't load when `reuse_values?` is true" do
     post =
       Post
@@ -1241,4 +1269,219 @@ defmodule AshPostgres.CalculationTest do
 
     assert [] == Ash.read!(query)
   end
+
+  test "expression calculation referencing aggregates loaded via code_interface with load option" do
+    post =
+      Post
+      |> Ash.Changeset.for_create(:create, %{title: "test post"})
+      |> Ash.create!()
+
+    Comment
+    |> Ash.Changeset.for_create(:create, %{title: "comment1", likes: 5})
+    |> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
+    |> Ash.create!()
+
+    Comment
+    |> Ash.Changeset.for_create(:create, %{title: "comment2", likes: 15})
+    |> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
+    |> Ash.create!()
+
+    result = Post.get_by_id!(post.id, load: [:comment_metric])
+
+    assert result.comment_metric == 200
+  end
+
+  test "complex SQL fragment calculation with multiple aggregates" do
+    post =
+      Post
+      |> Ash.Changeset.for_create(:create, %{
+        title: "test post",
+        base_reading_time: 500
+      })
+      |> Ash.create!()
+
+    Comment
+    |> Ash.Changeset.for_create(:create, %{
+      title: "comment1",
+      edited_duration: 100,
+      planned_duration: 80,
+      reading_time: 30,
+      version: :edited
+    })
+    |> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
+    |> Ash.create!()
+
+    Comment
+    |> Ash.Changeset.for_create(:create, %{
+      title: "comment2",
+      edited_duration: 0,
+      planned_duration: 120,
+      reading_time: 45,
+      version: :planned
+    })
+    |> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
+    |> Ash.create!()
+
+    result = Post.get_by_id!(post.id, load: [:estimated_reading_time])
+
+    assert result.estimated_reading_time == 175
+  end
+
+  test "calculation with missing aggregate dependencies" do
+    post =
+      Post
+      |> Ash.Changeset.for_create(:create, %{
+        title: "test post",
+        base_reading_time: 500
+      })
+      |> Ash.create!()
+
+    Comment
+    |> Ash.Changeset.for_create(:create, %{
+      title: "modified comment",
+      edited_duration: 100,
+      planned_duration: 0,
+      reading_time: 30,
+      version: :edited
+    })
+    |> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
+    |> Ash.create!()
+
+    Comment
+    |> Ash.Changeset.for_create(:create, %{
+      title: "planned comment",
+      edited_duration: 0,
+      planned_duration: 80,
+      reading_time: 20,
+      version: :planned
+    })
+    |> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
+    |> Ash.create!()
+
+    result = Post.get_by_id!(post.id, load: [:estimated_reading_time])
+
+    refute match?(%Ash.NotLoaded{}, result.estimated_reading_time),
+           "Expected calculated value, got: #{inspect(result.estimated_reading_time)}"
+  end
+
+  test "calculation with filtered aggregates and keyset pagination" do
+    post =
+      Post
+      |> Ash.Changeset.for_create(:create, %{
+        title: "test post",
+        base_reading_time: 500
+      })
+      |> Ash.create!()
+
+    Comment
+    |> Ash.Changeset.for_create(:create, %{
+      title: "completed comment",
+      edited_duration: 100,
+      reading_time: 30,
+      version: :edited,
+      status: :published
+    })
+    |> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
+    |> Ash.create!()
+
+    Comment
+    |> Ash.Changeset.for_create(:create, %{
+      title: "pending comment",
+      planned_duration: 80,
+      reading_time: 20,
+      version: :planned,
+      status: :pending
+    })
+    |> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
+    |> Ash.create!()
+
+
+    result_calc_only = Post.get_by_id!(post.id, load: [:estimated_reading_time])
+
+    debug_result =
+      Post.get_by_id!(post.id,
+        load: [
+          :total_edited_time,
+          :total_planned_time,
+          :total_comment_time,
+          :published_comments,
+          :base_reading_time
+        ]
+      )
+
+    result_count_only = Post.get_by_id!(post.id, load: [:published_comments])
+
+
+    result_both = Post.get_by_id!(post.id, load: [:published_comments, :estimated_reading_time])
+
+
+    assert result_both.estimated_reading_time == 150,
+           "Should calculate correctly with both loaded"
+
+    assert result_both.published_comments == 1, "Should count correctly with both loaded"
+  end
+
+  test "calculation with keyset pagination works correctly (previously returned NotLoaded)" do
+    _posts =
+      Enum.map(1..5, fn i ->
+        post =
+          Post
+          |> Ash.Changeset.for_create(:create, %{
+            title: "test post #{i}",
+            base_reading_time: 100 * i
+          })
+          |> Ash.create!()
+
+        Comment
+        |> Ash.Changeset.for_create(:create, %{
+          title: "comment#{i}",
+          edited_duration: 50 * i,
+          planned_duration: 40 * i,
+          reading_time: 10 * i,
+          version: :edited,
+          status: :published
+        })
+        |> Ash.Changeset.manage_relationship(:post, post, type: :append_and_remove)
+        |> Ash.create!()
+
+        post
+      end)
+
+    first_page =
+      Post
+      |> Ash.Query.load([:published_comments, :estimated_reading_time])
+      |> Ash.read!(action: :read_with_related_list_agg_filter, page: [limit: 2, count: true])
+
+    Enum.each(first_page.results, fn post ->
+      refute match?(%Ash.NotLoaded{}, post.estimated_reading_time),
+             "First page post #{post.id} should have loaded estimated_reading_time, got: #{inspect(post.estimated_reading_time)}"
+    end)
+
+    if first_page.more? do
+      second_page =
+        Post
+        |> Ash.Query.load([:published_comments, :estimated_reading_time])
+        |> Ash.read!(
+          action: :read_with_related_list_agg_filter,
+          page: [
+            limit: 2,
+            after: first_page.results |> List.last() |> Map.get(:__metadata__) |> Map.get(:keyset)
+          ]
+        )
+
+
+      assert length(second_page.results) > 0, "Second page should have results"
+
+      Enum.each(second_page.results, fn post ->
+        refute match?(%Ash.NotLoaded{}, post.estimated_reading_time),
+               "estimated_reading_time should be calculated, not NotLoaded"
+
+        refute match?(%Ash.NotLoaded{}, post.published_comments),
+               "published_comments should be calculated, not NotLoaded"
+
+        assert post.estimated_reading_time > 0, "estimated_reading_time should be positive"
+        assert post.published_comments == 1, "Each post has exactly 1 completed comment"
+      end)
+    end
+  end
 end

test/complex_calculation_test.exs

@@ -0,0 +1,67 @@
+defmodule AshPostgres.Test.ComplexCalculationTest do
+  use AshPostgres.RepoCase, async: false
+  alias AshPostgres.Test.{Comment, Post}
+  require Ash.Query
+
+  describe "complex calculations with filtered aggregates" do
+    test "estimated_reading_time calculation works with filtered aggregates and pagination" do
+      post =
+        Post
+        |> Ash.Changeset.for_create(:create, %{
+          title: "Test Post",
+          base_reading_time: 0
+        })
+        |> Ash.create!()
+
+      for i <- 1..3 do
+        Comment
+        |> Ash.Changeset.for_create(:create, %{
+          post_id: post.id,
+          reading_time: 30 + i * 10,
+          status: :published
+        })
+        |> Ash.create!()
+      end
+
+      query_opts = [
+        load: [:published_comments, :estimated_reading_time],
+        page: [limit: 5]
+      ]
+
+      page_result =
+        Ash.Query.filter(Post, id == ^post.id)
+        |> Ash.read!(query_opts)
+
+      [post] = page_result.results
+
+      assert post.estimated_reading_time == 150
+      assert post.published_comments == 3
+    end
+
+    test "estimated_reading_time works when loaded independently (control test)" do
+      post =
+        Post
+        |> Ash.Changeset.for_create(:create, %{
+          title: "Control Test",
+          base_reading_time: 0
+        })
+        |> Ash.create!()
+
+      for i <- 1..3 do
+        Comment
+        |> Ash.Changeset.for_create(:create, %{
+          post_id: post.id,
+          reading_time: 30 + i * 10,
+          status: :published
+        })
+        |> Ash.create!()
+      end
+
+      [post] =
+        Ash.Query.filter(Post, id == ^post.id)
+        |> Ash.read!(load: [:estimated_reading_time])
+
+      assert post.estimated_reading_time == 150
+    end
+  end
+end

test/support/resources/comment.ex

@@ -48,6 +48,11 @@ defmodule AshPostgres.Test.Comment do
     attribute(:title, :string, public?: true)
     attribute(:likes, :integer, public?: true)
     attribute(:arbitrary_timestamp, :utc_datetime_usec, public?: true)
+    attribute(:edited_duration, :integer, public?: true)
+    attribute(:planned_duration, :integer, public?: true)
+    attribute(:reading_time, :integer, public?: true)
+    attribute(:version, :atom, constraints: [one_of: [:edited, :planned]], public?: true)
+    attribute(:status, :atom, constraints: [one_of: [:published, :draft]], public?: true)
     create_timestamp(:created_at, writable?: true, public?: true)
   end