evil-client 0.3.3 → 1.0.0

data/spec/unit/exceptions/definition_error_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Evil::Client::DefinitionError, "#message" do
+  let(:error)    { described_class.new schema, keys, settings, original }
+  let(:keys)     { [:path] }
+  let(:schema)   { "Test::Api.users.update" }
+  let(:settings) { :my_settings }
+  let(:original) { "something got wrong" }
+
+  subject { error.message }
+
+  it "builds a proper error message" do
+    expect(error.message).to include "failed to resolve path" \
+                                     " from Test::Api.users.update schema" \
+                                     " for my_settings: something got wrong"
+  end
+end

data/spec/unit/exceptions/name_error_spec.rb

@@ -0,0 +1,77 @@
+RSpec.describe Evil::Client::NameError do
+  let(:error)     { described_class.new name, forbidden }
+  let(:name)      { "foo" }
+  let(:forbidden) { %i[foo bar] }
+
+  describe ".check!" do
+    subject { described_class.check! name, forbidden }
+
+    context "with a valid name" do
+      let(:name) { "qux_3" }
+
+      it "symbolizes the name" do
+        expect(subject).to eq :qux_3
+      end
+    end
+
+    context "with a name starting from a digit" do
+      let(:name) { "1qux_3" }
+
+      it "raises itself" do
+        expect { subject }.to raise_error described_class
+      end
+    end
+
+    context "with a name starting from  underscore" do
+      let(:name) { "_qux_3" }
+
+      it "raises itself" do
+        expect { subject }.to raise_error described_class
+      end
+    end
+
+    context "with a one-letter name" do
+      let(:name) { "q" }
+
+      it "raises itself" do
+        expect { subject }.to raise_error described_class
+      end
+    end
+
+    context "with a name ending with the underscore" do
+      let(:name) { "qux_3_" }
+
+      it "raises itself" do
+        expect { subject }.to raise_error described_class
+      end
+    end
+
+    context "with a name containing improper symbols" do
+      let(:name) { "quX_3" }
+
+      it "raises itself" do
+        expect { subject }.to raise_error described_class
+      end
+    end
+
+    context "with a forbidden name" do
+      let(:name) { "foo" }
+
+      it "raises itself" do
+        expect { subject }.to raise_error described_class
+      end
+    end
+  end
+
+  describe "#message" do
+    subject { error.message }
+
+    it "builds a proper error message" do
+      expect(subject).to eq "Invalid name :foo." \
+        " It should contain latin letters in the lower case," \
+        " digits, and underscores only; have minimum 2 chars;" \
+        " start from a letter; end with either letter or digit." \
+        " The following names: 'foo', 'bar' are already used by Evil::Client."
+    end
+  end
+end

data/spec/unit/exceptions/response_error_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe Evil::Client::ResponseError, "#message" do
+  let(:error)    { described_class.new schema, settings, response }
+  let(:schema)   { "Test::Api.users.get" }
+  let(:settings) { :my_settings }
+  let(:response) { [422, { "Language" => "en" }, ["something has got wrong"]] }
+
+  subject { error.message }
+
+  it "builds a proper error message" do
+    expect(error.message).to eq "remote API responded to Test::Api.users.get" \
+                                " with unexpected status 422"
+  end
+
+  it "handles proper data" do
+    expect(error.schema).to   eq schema
+    expect(error.settings).to eq settings
+    expect(error.response).to eq response
+    expect(error.status).to   eq response[0]
+    expect(error.headers).to  eq response[1]
+    expect(error.body).to     eq response[2]
+  end
+end

data/spec/unit/exceptions/type_error_spec.rb

