api_matchers 0.6.2 → 1.0.0

data/spec/api_matchers/pagination/be_paginated_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+RSpec.describe APIMatchers::Pagination::BePaginated do
+  describe "actual.to be_paginated" do
+    context "with pagination in meta" do
+      it "passes when meta has page" do
+        json = '{"data": [], "meta": {"page": 1, "per_page": 10}}'
+        expect(json).to be_paginated
+      end
+
+      it "passes when meta has total_count" do
+        json = '{"data": [], "meta": {"total_count": 100}}'
+        expect(json).to be_paginated
+      end
+
+      it "passes when meta has offset/limit" do
+        json = '{"data": [], "meta": {"offset": 0, "limit": 10}}'
+        expect(json).to be_paginated
+      end
+    end
+
+    context "with pagination links" do
+      it "passes when links has next" do
+        json = '{"data": [], "links": {"next": "/api/users?page=2"}}'
+        expect(json).to be_paginated
+      end
+
+      it "passes when links has prev" do
+        json = '{"data": [], "links": {"prev": "/api/users?page=1"}}'
+        expect(json).to be_paginated
+      end
+
+      it "passes when links has first/last" do
+        json = '{"data": [], "links": {"first": "/api/users?page=1", "last": "/api/users?page=10"}}'
+        expect(json).to be_paginated
+      end
+    end
+
+    context "with pagination at root level" do
+      it "passes when root has page" do
+        json = '{"items": [], "page": 1, "per_page": 10}'
+        expect(json).to be_paginated
+      end
+
+      it "passes when root has total" do
+        json = '{"items": [], "total": 100}'
+        expect(json).to be_paginated
+      end
+    end
+
+    context "when not paginated" do
+      it "fails when no pagination keys found" do
+        json = '{"data": [{"id": 1}]}'
+        expect {
+          expect(json).to be_paginated
+        }.to fail_with(/expected response to be paginated/)
+      end
+    end
+  end
+
+  describe "actual.not_to be_paginated" do
+    it "passes when not paginated" do
+      json = '{"data": [{"id": 1}]}'
+      expect(json).not_to be_paginated
+    end
+
+    it "fails when paginated" do
+      json = '{"data": [], "meta": {"page": 1}}'
+      expect {
+        expect(json).not_to be_paginated
+      }.to fail_with(/expected response NOT to be paginated/)
+    end
+  end
+
+  describe "with configuration" do
+    before do
+      APIMatchers.setup do |config|
+        config.response_body_method = :body
+        config.pagination_meta_path = 'pagination'
+      end
+    end
+
+    after do
+      APIMatchers.setup do |config|
+        config.response_body_method = nil
+        config.pagination_meta_path = nil
+      end
+    end
+
+    it "uses configured pagination_meta_path" do
+      response = OpenStruct.new(body: '{"data": [], "pagination": {"page": 1}}')
+      expect(response).to be_paginated
+    end
+  end
+end

data/spec/api_matchers/pagination/have_pagination_links_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+RSpec.describe APIMatchers::Pagination::HavePaginationLinks do
+  describe "actual.to have_pagination_links" do
+    context "with standard links" do
+      it "passes when specified links are present" do
+        json = '{"data": [], "links": {"next": "/page/2", "prev": "/page/1"}}'
+        expect(json).to have_pagination_links(:next, :prev)
+      end
+
+      it "passes when checking single link" do
+        json = '{"data": [], "links": {"next": "/page/2"}}'
+        expect(json).to have_pagination_links(:next)
+      end
+
+      it "fails when links are missing" do
+        json = '{"data": [], "links": {"next": "/page/2"}}'
+        expect {
+          expect(json).to have_pagination_links(:next, :prev)
+        }.to fail_with(/Missing: \["prev"\]/)
+      end
+    end
+
+    context "with various link names" do
+      it "passes with first/last links" do
+        json = '{"data": [], "links": {"first": "/page/1", "last": "/page/10"}}'
+        expect(json).to have_pagination_links(:first, :last)
+      end
+
+      it "treats previous as prev" do
+        json = '{"data": [], "links": {"previous": "/page/1"}}'
+        expect(json).to have_pagination_links(:prev)
+      end
+    end
+
+    context "when links path does not exist" do
+      it "fails with descriptive message" do
+        json = '{"data": []}'
+        expect {
+          expect(json).to have_pagination_links(:next)
+        }.to fail_with(/but no links were found/)
+      end
+    end
+  end
+
+  describe "actual.not_to have_pagination_links" do
+    it "passes when links are not present" do
+      json = '{"data": [], "links": {"self": "/current"}}'
+      expect(json).not_to have_pagination_links(:next, :prev)
+    end
+
+    it "fails when all specified links are present" do
+      json = '{"data": [], "links": {"next": "/page/2", "prev": "/page/1"}}'
+      expect {
+        expect(json).not_to have_pagination_links(:next, :prev)
+      }.to fail_with(/expected response NOT to have pagination links/)
+    end
+  end
+
+  describe "with configuration" do
+    before do
+      APIMatchers.setup do |config|
+        config.response_body_method = :body
+        config.pagination_links_path = '_links'
+      end
+    end
+
+    after do
+      APIMatchers.setup do |config|
+        config.response_body_method = nil
+        config.pagination_links_path = nil
+      end
+    end
+
+    it "uses configured pagination_links_path" do
+      response = OpenStruct.new(body: '{"data": [], "_links": {"next": "/page/2"}}')
+      expect(response).to have_pagination_links(:next)
+    end
+  end
+end

