evil-client 0.3.3 → 1.0.0

data/spec/unit/schema/operation_spec.rb

@@ -0,0 +1,309 @@
+RSpec.describe Evil::Client::Schema::Operation do
+  let(:client) { class_double Evil::Client, name: "MyApi" }
+  let(:parent) { described_class.new client }
+  let(:schema) { described_class.new parent, :users }
+  let(:block)  { -> { "bar" } }
+
+  it "subclasses the base schema" do
+    expect(described_class.superclass).to eq Evil::Client::Schema
+  end
+
+  describe "#leaf?" do
+    subject { schema.leaf? }
+
+    it "returns true" do
+      expect(subject).to eq true
+    end
+  end
+
+  describe "definitions" do
+    subject { schema.definitions }
+
+    it "is a hash with empty responses" do
+      expect(subject).to eq responses: {}
+    end
+  end
+
+  describe "#path" do
+    context "with block syntax" do
+      subject { schema.path(&block) }
+
+      it "adds block to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:path] }
+          .to block
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+
+    context "with plain syntax" do
+      subject { schema.path "foo" }
+
+      it "wraps value to block and adds it to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:path]&.call }
+          .to "foo"
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+  end
+
+  describe "#http_method" do
+    context "with block syntax" do
+      subject { schema.http_method(&block) }
+
+      it "adds block to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:http_method] }
+          .to block
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+
+    context "with plain syntax" do
+      subject { schema.http_method "foo" }
+
+      it "wraps value to block and adds it to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:http_method]&.call }
+          .to "foo"
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+  end
+
+  describe "#format" do
+    context "with block syntax" do
+      subject { schema.format(&block) }
+
+      it "adds block to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:format] }
+          .to block
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+
+    context "with plain syntax" do
+      subject { schema.format "foo" }
+
+      it "wraps value to block and adds it to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:format]&.call }
+          .to "foo"
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+  end
+
+  describe "#security" do
+    context "with block syntax" do
+      subject { schema.security(&block) }
+
+      it "adds block to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:security] }
+          .to block
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+
+    context "with plain syntax" do
+      subject { schema.security "foo" => "bar" }
+
+      it "wraps value to block and adds it to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:security]&.call }
+          .to "foo" => "bar"
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+  end
+
+  describe "#headers" do
+    context "with block syntax" do
+      subject { schema.headers(&block) }
+
+      it "adds block to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:headers] }
+          .to block
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+
+    context "with plain syntax" do
+      subject { schema.headers "foo" => "bar" }
+
+      it "wraps value to block and adds it to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:headers]&.call }
+          .to "foo" => "bar"
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+  end
+
+  describe "#query" do
+    context "with block syntax" do
+      subject { schema.query(&block) }
+
+      it "adds block to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:query] }
+          .to block
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+
+    context "with plain syntax" do
+      subject { schema.query "foo" => "bar" }
+
+      it "wraps value to block and adds it to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:query]&.call }
+          .to "foo" => "bar"
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+  end
+
+  describe "#body" do
+    context "with block syntax" do
+      subject { schema.body(&block) }
+
+      it "adds block to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:body] }
+          .to block
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+
+    context "with plain syntax" do
+      subject { schema.body "foo" => "bar" }
+
+      it "wraps value to block and adds it to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:body]&.call }
+          .to "foo" => "bar"
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+  end
+
+  describe "#middleware" do
+    context "with block syntax" do
+      subject { schema.middleware(&block) }
+
+      it "adds block to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:middleware] }
+          .to block
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+
+    context "with plain syntax" do
+      before  { class Test::Foo; end }
+      subject { schema.middleware Test::Foo }
+
+      it "wraps value to block and adds it to definitions" do
+        expect { subject }
+          .to change { schema.definitions[:middleware]&.call }
+          .to Test::Foo
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+  end
+
+  describe "#response" do
+    context "with a block" do
+      subject { schema.response(200, 201, &block) }
+
+      it "adds block to responses under given keys" do
+        expect { subject }
+          .to change { schema.definitions[:responses] }
+          .to(200 => block, 201 => block)
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+
+    context "without a block" do
+      subject { schema.response(200) }
+
+      it "adds identity block to responses under given keys" do
+        subject
+
+        expect(schema.definitions.dig(:responses, 200).call("Hi")).to eq %w[Hi]
+      end
+
+      it "returns the schema itself" do
+        expect(subject).to eq schema
+      end
+    end
+  end
+
+  describe "#responses" do
+    context "with a block" do
+      subject { schema.responses(200, 201, &block) }
+
+      it "is an alias for #response" do
+        expect { subject }
+          .to change { schema.definitions[:responses] }
+          .to(200 => block, 201 => block)
+      end
+    end
+  end
+end

data/spec/unit/schema/scope_spec.rb

