api_matchers 0.6.1 → 1.0.0

data/spec/api_matchers/http_status/be_unprocessable_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+RSpec.describe APIMatchers::HTTPStatus::BeUnprocessable do
+  describe "actual.to be_unprocessable" do
+    it "passes for status 422" do
+      expect(422).to be_unprocessable
+    end
+
+    it "fails for status 200" do
+      expect {
+        expect(200).to be_unprocessable
+      }.to fail_with("expected response to be unprocessable (422). Got: 200")
+    end
+
+    it "fails for status 400" do
+      expect {
+        expect(400).to be_unprocessable
+      }.to fail_with("expected response to be unprocessable (422). Got: 400")
+    end
+  end
+
+  describe "actual.not_to be_unprocessable" do
+    it "passes for non-422 status" do
+      expect(200).not_to be_unprocessable
+    end
+
+    it "fails for 422 status" do
+      expect {
+        expect(422).not_to be_unprocessable
+      }.to fail_with("expected response NOT to be unprocessable (422). Got: 422")
+    end
+  end
+
+  describe "alias be_unprocessable_entity" do
+    it "works as alias for be_unprocessable" do
+      expect(422).to be_unprocessable_entity
+    end
+  end
+end

data/spec/api_matchers/http_status/have_http_status_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+RSpec.describe APIMatchers::HTTPStatus::HaveHttpStatus do
+  describe "actual.to have_http_status" do
+    context "with integer status code" do
+      it "passes when the status matches" do
+        expect(200).to have_http_status(200)
+      end
+
+      it "fails when the status does not match" do
+        expect {
+          expect(404).to have_http_status(200)
+        }.to fail_with("expected response to have HTTP status 200. Got: 404")
+      end
+    end
+
+    context "with symbol status code" do
+      it "passes when the status matches :ok" do
+        expect(200).to have_http_status(:ok)
+      end
+
+      it "passes when the status matches :created" do
+        expect(201).to have_http_status(:created)
+      end
+
+      it "passes when the status matches :not_found" do
+        expect(404).to have_http_status(:not_found)
+      end
+
+      it "passes when the status matches :unprocessable_entity" do
+        expect(422).to have_http_status(:unprocessable_entity)
+      end
+
+      it "fails when the status does not match" do
+        expect {
+          expect(500).to have_http_status(:ok)
+        }.to fail_with("expected response to have HTTP status 200 (ok). Got: 500")
+      end
+
+      it "raises error for unknown symbol" do
+        expect {
+          expect(200).to have_http_status(:unknown_status)
+        }.to raise_error(ArgumentError, /Unknown status code symbol/)
+      end
+    end
+  end
+
+  describe "actual.not_to have_http_status" do
+    it "passes when the status does not match" do
+      expect(404).not_to have_http_status(200)
+    end
+
+    it "fails when the status matches" do
+      expect {
+        expect(200).not_to have_http_status(200)
+      }.to fail_with("expected response NOT to have HTTP status 200. Got: 200")
+    end
+  end
+
+  describe "with configuration" do
+    before do
+      APIMatchers.setup { |config| config.http_status_method = :status }
+    end
+
+    after do
+      APIMatchers.setup { |config| config.http_status_method = nil }
+    end
+
+    it "extracts status from response object" do
+      response = OpenStruct.new(status: 200)
+      expect(response).to have_http_status(:ok)
+    end
+
+    it "fails when response status does not match" do
+      response = OpenStruct.new(status: 404)
+      expect {
+        expect(response).to have_http_status(:ok)
+      }.to fail_with(/expected response to have HTTP status 200/)
+    end
+  end
+end