data/spec/api_matchers/pagination/have_total_count_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+RSpec.describe APIMatchers::Pagination::HaveTotalCount do
+  describe "actual.to have_total_count" do
+    context "with total in meta" do
+      it "passes when total matches" do
+        json = '{"data": [], "meta": {"total": 100}}'
+        expect(json).to have_total_count(100)
+      end
+
+      it "passes with total_count key" do
+        json = '{"data": [], "meta": {"total_count": 50}}'
+        expect(json).to have_total_count(50)
+      end
+
+      it "passes with totalCount key (camelCase)" do
+        json = '{"data": [], "meta": {"totalCount": 75}}'
+        expect(json).to have_total_count(75)
+      end
+
+      it "fails when count does not match" do
+        json = '{"data": [], "meta": {"total": 100}}'
+        expect {
+          expect(json).to have_total_count(50)
+        }.to fail_with(/expected total count to be 50. Got: 100/)
+      end
+    end
+
+    context "with total at root level" do
+      it "passes when total is at root" do
+        json = '{"items": [], "total": 100}'
+        expect(json).to have_total_count(100)
+      end
+
+      it "passes with count key at root" do
+        json = '{"items": [], "count": 25}'
+        expect(json).to have_total_count(25)
+      end
+    end
+
+    context "when total count is not found" do
+      it "fails with descriptive message" do
+        json = '{"data": []}'
+        expect {
+          expect(json).to have_total_count(100)
+        }.to fail_with(/but no total count field was found/)
+      end
+    end
+  end
+
+  describe "actual.not_to have_total_count" do
+    it "passes when count does not match" do
+      json = '{"data": [], "meta": {"total": 100}}'
+      expect(json).not_to have_total_count(50)
+    end
+
+    it "fails when count matches" do
+      json = '{"data": [], "meta": {"total": 100}}'
+      expect {
+        expect(json).not_to have_total_count(100)
+      }.to fail_with(/expected total count NOT to be 100, but it was/)
+    end
+  end
+
+  describe "with configuration" do
+    before do
+      APIMatchers.setup do |config|
+        config.response_body_method = :body
+        config.pagination_meta_path = 'pagination'
+      end
+    end
+
+    after do
+      APIMatchers.setup do |config|
+        config.response_body_method = nil
+        config.pagination_meta_path = nil
+      end
+    end
+
+    it "uses configured pagination_meta_path" do
+      response = OpenStruct.new(body: '{"data": [], "pagination": {"total": 100}}')
+      expect(response).to have_total_count(100)
+    end
+  end
+end

data/spec/api_matchers/response_body/base_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe APIMatchers::ResponseBody::Base do
-  let(:setup) { OpenStruct.new(:response_body_method => :body) }
-  subject { APIMatchers::ResponseBody::Base.new(setup: setup, expected_node: :status) }
+  subject { APIMatchers::ResponseBody::Base.new(expected_node: :status) }
 
   describe "#matches?" do
     it "should raise Not Implemented Error" do
@@ -13,8 +12,8 @@ RSpec.describe APIMatchers::ResponseBody::Base do
   end
 
   describe "#setup" do
-    it "should read from the initialize" do
-      expect(subject.setup).to equal setup
+    it "returns the global Setup class" do
+      expect(subject.setup).to eq APIMatchers::Core::Setup
     end
   end
 
@@ -28,6 +27,14 @@ RSpec.describe APIMatchers::ResponseBody::Base do
     let(:body) { { :foo => :bar}.to_json }
 
     context 'when have configuration' do
+      before do
+        APIMatchers.setup { |config| config.response_body_method = :body }
+      end
+
+      after do
+        APIMatchers.setup { |config| config.response_body_method = nil }
+      end
+
       it "should call the method when is config" do
         subject.actual = OpenStruct.new(:body => body)
         expect(subject.response_body).to eql body
@@ -35,8 +42,9 @@ RSpec.describe APIMatchers::ResponseBody::Base do
     end
 
     context 'when dont have configuration' do
-      let(:setup) { OpenStruct.new(:response_body_method => nil) }
-      subject { APIMatchers::ResponseBody::Base.new(setup: setup, expected_node: :status) }
+      before do
+        APIMatchers.setup { |config| config.response_body_method = nil }
+      end
 
       it "should return the actual when do not have config" do
         subject.actual = body
@@ -44,4 +52,4 @@ RSpec.describe APIMatchers::ResponseBody::Base do
       end
     end
   end
-end
+end

data/spec/api_matchers/response_body/have_json_node_spec.rb

