payload-api 0.4.1 → 0.6.0

data/spec/payload/arm/attr_spec.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "payload"
+require "payload/arm/attr"
+
+RSpec.describe Payload::AttrRoot do
+  let(:root) { described_class.new }
+
+  describe "attribute access" do
+    it "returns an Attr for any method name" do
+      expect(root.id).to be_a(Payload::Attr)
+      expect(root.id.to_s).to eq("id")
+      expect(root.created_at).to be_a(Payload::Attr)
+      expect(root.created_at.to_s).to eq("created_at")
+    end
+
+    it "returns an Attr for chained property access (non-callable names stay as nested key)" do
+      chained = root.sender.account_id
+      expect(chained).to be_a(Payload::Attr)
+      expect(chained.to_s).to eq("sender[account_id]")
+    end
+
+    it "treats no-arg access as nested attribute" do
+      expect(root.created_at.month.to_s).to eq("created_at[month]")
+      expect(root.created_at.year.to_s).to eq("created_at[year]")
+    end
+
+    it "supports pl.attr.created_at(:month) style (function as symbol arg)" do
+      expect(root.created_at(:month).to_s).to eq("month(created_at)")
+      expect(root.created_at(:year).to_s).to eq("year(created_at)")
+      expect(root.amount(:sum).to_s).to eq("sum(amount)")
+    end
+
+    it "supports nested attr with symbol: pl.attr.totals.total(:sum) => sum(totals[total])" do
+      expect(root.totals.total(:sum).to_s).to eq("sum(totals[total])")
+    end
+  end
+end
+
+RSpec.describe Payload::Attr do
+  describe "simple attribute" do
+    it "has key and to_s as the param when no parent" do
+      attr = Payload::Attr.new("amount")
+      expect(attr.key).to eq("amount")
+      expect(attr.to_s).to eq("amount")
+    end
+  end
+
+  describe "nested attribute" do
+    it "builds key and to_s as parent[param]" do
+      parent = Payload::Attr.new("totals")
+      attr = Payload::Attr.new("total", parent)
+      expect(attr.key).to eq("totals[total]")
+      expect(attr.to_s).to eq("totals[total]")
+    end
+  end
+
+  describe "function form (after .call)" do
+    it "serializes as name(parent_key) when marked as method" do
+      parent = Payload::Attr.new("created_at")
+      attr = Payload::Attr.new("month", parent)
+      attr.call
+      expect(attr.to_s).to eq("month(created_at)")
+    end
+
+    it "serializes nested path in function form" do
+      parent = Payload::Attr.new("total", Payload::Attr.new("totals"))
+      attr = Payload::Attr.new("sum", parent)
+      attr.call
+      expect(attr.to_s).to eq("sum(totals[total])")
+    end
+
+    it "raises when chaining after a method" do
+      parent = Payload::Attr.new("created_at")
+      attr = Payload::Attr.new("month", parent)
+      attr.call
+      expect { attr.day }.to raise_error(RuntimeError, /cannot get attr of method/)
+    end
+  end
+
+  describe "#strip" do
+    it "returns to_s.strip so Attr works with request.select(*args, **data) and args.map(&:strip)" do
+      inner = Payload::Attr.new("created_at")
+      year_attr = Payload::Attr.new("year", inner)
+      year_attr.call
+      expect(year_attr.strip).to eq("year(created_at)")
+    end
+  end
+
+  describe "comparisons (return ARMFilter subclasses)" do
+    let(:attr_amount) { Payload::Attr.new("amount") }
+    let(:attr_status) { Payload::Attr.new("status") }
+
+    it "== returns ARMEqual with correct attr and opval" do
+      f = attr_status == "processed"
+      expect(f).to be_a(Payload::ARMEqual)
+      expect(f.attr).to eq("status")
+      expect(f.opval).to eq("processed")
+    end
+
+    it "!= returns ARMNotEqual with ! prefix" do
+      f = attr_status != "draft"
+      expect(f).to be_a(Payload::ARMNotEqual)
+      expect(f.attr).to eq("status")
+      expect(f.opval).to eq("!draft")
+    end
+
+    it "> returns ARMGreaterThan" do
+      f = attr_amount > 100
+      expect(f).to be_a(Payload::ARMGreaterThan)
+      expect(f.attr).to eq("amount")
+      expect(f.opval).to eq(">100")
+    end
+
+    it "< returns ARMLessThan" do
+      f = attr_amount < 500
+      expect(f).to be_a(Payload::ARMLessThan)
+      expect(f.opval).to eq("<500")
+    end
+
+    it ">= returns ARMGreaterThanEqual" do
+      f = attr_amount >= 100
+      expect(f).to be_a(Payload::ARMGreaterThanEqual)
+      expect(f.opval).to eq(">=100")
+    end
+
+    it "<= returns ARMLessThanEqual" do
+      f = attr_amount <= 100
+      expect(f).to be_a(Payload::ARMLessThanEqual)
+      expect(f.opval).to eq("<=100")
+    end
+
+    it "contains returns ARMContains with ?* op" do
+      attr = Payload::Attr.new("description")
+      f = attr.contains("INV -")
+      expect(f).to be_a(Payload::ARMContains)
+      expect(f.attr).to eq("description")
+      expect(f.opval).to eq("?*INV -")
+    end
+
+    it "comparisons use Attr key for nested paths" do
+      nested = Payload::Attr.new("total", Payload::Attr.new("totals"))
+      f = nested > 0
+      expect(f.attr).to eq("totals[total]")
+      expect(f.opval).to eq(">0")
+    end
+  end
+
+  describe "Attr class-level (Payload::Attr.name)" do
+    it "returns Attr via method_missing" do
+      expect(Payload::Attr.created_at).to be_a(Payload::Attr)
+      expect(Payload::Attr.created_at.to_s).to eq("created_at")
+    end
+  end
+end
+
+RSpec.describe Payload::ARMFilter do
+  describe "#| (OR)" do
+    it "combines two filters on the same attribute and returns ARMEqual with joined opval" do
+      left = Payload::ARMGreaterThan.new(Payload::Attr.amount, 100)
+      right = Payload::ARMLessThan.new(Payload::Attr.amount, 50)
+      combined = left | right
+      expect(combined).to be_a(Payload::ARMEqual)
+      expect(combined.attr).to eq("amount")
+      expect(combined.opval).to eq(">100|<50")
+    end
+
+    it "raises TypeError when other is not an ARMFilter" do
+      f = Payload::ARMEqual.new(Payload::Attr.status, "active")
+      expect { f | "invalid" }.to raise_error(TypeError, /invalid type/)
+    end
+
+    it "raises ArgumentError when attributes differ" do
+      f1 = Payload::ARMEqual.new(Payload::Attr.status, "active")
+      f2 = Payload::ARMEqual.new(Payload::Attr.type, "payment")
+      expect { f1 | f2 }.to raise_error(ArgumentError, /only works on the same attribute/)
+    end
+  end
+
+  describe "filter subclasses op values" do
+    it "ARMEqual has empty op" do
+      f = Payload::ARMEqual.new("status", "active")
+      expect(f.opval).to eq("active")
+    end
+
+    it "ARMNotEqual has ! prefix" do
+      f = Payload::ARMNotEqual.new("status", "draft")
+      expect(f.opval).to eq("!draft")
+    end
+
+    it "ARMGreaterThan has > prefix" do
+      f = Payload::ARMGreaterThan.new("amount", 100)
+      expect(f.opval).to eq(">100")
+    end
+
+    it "ARMLessThan has < prefix" do
+      f = Payload::ARMLessThan.new("amount", 200)
+      expect(f.opval).to eq("<200")
+    end
+
+    it "ARMGreaterThanEqual has >= prefix" do
+      f = Payload::ARMGreaterThanEqual.new("amount", 100)
+      expect(f.opval).to eq(">=100")
+    end
+
+    it "ARMLessThanEqual has <= prefix" do
+      f = Payload::ARMLessThanEqual.new("amount", 100)
+      expect(f.opval).to eq("<=100")
+    end
+
+    it "ARMContains has ?* prefix" do
+      f = Payload::ARMContains.new("email", "example.com")
+      expect(f.opval).to eq("?*example.com")
+    end
+  end
+end