data/spec/api_matchers/json_api/be_json_api_compliant_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+RSpec.describe APIMatchers::JsonApi::BeJsonApiCompliant do
+  describe "actual.to be_json_api_compliant" do
+    context "with valid JSON:API structure" do
+      it "passes with data object" do
+        json = '{"data": {"id": "1", "type": "users", "attributes": {"name": "John"}}}'
+        expect(json).to be_json_api_compliant
+      end
+
+      it "passes with data array" do
+        json = '{"data": [{"id": "1", "type": "users"}, {"id": "2", "type": "users"}]}'
+        expect(json).to be_json_api_compliant
+      end
+
+      it "passes with null data" do
+        json = '{"data": null}'
+        expect(json).to be_json_api_compliant
+      end
+
+      it "passes with errors array" do
+        json = '{"errors": [{"status": "404", "title": "Not Found"}]}'
+        expect(json).to be_json_api_compliant
+      end
+
+      it "passes with meta only" do
+        json = '{"meta": {"total": 100}}'
+        expect(json).to be_json_api_compliant
+      end
+
+      it "passes with relationships" do
+        json = '{"data": {"id": "1", "type": "posts", "relationships": {"author": {"data": {"id": "1", "type": "users"}}}}}'
+        expect(json).to be_json_api_compliant
+      end
+    end
+
+    context "with invalid JSON:API structure" do
+      it "fails when top level is not an object" do
+        json = '[1, 2, 3]'
+        expect {
+          expect(json).to be_json_api_compliant
+        }.to fail_with(/top-level must be an object/)
+      end
+
+      it "fails when missing data, errors, and meta" do
+        json = '{"included": []}'
+        expect {
+          expect(json).to be_json_api_compliant
+        }.to fail_with(/must contain at least one of: data, errors, or meta/)
+      end
+
+      it "fails when data and errors coexist" do
+        json = '{"data": {"id": "1", "type": "users"}, "errors": []}'
+        expect {
+          expect(json).to be_json_api_compliant
+        }.to fail_with(/data and errors must not coexist/)
+      end
+
+      it "fails when resource is missing type" do
+        json = '{"data": {"id": "1"}}'
+        expect {
+          expect(json).to be_json_api_compliant
+        }.to fail_with(/must contain 'type'/)
+      end
+
+      it "fails when type is not a string" do
+        json = '{"data": {"id": "1", "type": 123}}'
+        expect {
+          expect(json).to be_json_api_compliant
+        }.to fail_with(/type must be a string/)
+      end
+
+      it "fails when attributes is not an object" do
+        json = '{"data": {"id": "1", "type": "users", "attributes": "invalid"}}'
+        expect {
+          expect(json).to be_json_api_compliant
+        }.to fail_with(/attributes must be an object/)
+      end
+
+      it "fails when relationships is not an object" do
+        json = '{"data": {"id": "1", "type": "users", "relationships": "invalid"}}'
+        expect {
+          expect(json).to be_json_api_compliant
+        }.to fail_with(/relationships must be an object/)
+      end
+
+      it "fails when errors is not an array" do
+        json = '{"errors": {"message": "error"}}'
+        expect {
+          expect(json).to be_json_api_compliant
+        }.to fail_with(/errors must be an array/)
+      end
+    end
+  end
+
+  describe "actual.not_to be_json_api_compliant" do
+    it "passes when not compliant" do
+      json = '{"result": "success"}'
+      expect(json).not_to be_json_api_compliant
+    end
+
+    it "fails when compliant" do
+      json = '{"data": {"id": "1", "type": "users"}}'
+      expect {
+        expect(json).not_to be_json_api_compliant
+      }.to fail_with(/expected response NOT to be JSON:API compliant/)
+    end
+  end
+end

data/spec/api_matchers/json_api/have_json_api_attributes_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+RSpec.describe APIMatchers::JsonApi::HaveJsonApiAttributes do
+  describe "actual.to have_json_api_attributes" do
+    context "with single resource" do
+      it "passes when all attributes are present" do
+        json = '{"data": {"id": "1", "type": "users", "attributes": {"name": "John", "email": "john@example.com"}}}'
+        expect(json).to have_json_api_attributes(:name, :email)
+      end
+
+      it "passes when checking subset of attributes" do
+        json = '{"data": {"id": "1", "type": "users", "attributes": {"name": "John", "email": "john@example.com", "age": 30}}}'
+        expect(json).to have_json_api_attributes(:name)
+      end
+
+      it "fails when attribute is missing" do
+        json = '{"data": {"id": "1", "type": "users", "attributes": {"name": "John"}}}'
+        expect {
+          expect(json).to have_json_api_attributes(:name, :email)
+        }.to fail_with(/Missing: \["email"\]/)
+      end
+    end
+
+    context "with array of resources" do
+      it "checks attributes of first resource" do
+        json = '{"data": [{"id": "1", "type": "users", "attributes": {"name": "John"}}, {"id": "2", "type": "users", "attributes": {"name": "Jane"}}]}'
+        expect(json).to have_json_api_attributes(:name)
+      end
+    end
+
+    context "when no attributes found" do
+      it "fails when data has no attributes" do
+        json = '{"data": {"id": "1", "type": "users"}}'
+        expect {
+          expect(json).to have_json_api_attributes(:name)
+        }.to fail_with(/but no attributes were found/)
+      end
+
+      it "fails when data is missing" do
+        json = '{"errors": []}'
+        expect {
+          expect(json).to have_json_api_attributes(:name)
+        }.to fail_with(/but no attributes were found/)
+      end
+    end
+  end
+
+  describe "actual.not_to have_json_api_attributes" do
+    it "passes when not all attributes are present" do
+      json = '{"data": {"id": "1", "type": "users", "attributes": {"name": "John"}}}'
+      expect(json).not_to have_json_api_attributes(:email)
+    end
+
+    it "fails when all attributes are present" do
+      json = '{"data": {"id": "1", "type": "users", "attributes": {"name": "John", "email": "john@example.com"}}}'
+      expect {
+        expect(json).not_to have_json_api_attributes(:name, :email)
+      }.to fail_with(/expected JSON:API data NOT to have attributes/)
+    end
+  end
+end

