Skip to content

Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.

17.6 KB
Raw Blame
defmodule Plausible.PostmarkTest do
  use Plausible.DataCase, async: true
  @moduletag :ee_only
  @moduletag :capture_log

  alias Plausible.EmailSuppressions
  alias Plausible.Postmark

  describe "suppressing_reason/1" do
    test "maps known permanently-bad bounce types" do
      assert Postmark.suppressing_reason("HardBounce") == {:ok, :hard_bounce}
      assert Postmark.suppressing_reason("BadEmailAddress") == {:ok, :bad_email_address}
      assert Postmark.suppressing_reason("Blocked") == {:ok, :blocked}
      assert Postmark.suppressing_reason("SpamNotification") == {:ok, :spam_notification}
      assert Postmark.suppressing_reason("Unsubscribe") == {:ok, :unsubscribe}
    end

    test "does not map transient bounce types" do
      assert Postmark.suppressing_reason("Transient") == :error
      assert Postmark.suppressing_reason("SpamComplaint") == :error
      assert Postmark.suppressing_reason("SomethingUnknown") == :error
    end
  end

  describe "delete_suppression/1" do
    test "deletes the suppression from every stream we send from" do
      Req.Test.stub(Postmark, fn conn ->
        assert conn.method == "POST"

        assert conn.request_path in [
                 "/message-streams/outbound/suppressions/delete",
                 "/message-streams/priority/suppressions/delete"
               ]

        conn = Plug.Conn.fetch_query_params(conn)
        {:ok, body, _conn} = Plug.Conn.read_body(conn)
        assert Jason.decode!(body) == %{"Suppressions" => [%{"EmailAddress" => "[email protected]"}]}

        Req.Test.json(conn, %{
          "Suppressions" => [%{"EmailAddress" => "[email protected]", "Status" => "Deleted"}]
        })
      end)

      assert :ok = Postmark.delete_suppression("[email protected]")
    end

    test "no-ops (still :ok) when the address wasn't suppressed on a stream" do
      Req.Test.stub(Postmark, fn conn ->
        Req.Test.json(conn, %{
          "Suppressions" => [
            %{"EmailAddress" => "[email protected]", "Status" => "Deleted", "Message" => nil}
          ]
        })
      end)

      assert :ok = Postmark.delete_suppression("[email protected]")
    end

    test "returns an error when Postmark refuses (e.g. a spam complaint can't be deleted)" do
      Req.Test.stub(Postmark, fn conn ->
        Req.Test.json(conn, %{
          "Suppressions" => [
            %{
              "EmailAddress" => "[email protected]",
              "Status" => "Failed",
              "Message" => "SpamComplaint suppressions cannot be deleted"
            }
          ]
        })
      end)

      assert {:error, {stream, "SpamComplaint suppressions cannot be deleted"}} =
               Postmark.delete_suppression("[email protected]")

      assert stream in ["outbound", "priority"]
    end

    test "returns an error on a non-200 response from either stream" do
      Req.Test.stub(Postmark, fn conn ->
        case conn.request_path do
          "/message-streams/outbound/suppressions/delete" ->
            Req.Test.json(conn, %{
              "Suppressions" => [%{"EmailAddress" => "[email protected]", "Status" => "Deleted"}]
            })

          "/message-streams/priority/suppressions/delete" ->
            conn |> Plug.Conn.put_status(500) |> Req.Test.json(%{"Message" => "boom"})
        end
      end)

      assert {:error, {:unexpected_status, 500, _body}} =
               Postmark.delete_suppression("[email protected]")
    end
  end

  describe "delete_suppressions/1" do
    test "no-ops without making any request for an empty list" do
      Req.Test.stub(Postmark, fn _conn -> flunk("Postmark should not have been called") end)

      assert [] = Postmark.delete_suppressions([])
    end

    test "deletes every address, on every stream, in a single request each, and confirms all" do
      test_pid = self()

      Req.Test.stub(Postmark, fn conn ->
        assert conn.request_path in [
                 "/message-streams/outbound/suppressions/delete",
                 "/message-streams/priority/suppressions/delete"
               ]

        conn = Plug.Conn.fetch_query_params(conn)
        {:ok, body, conn} = Plug.Conn.read_body(conn)
        send(test_pid, {:request, conn.request_path, Jason.decode!(body)})

        Req.Test.json(conn, %{
          "Suppressions" => [
            %{"EmailAddress" => "[email protected]", "Status" => "Deleted"},
            %{"EmailAddress" => "[email protected]", "Status" => "Deleted"}
          ]
        })
      end)

      assert Postmark.delete_suppressions(["[email protected]", "[email protected]"]) == [
               "[email protected]",
               "[email protected]"
             ]

      for stream <- ["outbound", "priority"] do
        path = "/message-streams/#{stream}/suppressions/delete"
        assert_received {:request, ^path, body}

        assert body == %{
                 "Suppressions" => [
                   %{"EmailAddress" => "[email protected]"},
                   %{"EmailAddress" => "[email protected]"}
                 ]
               }
      end
    end

    test "splits a large batch into multiple requests per stream, respecting Postmark's max of 50" do
      test_pid = self()
      emails = for n <- 1..51, do: "user-#{n}@example.com"

      Req.Test.stub(Postmark, fn conn ->
        conn = Plug.Conn.fetch_query_params(conn)
        {:ok, body, conn} = Plug.Conn.read_body(conn)
        %{"Suppressions" => suppressions} = Jason.decode!(body)
        send(test_pid, {:chunk_size, length(suppressions)})

        Req.Test.json(
          conn,
          %{"Suppressions" => Enum.map(suppressions, &Map.put(&1, "Status", "Deleted"))}
        )
      end)

      assert Postmark.delete_suppressions(emails) |> length() == 51

      # 51 emails, chunked at 50, on each of the 2 streams = 4 requests total
      assert_received {:chunk_size, 50}
      assert_received {:chunk_size, 50}
      assert_received {:chunk_size, 1}
      assert_received {:chunk_size, 1}
    end

    test "still confirms addresses Postmark refused (e.g. a spam complaint), only logging it" do
      Req.Test.stub(Postmark, fn conn ->
        Req.Test.json(conn, %{
          "Suppressions" => [
            %{"EmailAddress" => "[email protected]", "Status" => "Deleted"},
            %{
              "EmailAddress" => "[email protected]",
              "Status" => "Failed",
              "Message" => "SpamComplaint suppressions cannot be deleted"
            }
          ]
        })
      end)

      assert Postmark.delete_suppressions(["[email protected]", "[email protected]"]) == [
               "[email protected]",
               "[email protected]"
             ]
    end

    test "does not confirm a chunk whose call errored outright on any stream" do
      Req.Test.stub(Postmark, fn conn ->
        case conn.request_path do
          "/message-streams/outbound/suppressions/delete" ->
            Req.Test.json(conn, %{
              "Suppressions" => [%{"EmailAddress" => "[email protected]", "Status" => "Deleted"}]
            })

          "/message-streams/priority/suppressions/delete" ->
            conn |> Plug.Conn.put_status(500) |> Req.Test.json(%{"Message" => "boom"})
        end
      end)

      assert Postmark.delete_suppressions(["[email protected]"]) == []
    end

    test "only leaves out the chunk that failed, not unrelated chunks" do
      ok_emails = for n <- 1..50, do: "ok-#{n}@example.com"
      failing_email = "[email protected]"

      Req.Test.stub(Postmark, fn conn ->
        conn = Plug.Conn.fetch_query_params(conn)
        {:ok, body, conn} = Plug.Conn.read_body(conn)
        %{"Suppressions" => suppressions} = Jason.decode!(body)

        if Enum.any?(suppressions, &(&1["EmailAddress"] == failing_email)) do
          conn |> Plug.Conn.put_status(500) |> Req.Test.json(%{"Message" => "boom"})
        else
          Req.Test.json(
            conn,
            %{"Suppressions" => Enum.map(suppressions, &Map.put(&1, "Status", "Deleted"))}
          )
        end
      end)

      confirmed = Postmark.delete_suppressions(ok_emails ++ [failing_email])

      assert Enum.sort(confirmed) == Enum.sort(ok_emails)
      refute failing_email in confirmed
    end
  end

  describe "backfill_suppressions/0" do
    test "upserts a suppression for every entry found, across both streams" do
      Req.Test.stub(Postmark, fn conn ->
        entries =
          case conn.request_path do
            "/message-streams/outbound/suppressions/dump" ->
              [
                %{
                  "EmailAddress" => "[email protected]",
                  "SuppressionReason" => "HardBounce",
                  "Origin" => "Recipient"
                },
                %{
                  "EmailAddress" => "[email protected]",
                  "SuppressionReason" => "SpamComplaint",
                  "Origin" => "Recipient"
                }
              ]

            "/message-streams/priority/suppressions/dump" ->
              [
                %{
                  "EmailAddress" => "[email protected]",
                  "SuppressionReason" => "ManualSuppression",
                  "Origin" => "Admin"
                }
              ]
          end

        Req.Test.json(conn, %{"Suppressions" => entries})
      end)

      assert %{processed: 3, distinct_addresses: 3, upsert_errors: 0, fetch_errors: 0} =
               Postmark.backfill_suppressions()

      assert EmailSuppressions.suppressed?("[email protected]")
      assert EmailSuppressions.suppressed?("[email protected]")
      assert EmailSuppressions.suppressed?("[email protected]")

      hard = Repo.get_by!(Plausible.EmailSuppression, email: "[email protected]")
      assert hard.reason == :hard_bounce
      assert hard.source == :backfill
      assert hard.details == "Postmark suppression (origin: Recipient)"

      complainer = Repo.get_by!(Plausible.EmailSuppression, email: "[email protected]")
      assert complainer.reason == :spam_complaint

      manual = Repo.get_by!(Plausible.EmailSuppression, email: "[email protected]")
      assert manual.reason == :manual
    end

    test "maps a recipient-originated ManualSuppression to :unsubscribe" do
      Req.Test.stub(Postmark, fn conn ->
        entries =
          case conn.request_path do
            "/message-streams/outbound/suppressions/dump" ->
              [
                %{
                  "EmailAddress" => "[email protected]",
                  "SuppressionReason" => "ManualSuppression",
                  "Origin" => "Recipient"
                }
              ]

            "/message-streams/priority/suppressions/dump" ->
              []
          end

        Req.Test.json(conn, %{"Suppressions" => entries})
      end)

      assert %{upsert_errors: 0} = Postmark.backfill_suppressions()

      suppression = Repo.get_by!(Plausible.EmailSuppression, email: "[email protected]")
      assert suppression.reason == :unsubscribe
    end

    test "maps a customer/admin-originated ManualSuppression to :manual" do
      Req.Test.stub(Postmark, fn conn ->
        entries =
          case conn.request_path do
            "/message-streams/outbound/suppressions/dump" ->
              [
                %{
                  "EmailAddress" => "[email protected]",
                  "SuppressionReason" => "ManualSuppression",
                  "Origin" => "Customer"
                }
              ]

            "/message-streams/priority/suppressions/dump" ->
              []
          end

        Req.Test.json(conn, %{"Suppressions" => entries})
      end)

      assert %{upsert_errors: 0} = Postmark.backfill_suppressions()

      suppression =
        Repo.get_by!(Plausible.EmailSuppression, email: "[email protected]")

      assert suppression.reason == :manual
    end

    test "counts fetch failures separately, per stream" do
      Req.Test.stub(Postmark, fn conn ->
        case conn.request_path do
          "/message-streams/outbound/suppressions/dump" ->
            conn |> Plug.Conn.put_status(500) |> Req.Test.json(%{"Message" => "boom"})

          "/message-streams/priority/suppressions/dump" ->
            Req.Test.json(conn, %{"Suppressions" => []})
        end
      end)

      assert %{processed: 0, distinct_addresses: 0, upsert_errors: 0, fetch_errors: 1} =
               Postmark.backfill_suppressions()
    end

    test "counts distinct_addresses, deduping the same address across streams" do
      Req.Test.stub(Postmark, fn conn ->
        entry = %{
          "EmailAddress" => "[email protected]",
          "SuppressionReason" => "HardBounce",
          "Origin" => "Recipient"
        }

        Req.Test.json(conn, %{"Suppressions" => [entry]})
      end)

      assert %{processed: 2, distinct_addresses: 1, upsert_errors: 0, fetch_errors: 0} =
               Postmark.backfill_suppressions()

      assert EmailSuppressions.suppressed?("[email protected]")
      assert Repo.aggregate(Plausible.EmailSuppression, :count) == 1
    end

    test "counts email citext variants as the same address" do
      Req.Test.stub(Postmark, fn conn ->
        entries =
          case conn.request_path do
            "/message-streams/outbound/suppressions/dump" ->
              [
                %{
                  "EmailAddress" => "[email protected]",
                  "SuppressionReason" => "HardBounce",
                  "Origin" => "Recipient"
                }
              ]

            "/message-streams/priority/suppressions/dump" ->
              [
                %{
                  "EmailAddress" => "[email protected]",
                  "SuppressionReason" => "HardBounce",
                  "Origin" => "Recipient"
                }
              ]
          end

        Req.Test.json(conn, %{"Suppressions" => entries})
      end)

      assert %{processed: 2, distinct_addresses: 1, upsert_errors: 0, fetch_errors: 0} =
               Postmark.backfill_suppressions()

      assert Repo.aggregate(Plausible.EmailSuppression, :count) == 1
    end

    test "for multiple entries, the most recent one wins" do
      Req.Test.stub(Postmark, fn conn ->
        entries =
          case conn.request_path do
            "/message-streams/outbound/suppressions/dump" ->
              [
                %{
                  "EmailAddress" => "[email protected]",
                  "SuppressionReason" => "HardBounce",
                  "Origin" => "Recipient",
                  "CreatedAt" => "2026-01-01T00:00:00Z"
                }
              ]

            "/message-streams/priority/suppressions/dump" ->
              [
                %{
                  "EmailAddress" => "[email protected]",
                  "SuppressionReason" => "ManualSuppression",
                  "Origin" => "Admin",
                  "CreatedAt" => "2026-06-01T00:00:00Z"
                }
              ]
          end

        Req.Test.json(conn, %{"Suppressions" => entries})
      end)

      assert %{distinct_addresses: 1} = Postmark.backfill_suppressions()

      suppression = Repo.get_by!(Plausible.EmailSuppression, email: "[email protected]")
      assert suppression.reason == :manual
      assert suppression.details == "Postmark suppression (origin: Admin)"
    end

    test "spam complaint always wins over another reason" do
      Req.Test.stub(Postmark, fn conn ->
        entries =
          case conn.request_path do
            "/message-streams/outbound/suppressions/dump" ->
              [
                %{
                  "EmailAddress" => "[email protected]",
                  "SuppressionReason" => "HardBounce",
                  "Origin" => "Recipient",
                  "CreatedAt" => "2026-06-01T00:00:00Z"
                }
              ]

            "/message-streams/priority/suppressions/dump" ->
              [
                %{
                  "EmailAddress" => "[email protected]",
                  "SuppressionReason" => "SpamComplaint",
                  "Origin" => "Recipient",
                  "CreatedAt" => "2026-01-01T00:00:00Z"
                }
              ]
          end

        Req.Test.json(conn, %{"Suppressions" => entries})
      end)

      assert %{distinct_addresses: 1} = Postmark.backfill_suppressions()

      suppression = Repo.get_by!(Plausible.EmailSuppression, email: "[email protected]")
      assert suppression.reason == :spam_complaint
    end

    test "a missing CreatedAt does not crash the backfill" do
      Req.Test.stub(Postmark, fn conn ->
        entries =
          case conn.request_path do
            "/message-streams/outbound/suppressions/dump" ->
              [
                %{
                  "EmailAddress" => "[email protected]",
                  "SuppressionReason" => "HardBounce",
                  "Origin" => "Recipient"
                }
              ]

            "/message-streams/priority/suppressions/dump" ->
              []
          end

        Req.Test.json(conn, %{"Suppressions" => entries})
      end)

      assert %{distinct_addresses: 1, upsert_errors: 0} = Postmark.backfill_suppressions()
      assert EmailSuppressions.suppressed?("[email protected]")
    end

    test "falls back to :manual for an unrecognized SuppressionReason" do
      Req.Test.stub(Postmark, fn conn ->
        entries =
          case conn.request_path do
            "/message-streams/outbound/suppressions/dump" ->
              [
                %{
                  "EmailAddress" => "[email protected]",
                  "SuppressionReason" => "SomethingNew",
                  "Origin" => "Recipient"
                }
              ]

            "/message-streams/priority/suppressions/dump" ->
              []
          end

        Req.Test.json(conn, %{"Suppressions" => entries})
      end)

      assert %{upsert_errors: 0} = Postmark.backfill_suppressions()

      suppression = Repo.get_by!(Plausible.EmailSuppression, email: "[email protected]")
      assert suppression.reason == :manual
    end
  end
end