data/spec/payload/arm/object_spec.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "payload"
+require "payload/arm/object"
+
+RSpec.describe Payload::ARMObject do
+  describe "method_missing (attribute access)" do
+    let(:session) { Payload::Session.new("test_key", "https://api.test.com", "v2") }
+
+    it "returns value for present key" do
+      obj = Payload::Invoice.new({ "id" => "inv_1", "amount" => 100 }, session)
+      expect(obj.id).to eq("inv_1")
+      expect(obj.amount).to eq(100)
+    end
+
+    it "raises NoMethodError for missing key (strict behavior preserved)" do
+      obj = Payload::Invoice.new({ "id" => "inv_1" }, session)
+      expect { obj.nonexistent_key }.to raise_error(NoMethodError, /nonexistent_key/)
+      expect { obj.amount }.to raise_error(NoMethodError, /amount/)
+    end
+
+    it "strips trailing = for setter-like names and returns value" do
+      obj = Payload::Account.new({ "name" => "Acme" }, session)
+      expect(obj.name).to eq("Acme")
+    end
+  end
+
+  describe "#json" do
+    let(:session) { Payload::Session.new("test_key", "https://api.test.com", "v2") }
+
+    it "returns same as to_json" do
+      obj = Payload::Invoice.new({ "id" => "inv_1", "object" => "invoice" }, session)
+      expect(obj.json).to eq(obj.to_json)
+      expect(obj.json).to include("inv_1")
+      expect(obj.json).to include("invoice")
+    end
+  end
+
+  describe ".order_by, .limit, .offset" do
+    it "delegates to ARMRequest and returns chainable request" do
+      req = Payload::Invoice.order_by("created_at")
+      expect(req).to be_a(Payload::ARMRequest)
+      expect(req.instance_variable_get(:@order_by)).to include("created_at")
+
+      req = Payload::Invoice.limit(10)
+      expect(req.instance_variable_get(:@limit)).to eq(10)
+
+      req = Payload::Invoice.offset(20)
+      expect(req.instance_variable_get(:@offset)).to eq(20)
+    end
+  end
+
+  describe ".select" do
+    it "delegates to ARMRequest and sets fields filter" do
+      req = Payload::Invoice.select("id", "amount")
+      expect(req).to be_a(Payload::ARMRequest)
+      expect(req.instance_variable_get(:@filters)["fields"]).to eq("id,amount")
+    end
+  end
+
+  describe "#[] (bracket access)" do
+    let(:session) { Payload::Session.new("test_key", "https://api.test.com", "v2") }
+
+    it "returns value for string key" do
+      obj = Payload::Invoice.new({ "id" => "inv_1", "status" => "open" }, session)
+      expect(obj["id"]).to eq("inv_1")
+      expect(obj["status"]).to eq("open")
+    end
+
+    it "returns value for symbol key (data keys are stored as strings)" do
+      obj = Payload::Invoice.new({ "id" => "inv_1" }, session)
+      expect(obj[:id]).to eq("inv_1")
+    end
+
+    it "returns nil for missing key" do
+      obj = Payload::Invoice.new({ "id" => "inv_1" }, session)
+      expect(obj["missing"]).to be_nil
+    end
+  end
+
+  describe "#to_json" do
+    let(:session) { Payload::Session.new("test_key", "https://api.test.com", "v2") }
+
+    it "includes @data in JSON output" do
+      obj = Payload::Invoice.new({ "id" => "inv_1", "object" => "invoice", "amount" => 99 }, session)
+      json = obj.to_json
+      expect(json).to include("inv_1")
+      expect(json).to include("invoice")
+      expect(json).to include("99")
+    end
+
+    it "merges class poly when present" do
+      obj = Payload::Payment.new({ "id" => "txn_1", "object" => "transaction", "type" => "payment" }, session)
+      json = obj.to_json
+      expect(json).to include("payment")
+      expect(json).to include("txn_1")
+    end
+  end
+
+  describe "#respond_to_missing?" do
+    let(:session) { Payload::Session.new("test_key", "https://api.test.com", "v2") }
+
+    it "returns true for key present in data" do
+      obj = Payload::Invoice.new({ "id" => "inv_1", "amount" => 100 }, session)
+      expect(obj.respond_to?(:id)).to be true
+      expect(obj.respond_to?(:amount)).to be true
+    end
+
+    it "returns false for key missing from data (so method_missing will call super)" do
+      obj = Payload::Invoice.new({ "id" => "inv_1" }, session)
+      expect(obj.respond_to?(:nonexistent_key)).to be false
+    end
+  end
+end