@@ -0,0 +1,71 @@
+RSpec.describe Evil::Client::TypeError do
+  let(:error) { described_class.new name, type }
+
+  describe ".check!" do
+    subject { described_class.check! schema, name, type }
+
+    let(:schema) { double operations: { foo: double }, scopes: { bar: double } }
+
+    context "with unused name" do
+      let(:name) { :qux }
+      let(:type) { :operation }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with valid name for operation" do
+      let(:name) { :foo }
+      let(:type) { :operation }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with valid name for scope" do
+      let(:name) { :bar }
+      let(:type) { :scope }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with invalid name for operation" do
+      let(:name) { :bar }
+      let(:type) { :operation }
+
+      it "raises itself" do
+        expect { subject }.to raise_error described_class
+      end
+    end
+
+    context "with invalid name for scope" do
+      let(:name) { :foo }
+      let(:type) { :scope }
+
+      it "raises itself" do
+        expect { subject }.to raise_error described_class
+      end
+    end
+  end
+
+  describe "#message" do
+    subject { error.message }
+    let(:name) { "foo" }
+
+    context "for a scope" do
+      let(:type) { :scope }
+
+      it "builds a proper error message" do
+        expect(subject).to eq "The operation :foo was already defined." \
+                              " You cannot create scope with the same name."
+      end
+    end
+
+    context "for an operation" do
+      let(:type) { :operation }
+
+      it "builds a proper error message" do
+        expect(subject).to eq "The scope :foo was already defined." \
+                              " You cannot create operation with the same name."
+      end
+    end
+  end
+end

data/spec/unit/exceptions/validation_error_spec.rb

@@ -0,0 +1,13 @@
+RSpec.describe Evil::Client::ValidationError, "#message" do
+  let(:error)   { described_class.new key, scope, options }
+  let(:key)     { :token_present }
+  let(:scope)   { "Test::Api.users.update" }
+  let(:options) { { id: 3, name: "Andrew" } }
+
+  subject { error.message }
+
+  it "builds a proper error message" do
+    # see spec/fixtures/locales/en.yml
+    expect(subject).to eq "To update user id:3 you must provide a token"
+  end
+end

data/spec/unit/formatter/form_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe Evil::Client::Formatter::Form do
+  subject { described_class.call value }
+
+  context "when value is a hash" do
+    let(:value) { { foo: { bar: [baz: :qux], qux: [1, 2] } } }
+
+    it "returns formatted string" do
+      expect(subject).to eq "foo[bar][][baz]=qux&foo[qux][]=1&foo[qux][]=2"
+    end
+  end
+
+  context "when value is nil" do
+    let(:value) { nil }
+
+    it "returns nil" do
+      expect(subject).to be_nil
+    end
+  end
+
+  context "when value is not a hash" do
+    let(:value) { 844 }
+
+    it "raises Evil::Client::DefinitionError" do
+      expect { subject }.to raise_error StandardError, "844 is not a hash"
+    end
+  end
+end

data/spec/unit/formatter/multipart_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe Evil::Client::Formatter::Multipart do
+  subject { described_class.call(*parts, boundary: "foobar") }
+
+  let(:parts)     { [string_io, string] }
+  let(:string_io) { StringIO.new "Hola!" }
+  let(:string)    { "Hello!" }
+
+  it "converts values to multipart body" do
+    expect(subject).to eq \
+      "\r\n\r\n" \
+      "--foobar\r\n" \
+      "Content-Disposition: form-data; name=\"Part1\"\r\n" \
+      "Content-Type: text/plain; charset=utf-8\r\n" \
+      "\r\n" \
+      "Hola!\r\n" \
+      "--foobar\r\n" \
+      "Content-Disposition: form-data; name=\"Part2\"\r\n" \
+      "Content-Type: text/plain; charset=utf-8\r\n" \
+      "\r\n" \
+      "Hello!\r\n" \
+      "--foobar--\r\n"
+  end
+end

data/spec/unit/formatter/part_spec.rb

@@ -0,0 +1,49 @@
+RSpec.describe Evil::Client::Formatter::Part do
+  subject { described_class.call(value, 23).encode("utf-8") }
+
+  context "when value is a file" do
+    let(:value) do
+      Tempfile.new(%w[hello .xml], encoding: "ascii-8bit").tap do |f|
+        f.write "Hi!"
+        f.rewind
+      end
+    end
+
+    it "converts the value to a part of multipart body" do
+      [
+        "Content-Disposition: form-data; name=\"hello",
+        "Content-Type: application/xml; charset=ascii-8bit",
+        "Hi!"
+      ].each { |str| expect(subject).to include str }
+    end
+
+    after do
+      value.close
+      value.unlink
+    end
+  end
+
+  context "when value is a StringIO" do
+    let(:value) { StringIO.new "Упс!".force_encoding "windows-1251" }
+
+    it "converts the value to a part of multipart body" do
+      [
+        "Content-Disposition: form-data; name=\"Part23\"",
+        "Content-Type: text/plain; charset=windows-1251",
+        "РЈРїСЃ!"
+      ].each { |str| expect(subject).to include str }
+    end
+  end
+
+  context "when value is a string" do
+    let(:value) { "Hi!" }
+
+    it "converts the value to a part of multipart body" do
+      [
+        "Content-Disposition: form-data; name=\"Part23\"",
+        "Content-Type: text/plain; charset=utf-8",
+        "Hi!"
+      ].each { |str| expect(subject).to include str }
+    end
+  end
+end

