payload-api 0.5.0 → 0.6.1

data/spec/payload/arm/arm_request_query_spec.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "payload"
+require "payload/arm/object"
+
+RSpec.describe Payload::ARMRequest do
+  describe "#group_by" do
+    let(:instance) { described_class.new(Payload::Invoice, nil) }
+
+    it "appends to group_by and returns self" do
+      year_attr = Payload::Attr.new("year", Payload::Attr.new("created_at"))
+      year_attr.call
+      result = instance.group_by(year_attr, Payload::Attr.status)
+      expect(result).to be(instance)
+      expect(instance.instance_variable_get(:@group_by).map(&:to_s)).to eq(["year(created_at)", "status"])
+    end
+
+    it "includes group_by in request params when all() is called" do
+      Payload::api_key = "test_key"
+      instance.instance_variable_set(:@cls, Payload::Invoice)
+
+      expect(instance).to receive(:_execute_request) do |_http, request|
+        query = request.path.split("?")[1]
+        expect(query).to include("group_by%5B0%5D=") # group_by[0]=
+        expect(query).to include("group_by%5B1%5D=") # group_by[1]=
+        QuerySpecMockResponse.new('{"object":"list","values":[]}')
+      end
+
+      instance.group_by("year(created_at)", "status").all()
+    end
+  end
+
+  describe "#order_by" do
+    let(:instance) { described_class.new(Payload::Account, nil) }
+
+    it "appends to order_by and returns self" do
+      result = instance.order_by("created_at", "desc(id)")
+      expect(result).to be(instance)
+      expect(instance.instance_variable_get(:@order_by)).to eq(["created_at", "desc(id)"])
+    end
+
+    it "includes order_by in request params when all() is called" do
+      Payload::api_key = "test_key"
+      instance.instance_variable_set(:@cls, Payload::Account)
+
+      expect(instance).to receive(:_execute_request) do |_http, request|
+        query = request.path.split("?")[1]
+        expect(query).to include("order_by%5B0%5D=created_at")
+        expect(query).to include("order_by%5B1%5D=desc%28id%29")
+        QuerySpecMockResponse.new('{"object":"list","values":[]}')
+      end
+
+      instance.order_by("created_at", "desc(id)").all()
+    end
+  end
+
+  describe "#limit and #offset" do
+    let(:instance) { described_class.new(Payload::Account, nil) }
+
+    it "sets limit and offset and returns self" do
+      result = instance.limit(10).offset(20)
+      expect(result).to be(instance)
+      expect(instance.instance_variable_get(:@limit)).to eq(10)
+      expect(instance.instance_variable_get(:@offset)).to eq(20)
+    end
+
+    it "includes limit and offset in request params when all() is called" do
+      Payload::api_key = "test_key"
+      instance.instance_variable_set(:@cls, Payload::Account)
+
+      expect(instance).to receive(:_execute_request) do |_http, request|
+        query = request.path.split("?")[1]
+        expect(query).to include("limit=10")
+        expect(query).to include("offset=20")
+        QuerySpecMockResponse.new('{"object":"list","values":[]}')
+      end
+
+      instance.limit(10).offset(20).all()
+    end
+  end
+
+  describe "#request_params" do
+    it "merges filters, filter_objects, group_by, order_by, limit, offset into query params" do
+      instance = described_class.new(Payload::Transaction, nil)
+      instance.instance_variable_set(:@filters, { "fields" => "id,amount" })
+      instance.instance_variable_set(:@group_by, ["status"])
+      instance.instance_variable_set(:@order_by, ["desc(created_at)"])
+      instance.instance_variable_set(:@limit, 5)
+      instance.instance_variable_set(:@offset, 10)
+
+      filter_obj = Payload::ARMGreaterThan.new(Payload::Attr.amount, 100)
+      instance.instance_variable_set(:@filter_objects, [filter_obj])
+
+      params = instance.request_params
+
+      expect(params["fields"]).to eq("id,amount")
+      expect(params["group_by[0]"]).to eq("status")
+      expect(params["order_by[0]"]).to eq("desc(created_at)")
+      expect(params["limit"]).to eq("5")
+      expect(params["offset"]).to eq("10")
+      expect(params[filter_obj.attr]).to eq(filter_obj.opval)
+    end
+
+    it "is encoded as URL query string in _request (url.query = URI.encode_www_form(params))" do
+      Payload::api_key = "test_key"
+      session = Payload::Session.new("test_key", "https://api.test.com", "v2")
+      instance = described_class.new(Payload::Invoice, session)
+      instance.select("id", "status").filter_by(session.attr.status == "open").order_by("created_at").limit(5).offset(1)
+
+      expected_params = instance.request_params.dup
+
+      expect(instance).to receive(:_execute_request) do |_http, request|
+        query_str = request.path.split("?", 2)[1]
+        expect(query_str).not_to be_nil
+        decoded = URI.decode_www_form(query_str || "").to_h
+        expected_params.each do |key, value|
+          expect(decoded[key]).to eq(value.to_s)
+        end
+        expect(decoded).to include("fields" => "id,status", "limit" => "5", "offset" => "1")
+        expect(decoded.keys).to include("status", "order_by[0]")
+        QuerySpecMockResponse.new('{"object":"list","values":[]}')
+      end
+
+      instance.all()
+    end
+  end
+
+  describe "#[] (slice)" do
+    let(:instance) { described_class.new(Payload::Account, nil) }
+
+    it "raises TypeError for non-Range key" do
+      expect { instance["foo"] }.to raise_error(TypeError, /invalid key or index/)
+      expect { instance[5] }.to raise_error(TypeError, /invalid key or index/)
+    end
+
+    it "raises ArgumentError for negative begin" do
+      expect { instance[-1..10] }.to raise_error(ArgumentError, /Negative slice indices not supported/)
+    end
+
+    it "raises ArgumentError for negative end" do
+      expect { instance[0..-5] }.to raise_error(ArgumentError, /Negative slice indices not supported/)
+    end
+
+    it "calls offset(begin).limit(size).all() for a range and returns result" do
+      Payload::api_key = "test_key"
+      instance.instance_variable_set(:@cls, Payload::Account)
+
+      expect(instance).to receive(:_execute_request) do |_http, request|
+        query = request.path.split("?")[1]
+        expect(query).to include("offset=10")
+        expect(query).to include("limit=10")
+        QuerySpecMockResponse.new('{"object":"list","values":[{"id":"acct_1","object":"customer"}]}')
+      end
+
+      result = instance[10..19]
+      expect(result).to be_an(Array)
+      expect(result.size).to eq(1)
+      expect(result[0].id).to eq("acct_1")
+    end
+  end
+
+  describe "#filter_by with pl.attr filter objects" do
+    it "extracts ARM filter objects and merges their attr/opval into request params" do
+      session = Payload::Session.new("test_key", "https://api.test.com", "v2")
+      instance = described_class.new(Payload::Transaction, session)
+      pl = session
+      filter_expr = (pl.attr.amount > 100) | (pl.attr.amount < 200)
+
+      instance.filter_by(filter_expr)
+
+      expect(instance.instance_variable_get(:@filter_objects)).to include(be_a(Payload::ARMFilter))
+      params = instance.request_params
+      expect(params.keys).to include(filter_expr.attr)
+      expect(params[filter_expr.attr]).to eq(filter_expr.opval)
+    end
+
+    it "builds GET request with filter object serialized in query string" do
+      Payload::api_key = "test_key"
+      session = Payload::Session.new("test_key", "https://api.test.com", "v2")
+      instance = described_class.new(Payload::Transaction, session)
+      filter_expr = session.attr.amount > 100
+
+      instance.filter_by(filter_expr)
+
+      expect(instance).to receive(:_execute_request) do |_http, request|
+        query = request.path.split("?")[1]
+        expect(query).to include("amount=")
+        expect(query).to include("%3E100") # URL-encoded ">100"
+        QuerySpecMockResponse.new('{"object":"list","values":[]}')
+      end
+
+      instance.all()
+    end
+  end
+
+  describe "#filter_by with multiple filters" do
+    it "accumulates multiple filter objects and merges keyword filters into @filters" do
+      instance = described_class.new(Payload::Invoice, nil)
+      f1 = Payload::ARMEqual.new(Payload::Attr.status, "open")
+      f2 = Payload::ARMGreaterThan.new(Payload::Attr.amount, 50)
+
+      instance.filter_by(f1).filter_by(f2).filter_by(custom_key: "value")
+
+      fo = instance.instance_variable_get(:@filter_objects)
+      expect(fo).to include(f1, f2)
+      params = instance.request_params
+      expect(params["status"]).to eq("open")
+      expect(params["amount"]).to eq(">50")
+      expect(instance.instance_variable_get(:@filters)[:custom_key]).to eq("value")
+    end
+  end
+end
+
+class QuerySpecMockResponse
+  def initialize(body = '{"object":"list","values":[]}')
+    @body = body
+  end
+
+  def code
+    "200"
+  end
+
+  def body
+    @body
+  end
+end

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