data/spec/api_matchers/json_api/have_json_api_data_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+RSpec.describe APIMatchers::JsonApi::HaveJsonApiData do
+  describe "actual.to have_json_api_data" do
+    context "basic data presence" do
+      it "passes when data is present" do
+        json = '{"data": {"id": "1", "type": "users"}}'
+        expect(json).to have_json_api_data
+      end
+
+      it "passes when data is null" do
+        json = '{"data": null}'
+        expect(json).to have_json_api_data
+      end
+
+      it "passes when data is an array" do
+        json = '{"data": [{"id": "1", "type": "users"}]}'
+        expect(json).to have_json_api_data
+      end
+
+      it "fails when data is missing" do
+        json = '{"errors": []}'
+        expect {
+          expect(json).to have_json_api_data
+        }.to fail_with(/expected response to have JSON:API data/)
+      end
+    end
+
+    context "with of_type" do
+      it "passes when type matches" do
+        json = '{"data": {"id": "1", "type": "users"}}'
+        expect(json).to have_json_api_data.of_type("users")
+      end
+
+      it "passes when type matches for array" do
+        json = '{"data": [{"id": "1", "type": "users"}, {"id": "2", "type": "users"}]}'
+        expect(json).to have_json_api_data.of_type(:users)
+      end
+
+      it "fails when type does not match" do
+        json = '{"data": {"id": "1", "type": "posts"}}'
+        expect {
+          expect(json).to have_json_api_data.of_type("users")
+        }.to fail_with(/expected JSON:API data to have type 'users'. Got type: 'posts'/)
+      end
+    end
+
+    context "with with_id" do
+      it "passes when id matches" do
+        json = '{"data": {"id": "123", "type": "users"}}'
+        expect(json).to have_json_api_data.with_id("123")
+      end
+
+      it "passes when id is in array" do
+        json = '{"data": [{"id": "1", "type": "users"}, {"id": "2", "type": "users"}]}'
+        expect(json).to have_json_api_data.with_id("2")
+      end
+
+      it "fails when id does not match" do
+        json = '{"data": {"id": "123", "type": "users"}}'
+        expect {
+          expect(json).to have_json_api_data.with_id("456")
+        }.to fail_with(/expected JSON:API data to have id '456'. Got id: '123'/)
+      end
+    end
+
+    context "combining of_type and with_id" do
+      it "passes when both match" do
+        json = '{"data": {"id": "123", "type": "users"}}'
+        expect(json).to have_json_api_data.of_type("users").with_id("123")
+      end
+
+      it "fails when type does not match" do
+        json = '{"data": {"id": "123", "type": "posts"}}'
+        expect {
+          expect(json).to have_json_api_data.of_type("users").with_id("123")
+        }.to fail_with(/expected JSON:API data to have type 'users'/)
+      end
+    end
+  end
+
+  describe "actual.not_to have_json_api_data" do
+    it "passes when data is missing" do
+      json = '{"errors": []}'
+      expect(json).not_to have_json_api_data
+    end
+
+    it "fails when data is present" do
+      json = '{"data": {"id": "1", "type": "users"}}'
+      expect {
+        expect(json).not_to have_json_api_data
+      }.to fail_with(/expected response NOT to have JSON:API data/)
+    end
+  end
+end