@@ -275,4 +275,61 @@ RSpec.describe APIMatchers::ResponseBody::HaveJsonNode do
       }.to fail_with(%Q{expected to have node called: 'bar'. Got: '{"baz":"foo"}'})
     end
   end
+
+  describe "including" do
+    it "passes when array includes an element matching the hash" do
+      json = '{"users": [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]}'
+      expect(json).to have_json_node(:users).including(name: "Alice")
+    end
+
+    it "passes when array includes an element matching multiple attributes" do
+      json = '{"users": [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]}'
+      expect(json).to have_json_node(:users).including(name: "Alice", age: 30)
+    end
+
+    it "fails when array does not include matching element" do
+      json = '{"users": [{"name": "Alice"}, {"name": "Bob"}]}'
+      expect {
+        expect(json).to have_json_node(:users).including(name: "Charlie")
+      }.to fail_with(/expected to have node called: 'users'/)
+    end
+
+    it "fails when node is not an array" do
+      json = '{"user": {"name": "Alice"}}'
+      expect {
+        expect(json).to have_json_node(:user).including(name: "Alice")
+      }.to fail_with(/expected to have node called: 'user'/)
+    end
+
+    it "passes when array includes a simple value" do
+      json = '{"tags": ["ruby", "rails", "api"]}'
+      expect(json).to have_json_node(:tags).including("ruby")
+    end
+  end
+
+  describe "including_all" do
+    it "passes when array includes all specified elements" do
+      json = '{"items": [{"id": 1}, {"id": 2}, {"id": 3}]}'
+      expect(json).to have_json_node(:items).including_all([{id: 1}, {id: 2}])
+    end
+
+    it "fails when array is missing some elements" do
+      json = '{"items": [{"id": 1}, {"id": 3}]}'
+      expect {
+        expect(json).to have_json_node(:items).including_all([{id: 1}, {id: 2}])
+      }.to fail_with(/expected to have node called: 'items'/)
+    end
+
+    it "passes when array includes all simple values" do
+      json = '{"numbers": [1, 2, 3, 4, 5]}'
+      expect(json).to have_json_node(:numbers).including_all([1, 3, 5])
+    end
+
+    it "fails when node is not an array" do
+      json = '{"item": {"id": 1}}'
+      expect {
+        expect(json).to have_json_node(:item).including_all([{id: 1}])
+      }.to fail_with(/expected to have node called: 'item'/)
+    end
+  end
 end

data/spec/api_matchers/response_body/match_json_schema_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+RSpec.describe APIMatchers::ResponseBody::MatchJsonSchema do
+  let(:schema) do
+    {
+      type: "object",
+      required: ["id", "name"],
+      properties: {
+        id: { type: "integer" },
+        name: { type: "string" },
+        email: { type: "string" }
+      }
+    }
+  end
+
+  describe "actual.to match_json_schema" do
+    it "passes when JSON matches the schema" do
+      json = '{"id": 1, "name": "John", "email": "john@example.com"}'
+      expect(json).to match_json_schema(schema)
+    end
+
+    it "passes when JSON has extra properties not in schema" do
+      json = '{"id": 1, "name": "John", "extra": "field"}'
+      expect(json).to match_json_schema(schema)
+    end
+
+    it "fails when required property is missing" do
+      json = '{"id": 1}'
+      expect {
+        expect(json).to match_json_schema(schema)
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /Expected JSON to match schema/)
+    end
+
+    it "fails when property has wrong type" do
+      json = '{"id": "not_an_integer", "name": "John"}'
+      expect {
+        expect(json).to match_json_schema(schema)
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /Expected JSON to match schema/)
+    end
+  end
+
+  describe "actual.not_to match_json_schema" do
+    it "passes when JSON does not match schema" do
+      json = '{"id": 1}'
+      expect(json).not_to match_json_schema(schema)
+    end
+
+    it "fails when JSON matches schema" do
+      json = '{"id": 1, "name": "John"}'
+      expect {
+        expect(json).not_to match_json_schema(schema)
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /Expected JSON to NOT match schema/)
+    end
+  end
+
+  describe "with string schema" do
+    it "accepts schema as JSON string" do
+      json = '{"id": 1, "name": "John"}'
+      schema_string = '{"type": "object", "required": ["id"], "properties": {"id": {"type": "integer"}}}'
+      expect(json).to match_json_schema(schema_string)
+    end
+  end
+
+  describe "with invalid JSON" do
+    it "raises InvalidJSON error" do
+      expect {
+        expect("not valid json").to match_json_schema(schema)
+      }.to raise_error(APIMatchers::InvalidJSON)
+    end
+  end
+
+  describe "with response_body_method configured" do
+    before do
+      APIMatchers.setup { |config| config.response_body_method = :body }
+    end
+
+    after do
+      APIMatchers.setup { |config| config.response_body_method = nil }
+    end
+
+    it "uses configured method to get response body" do
+      response = OpenStruct.new(body: '{"id": 1, "name": "John"}')
+      expect(response).to match_json_schema(schema)
+    end
+  end
+end