data/spec/unit/formatter/text_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe Evil::Client::Formatter::Text do
+  subject { described_class.call(source) }
+
+  context "from file" do
+    let(:source) do
+      Tempfile.new(%w[hello .xml], encoding: "ascii-8bit").tap do |f|
+        f.write "Hi!"
+        f.rewind
+      end
+    end
+
+    it "reads the file" do
+      expect(subject).to eq "Hi!"
+    end
+
+    after do
+      source.close
+      source.unlink
+    end
+  end
+
+  context "from a StringIO" do
+    let(:source) { StringIO.new "Hello!" }
+
+    it "reads the IO" do
+      expect(subject).to eq "Hello!"
+    end
+  end
+
+  context "from another source" do
+    let(:source) { %i[2384] }
+
+    it "stringifies the source" do
+      expect(subject).to eq '[:"2384"]'
+    end
+  end
+end

data/spec/unit/formatter_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe Evil::Client::Formatter do
+  subject { described_class.call source, format, boundary: "foobar" }
+
+  let(:source) { { foo: :bar } }
+
+  context "for :json format" do
+    let(:format) { :json }
+
+    it "returns formatted body as json" do
+      expect(subject).to eq '{"foo":"bar"}'
+    end
+  end
+
+  context "for :yaml format" do
+    let(:format) { :yaml }
+
+    it "returns formatted body as yaml" do
+      expect(subject).to eq "---\n:foo: :bar\n"
+    end
+  end
+
+  context "for :text format" do
+    let(:format) { :text }
+
+    it "returns formatted body as plain text" do
+      expect(subject).to eq "{:foo=>:bar}"
+    end
+  end
+
+  context "for :form format" do
+    let(:format) { :form }
+
+    it "returns formatted body as form/urlencoded" do
+      expect(subject).to eq "foo=bar"
+    end
+  end
+
+  context "for :multipart format" do
+    let(:format) { :multipart }
+
+    it "returns formatted body as a multipart" do
+      expect(subject).to include "--foobar"
+      expect(subject).to include "foo=bar"
+    end
+  end
+end

data/spec/unit/resolver/body_spec.rb

@@ -0,0 +1,65 @@
+RSpec.describe Evil::Client::Resolver::Body, ".call" do
+  subject { described_class.call schema, settings }
+
+  let(:log)      { StringIO.new }
+  let(:logger)   { Logger.new log }
+  let(:settings) { double :my_settings, version: 77, logger: logger }
+
+  let(:root_schema) do
+    double :my_parent_schema,
+           definitions: { body: proc { %W[v#{version}] } },
+           parent: nil
+  end
+
+  let(:schema) do
+    double :my_schema,
+           definitions: { body: proc { { version: "v#{version}" } } },
+           parent: root_schema
+  end
+
+  it "resolves body from a schema" do
+    expect(subject).to eq version: "v77"
+  end
+
+  it "logs the result" do
+    subject
+
+    expect(log.string).to include described_class.name
+    expect(log.string).to include "my_schema"
+    expect(log.string).to include "my_settings"
+    expect(log.string).to include "v77"
+  end
+
+  context "when logger level was set to INFO" do
+    before { logger.level = Logger::INFO }
+
+    it "skips logging" do
+      expect { subject }.not_to change { log.string }
+    end
+  end
+
+  context "when current schema not defines a body" do
+    before { schema.definitions.delete :body }
+
+    it "resolves body from a parent schema" do
+      expect(subject).to eq %w[v77]
+    end
+  end
+
+  context "when root body definitions was reloaded by nil" do
+    before { schema.definitions[:body] = proc {} }
+
+    it "resolves body to nil" do
+      expect(subject).to be_nil
+    end
+  end
+
+  context "when body not defined by any schema" do
+    before { schema.definitions.delete :body }
+    before { root_schema.definitions.delete :body }
+
+    it "resolves body to nil" do
+      expect(subject).to be_nil
+    end
+  end
+end