data/spec/api_matchers/json_api/have_json_api_relationships_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+RSpec.describe APIMatchers::JsonApi::HaveJsonApiRelationships do
+  describe "actual.to have_json_api_relationships" do
+    context "with single resource" do
+      it "passes when all relationships are present" do
+        json = '{"data": {"id": "1", "type": "posts", "relationships": {"author": {"data": {"id": "1", "type": "users"}}, "comments": {"data": []}}}}'
+        expect(json).to have_json_api_relationships(:author, :comments)
+      end
+
+      it "passes when checking subset of relationships" do
+        json = '{"data": {"id": "1", "type": "posts", "relationships": {"author": {"data": {"id": "1", "type": "users"}}, "comments": {"data": []}}}}'
+        expect(json).to have_json_api_relationships(:author)
+      end
+
+      it "fails when relationship is missing" do
+        json = '{"data": {"id": "1", "type": "posts", "relationships": {"author": {"data": {"id": "1", "type": "users"}}}}}'
+        expect {
+          expect(json).to have_json_api_relationships(:author, :comments)
+        }.to fail_with(/Missing: \["comments"\]/)
+      end
+    end
+
+    context "with array of resources" do
+      it "checks relationships of first resource" do
+        json = '{"data": [{"id": "1", "type": "posts", "relationships": {"author": {"data": {"id": "1", "type": "users"}}}}, {"id": "2", "type": "posts", "relationships": {"author": {"data": {"id": "2", "type": "users"}}}}]}'
+        expect(json).to have_json_api_relationships(:author)
+      end
+    end
+
+    context "when no relationships found" do
+      it "fails when data has no relationships" do
+        json = '{"data": {"id": "1", "type": "posts"}}'
+        expect {
+          expect(json).to have_json_api_relationships(:author)
+        }.to fail_with(/but no relationships were found/)
+      end
+
+      it "fails when data is missing" do
+        json = '{"errors": []}'
+        expect {
+          expect(json).to have_json_api_relationships(:author)
+        }.to fail_with(/but no relationships were found/)
+      end
+    end
+  end
+
+  describe "actual.not_to have_json_api_relationships" do
+    it "passes when not all relationships are present" do
+      json = '{"data": {"id": "1", "type": "posts", "relationships": {"author": {"data": {"id": "1", "type": "users"}}}}}'
+      expect(json).not_to have_json_api_relationships(:comments)
+    end
+
+    it "fails when all relationships are present" do
+      json = '{"data": {"id": "1", "type": "posts", "relationships": {"author": {"data": {"id": "1", "type": "users"}}, "comments": {"data": []}}}}'
+      expect {
+        expect(json).not_to have_json_api_relationships(:author, :comments)
+      }.to fail_with(/expected JSON:API data NOT to have relationships/)
+    end
+  end
+end

data/spec/api_matchers/json_structure/have_json_keys_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+RSpec.describe APIMatchers::JsonStructure::HaveJsonKeys do
+  describe "actual.to have_json_keys" do
+    context "with JSON string" do
+      it "passes when all keys are present" do
+        json = '{"id": 1, "name": "John", "email": "john@example.com"}'
+        expect(json).to have_json_keys(:id, :name, :email)
+      end
+
+      it "passes when checking subset of keys" do
+        json = '{"id": 1, "name": "John", "email": "john@example.com"}'
+        expect(json).to have_json_keys(:id, :name)
+      end
+
+      it "fails when a key is missing" do
+        json = '{"id": 1, "name": "John"}'
+        expect {
+          expect(json).to have_json_keys(:id, :name, :email)
+        }.to fail_with(/Missing: \["email"\]/)
+      end
+
+      it "fails when multiple keys are missing" do
+        json = '{"id": 1}'
+        expect {
+          expect(json).to have_json_keys(:id, :name, :email)
+        }.to fail_with(/Missing: \["name", "email"\]/)
+      end
+    end
+
+    context "with Hash" do
+      it "passes when all keys are present" do
+        data = { id: 1, name: "John", email: "john@example.com" }
+        expect(data).to have_json_keys(:id, :name, :email)
+      end
+    end
+
+    context "with at_path" do
+      it "checks keys at specified path" do
+        json = '{"user": {"id": 1, "name": "John"}}'
+        expect(json).to have_json_keys(:id, :name).at_path("user")
+      end
+
+      it "fails when path does not exist" do
+        json = '{"data": {"id": 1}}'
+        expect {
+          expect(json).to have_json_keys(:id).at_path("user")
+        }.to fail_with(/Missing: \["id"\]/)
+      end
+    end
+  end
+
+  describe "actual.not_to have_json_keys" do
+    it "passes when not all keys are present" do
+      json = '{"id": 1, "name": "John"}'
+      expect(json).not_to have_json_keys(:id, :name, :email)
+    end
+
+    it "fails when all keys are present" do
+      json = '{"id": 1, "name": "John"}'
+      expect {
+        expect(json).not_to have_json_keys(:id, :name)
+      }.to fail_with(/expected JSON NOT to have keys/)
+    end
+  end
+
+  describe "with 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 "extracts body from response object" do
+      response = OpenStruct.new(body: '{"id": 1, "name": "John"}')
+      expect(response).to have_json_keys(:id, :name)
+    end
+  end
+end