@@ -0,0 +1,110 @@
+RSpec.describe Evil::Client::Schema::Scope do
+  let(:client) { class_double Evil::Client, name: "MyApi" }
+  let(:parent) { described_class.new client }
+  let(:schema) { described_class.new parent, :users }
+  let(:block)  { proc { def self.foo; :FOO; end } }
+  let(:dsl_methods) do
+    %i[operations scopes options schema settings inspect logger]
+  end
+
+  it "subclasses the operation schema" do
+    expect(described_class.superclass).to eq Evil::Client::Schema::Operation
+  end
+
+  describe "#leaf?" do
+    subject { schema.leaf? }
+
+    it "returns false" do
+      expect(subject).to eq false
+    end
+  end
+
+  describe "#scopes" do
+    subject { schema.scopes }
+
+    it "returns empty hash by default" do
+      expect(subject).to eq({})
+    end
+  end
+
+  describe "#scope" do
+    subject { schema.scope(:customers, &block) }
+
+    it "adds named subscope to the scope" do
+      subject
+      expect(schema.scopes[:customers]).to be_a described_class
+    end
+
+    it "executes the block in context of the new subscope" do
+      subject
+      expect(schema.scopes[:customers].foo).to eq :FOO
+    end
+
+    it "returns the scope itself" do
+      expect(subject).to eq schema
+    end
+
+    context "when name is reserved by DSL" do
+      it "raises Evil::Client::NameError" do
+        dsl_methods.each do |name|
+          expect { schema.scope(name, &block) }
+            .to raise_error Evil::Client::NameError
+        end
+      end
+    end
+
+    context "when there is an operation with the same name" do
+      before { schema.operation(:customers) {} }
+
+      it "raises Evil::Client::TypeError" do
+        expect { subject }.to raise_error Evil::Client::TypeError
+      end
+    end
+  end
+
+  describe "#operations" do
+    subject { schema.operations }
+
+    it "returns empty hash by default" do
+      expect(subject).to eq({})
+    end
+  end
+
+  describe "#operation" do
+    subject { schema.operation(:fetch, &block) }
+
+    it "adds named operation to the scope" do
+      subject
+      expect(schema.operations[:fetch]).to be_a Evil::Client::Schema::Operation
+    end
+
+    it "executes the block in context of the new operation" do
+      subject
+      expect(schema.operations[:fetch].foo).to eq :FOO
+    end
+
+    it "returns the scope itself" do
+      expect(subject).to eq schema
+    end
+
+    context "when name is reserved by DSL" do
+      it "raises Evil::Client::NameError" do
+        dsl_methods.each do |name|
+          expect { schema.operation(name, &block) }
+            .to raise_error Evil::Client::NameError
+        end
+      end
+    end
+
+    context "when there is an operation with the same name" do
+      before { schema.scope(:fetch) {} }
+
+      it "raises Evil::Client::TypeError" do
+        expect { subject }.to raise_error Evil::Client::TypeError
+      end
+    end
+  end
+
+  describe "#operation" do
+  end
+end

data/spec/unit/schema_spec.rb

@@ -0,0 +1,157 @@
+RSpec.describe Evil::Client::Schema do
+  let(:client) { class_double Evil::Client, name: "MyApi" }
+  let(:parent) { described_class.new client }
+  let(:schema) { described_class.new parent, :users }
+
+  describe "#client" do
+    context "for a root schema" do
+      subject { parent.client }
+
+      it "is taken from initializer" do
+        expect(subject).to eq client
+      end
+    end
+
+    context "for a subschema" do
+      subject { schema.client }
+
+      it "is taken from parent" do
+        expect(subject).to eq client
+      end
+    end
+  end
+
+  describe "#parent" do
+    context "for a root schema" do
+      subject { parent.parent }
+
+      it "is absent" do
+        expect(subject).to be_nil
+      end
+    end
+
+    context "for a subschema" do
+      subject { schema.parent }
+
+      it "is taken from the initializer" do
+        expect(subject).to eq parent
+      end
+    end
+  end
+
+  describe "#name" do
+    context "for a root schema" do
+      subject { parent.name }
+
+      it "is taken from client" do
+        expect(subject).to eq client.name
+      end
+    end
+
+    context "for a subschema" do
+      subject { schema.name }
+
+      it "is taken from the initializer" do
+        expect(subject).to eq :users
+      end
+    end
+  end
+
+  describe "#to_s" do
+    context "for a root schema" do
+      subject { parent.to_s }
+
+      it "returns the name" do
+        expect(subject).to eq "MyApi"
+      end
+    end
+
+    context "for a subschema" do
+      subject { schema.to_s }
+
+      it "returns full name" do
+        expect(subject).to eq "MyApi.users"
+      end
+    end
+  end
+
+  describe "#to_str" do
+    subject { schema.to_str }
+
+    it "is an alias for #to_s" do
+      expect(subject).to eq schema.to_s
+    end
+  end
+
+  describe "#inspect" do
+    subject { schema.inspect }
+
+    it "is an alias for #to_s" do
+      expect(subject).to eq schema.to_s
+    end
+  end
+
+  describe "#settings" do
+    context "for a root schema" do
+      subject { parent.settings }
+
+      it "is a subclass of Evil::Client::Settings" do
+        expect(subject).to be_a Class
+        expect(subject.superclass).to eq Evil::Client::Settings
+      end
+    end
+
+    context "for a subschema" do
+      subject { schema.settings }
+
+      it "is a subclass of parent settings" do
+        expect(subject).to be_a Class
+        expect(subject.superclass).to eq parent.settings
+      end
+    end
+  end
+
+  describe "#option" do
+    before  { allow(schema.settings).to receive(:let) }
+    subject { schema.option(:user, optional: true) }
+
+    it "is delegated to settings" do
+      expect(schema.settings)
+        .to receive(:option).with(:user, nil, optional: true)
+
+      subject
+    end
+
+    it "returns the schema itself" do
+      expect(subject).to eq schema
+    end
+  end
+
+  describe "#let" do
+    before  { allow(schema.settings).to receive(:let) }
+    subject { schema.let(:user) {} }
+
+    it "is delegated to settings" do
+      expect(schema.settings).to receive(:let).with(:user)
+      subject
+    end
+
+    it "returns the schema itself" do
+      expect(subject).to eq schema
+    end
+  end
+
+  describe "#validate" do
+    before  { allow(schema.settings).to receive(:validate) }
+    subject { schema.validate(:id_present) {} }
+
+    it "is delegated to settings" do
+      expect(schema.settings).to receive(:validate).with(:id_present)
+      subject
+    end
+
+    it "returns the schema itself" do
+      expect(subject).to eq schema
+    end
+  end
+end