data/spec/payload/arm/request_format_integration_spec.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "payload"
+require "payload/arm/object"
+require_relative "../../support/helpers"
+
+RSpec.describe "confirm request format is valid" do
+  include_context "test helpers"
+
+  [1, 2].each do |api_version|
+    context "API v#{api_version}" do
+      let(:session) { Payload::Session.new(Payload.api_key, Payload.api_url, api_version) }
+      let(:pl) { session }
+
+      context "date functions" do
+        it "filter with year(attr) ==" do
+          results = pl.Transaction.filter_by(
+            pl.attr.type == "payment",
+            pl.attr.created_at(:year) == Time.now.year
+          ).limit(5).all
+          expect(results).to be_an(Array)
+        end
+
+        it "filter with month(attr) ==" do
+          results = pl.Transaction.filter_by(
+            pl.attr.created_at(:month) == Time.now.month
+          ).limit(5).all
+          expect(results).to be_an(Array)
+        end
+
+        it "select with dayname(attr)" do
+          results = pl.Transaction.select(
+            pl.attr.id,
+            pl.attr.created_at(:dayname)
+          ).limit(5).all
+          expect(results).to be_an(Array)
+        end
+
+        it "group_by year(attr) with count" do
+          yearly = pl.Transaction.select(
+            pl.attr.created_at(:year),
+            pl.attr.id(:count)
+          ).group_by(pl.attr.created_at(:year)).limit(5).all
+          expect(yearly).to be_an(Array)
+        end
+      end
+
+      context "order_by" do
+        it "order_by ascending" do
+          results = pl.Transaction.select(pl.attr.id).order_by(pl.attr.created_at).limit(5).all
+          expect(results).to be_an(Array)
+        end
+
+        it "order_by descending" do
+          results = pl.Transaction.select(pl.attr.id).order_by(pl.attr.created_at(:desc)).limit(5).all
+          expect(results).to be_an(Array)
+        end
+      end
+
+      context "limit, offset, and range" do
+        it "limit" do
+          results = pl.Transaction.select(pl.attr.id).limit(2).all
+          expect(results).to be_an(Array)
+          expect(results.length).to be <= 2
+        end
+
+        it "offset" do
+          page1 = pl.Transaction.select(pl.attr.id).limit(3).offset(0).all
+          page2 = pl.Transaction.select(pl.attr.id).limit(3).offset(3).all
+          expect(page1).to be_an(Array)
+          expect(page2).to be_an(Array)
+          expect(page1.length).to be <= 3
+          expect(page2.length).to be <= 3
+        end
+
+        it "range operator []" do
+          results = pl.Transaction.select(pl.attr.id)[0..2]
+          expect(results).to be_an(Array)
+          expect(results.length).to be <= 3
+        end
+      end
+
+      context "nested attr" do
+        it "select with nested attr (sender.account_id)" do
+          results = pl.Transaction.select(
+            pl.attr.id,
+            pl.attr.sender.account_id
+          ).filter_by(pl.attr.type == "payment").limit(5).all
+          expect(results).to be_an(Array)
+        end
+      end
+
+      context "filter operators" do
+        it "filter with >" do
+          results = pl.Transaction.filter_by(
+            pl.attr.type == "payment",
+            pl.attr.amount > 0
+          ).select(pl.attr.id, pl.attr.amount).limit(5).all
+          expect(results).to be_an(Array)
+        end
+
+        it "filter with <" do
+          results = pl.Transaction.filter_by(
+            pl.attr.type == "payment",
+            pl.attr.amount < 1_000_000
+          ).select(pl.attr.id, pl.attr.amount).limit(5).all
+          expect(results).to be_an(Array)
+        end
+
+        it "filter with !=" do
+          results = pl.Transaction.filter_by(
+            pl.attr.type != "nonexistent_type"
+          ).select(pl.attr.id, pl.attr.type).limit(5).all
+          expect(results).to be_an(Array)
+        end
+
+        it "filter with contains" do
+          results = pl.Transaction.filter_by(
+            pl.attr.type == "payment",
+            pl.attr.description.contains("")
+          ).select(pl.attr.id, pl.attr.description).limit(5).all
+          expect(results).to be_an(Array)
+        end
+      end
+
+      context "filter OR (chained conditions)" do
+        it "filter with OR (|) on same attribute" do
+          or_filter = (pl.attr.amount > 0) | (pl.attr.amount < 1_000_000)
+          results = pl.Transaction.filter_by(
+            pl.attr.type == "payment",
+            or_filter
+          ).select(pl.attr.id, pl.attr.amount).limit(5).all
+          expect(results).to be_an(Array)
+        end
+      end
+
+      context "group_by and aggregates" do
+        it "group_by with sum and count" do
+          results = pl.Transaction.select(
+            pl.attr.type,
+            pl.attr.amount(:sum),
+            pl.attr.id(:count)
+          ).filter_by(pl.attr.type == "payment").group_by(pl.attr.type).limit(5).all
+          expect(results).to be_an(Array)
+        end
+
+        it "group_by month(attr) with sum and count" do
+          results = pl.Transaction.select(
+            pl.attr.created_at(:month),
+            pl.attr.amount(:sum),
+            pl.attr.id(:count)
+          ).filter_by(pl.attr.type == "payment").group_by(pl.attr.created_at(:month)).limit(5).all
+          expect(results).to be_an(Array)
+        end
+
+        it "group_by year(attr) with count" do
+          results = pl.Transaction.select(
+            pl.attr.created_at(:year),
+            pl.attr.id(:count)
+          ).filter_by(pl.attr.type == "payment").group_by(pl.attr.created_at(:year)).limit(5).all
+          expect(results).to be_an(Array)
+        end
+      end
+    end
+  end
+end