data/spec/api_matchers/json_structure/have_json_type_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+RSpec.describe APIMatchers::JsonStructure::HaveJsonType do
+  describe "actual.to have_json_type" do
+    context "Integer type" do
+      it "passes for integer value" do
+        json = '{"id": 42}'
+        expect(json).to have_json_type(Integer).at_path("id")
+      end
+
+      it "fails for non-integer value" do
+        json = '{"id": "42"}'
+        expect {
+          expect(json).to have_json_type(Integer).at_path("id")
+        }.to fail_with(/expected JSON value at 'id' to be of type Integer/)
+      end
+    end
+
+    context "String type" do
+      it "passes for string value" do
+        json = '{"name": "John"}'
+        expect(json).to have_json_type(String).at_path("name")
+      end
+
+      it "fails for non-string value" do
+        json = '{"name": 123}'
+        expect {
+          expect(json).to have_json_type(String).at_path("name")
+        }.to fail_with(/expected JSON value at 'name' to be of type String/)
+      end
+    end
+
+    context "Boolean type" do
+      it "passes for true value" do
+        json = '{"active": true}'
+        expect(json).to have_json_type(:boolean).at_path("active")
+      end
+
+      it "passes for false value" do
+        json = '{"active": false}'
+        expect(json).to have_json_type(:boolean).at_path("active")
+      end
+
+      it "fails for non-boolean value" do
+        json = '{"active": "true"}'
+        expect {
+          expect(json).to have_json_type(:boolean).at_path("active")
+        }.to fail_with(/expected JSON value at 'active' to be of type Boolean/)
+      end
+    end
+
+    context "Array type" do
+      it "passes for array value" do
+        json = '{"items": [1, 2, 3]}'
+        expect(json).to have_json_type(Array).at_path("items")
+      end
+
+      it "fails for non-array value" do
+        json = '{"items": "not an array"}'
+        expect {
+          expect(json).to have_json_type(Array).at_path("items")
+        }.to fail_with(/expected JSON value at 'items' to be of type Array/)
+      end
+    end
+
+    context "Hash type" do
+      it "passes for hash/object value" do
+        json = '{"user": {"name": "John"}}'
+        expect(json).to have_json_type(Hash).at_path("user")
+      end
+
+      it "fails for non-hash value" do
+        json = '{"user": "not a hash"}'
+        expect {
+          expect(json).to have_json_type(Hash).at_path("user")
+        }.to fail_with(/expected JSON value at 'user' to be of type Hash/)
+      end
+    end
+
+    context "NilClass type" do
+      it "passes for null value" do
+        json = '{"value": null}'
+        expect(json).to have_json_type(NilClass).at_path("value")
+      end
+
+      it "fails for non-null value" do
+        json = '{"value": "something"}'
+        expect {
+          expect(json).to have_json_type(NilClass).at_path("value")
+        }.to fail_with(/expected JSON value at 'value' to be of type NilClass/)
+      end
+    end
+
+    context "Numeric type" do
+      it "passes for integer value" do
+        json = '{"count": 42}'
+        expect(json).to have_json_type(Numeric).at_path("count")
+      end
+
+      it "passes for float value" do
+        json = '{"price": 19.99}'
+        expect(json).to have_json_type(Numeric).at_path("price")
+      end
+    end
+
+    context "nested path" do
+      it "navigates nested structure" do
+        json = '{"user": {"profile": {"age": 30}}}'
+        expect(json).to have_json_type(Integer).at_path("user.profile.age")
+      end
+    end
+
+    context "at root" do
+      it "checks type at root level without at_path" do
+        json = '[1, 2, 3]'
+        expect(json).to have_json_type(Array)
+      end
+    end
+  end
+
+  describe "actual.not_to have_json_type" do
+    it "passes when type does not match" do
+      json = '{"id": "42"}'
+      expect(json).not_to have_json_type(Integer).at_path("id")
+    end
+
+    it "fails when type matches" do
+      json = '{"id": 42}'
+      expect {
+        expect(json).not_to have_json_type(Integer).at_path("id")
+      }.to fail_with(/expected JSON value at 'id' NOT to be of type Integer/)
+    end
+  end
+end