search-kit 0.0.3 → 0.0.4

data/spec/search_kit/clients/documents_spec.rb

@@ -0,0 +1,210 @@
+require 'ostruct'
+require 'spec_helper'
+
+describe SearchKit::Clients::Documents do
+  let(:body)     { { data: [] } }
+  let(:client)   { described_class.new }
+  let(:id)       { 1 }
+  let(:json)     { body.to_json }
+  let(:response) { OpenStruct.new(body: json, status: status) }
+  let(:slug)     { "index-slug" }
+  let(:status)   { 200 }
+  let(:token)    { SearchKit.config.app_token }
+
+  before do
+    allow(client.connection).to receive(:delete).and_return(response)
+    allow(client.connection).to receive(:get).and_return(response)
+    allow(client.connection).to receive(:patch).and_return(response)
+    allow(client.connection).to receive(:post).and_return(response)
+  end
+
+  subject { client }
+
+  it { is_expected.to respond_to :token }
+
+  describe '#connection' do
+    subject { client.connection }
+    it { is_expected.to be_instance_of Faraday::Connection }
+  end
+
+  describe '#create' do
+    let(:document) { { id: id, title: "The first document" } }
+
+    let(:params) do
+      { token: token, data: { type: "documents", attributes: document } }
+    end
+
+    subject { client.create(slug, document) }
+
+    it "calls #connection.post with the base path and a document" do
+      expect(client.connection).to receive(:post).with(slug, params)
+      subject
+    end
+
+    it "parses the json response" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    context 'when the response status is 400' do
+      let(:status) { 400 }
+
+      it "raises a bad request error" do
+        expect { subject }.to raise_exception(SearchKit::Errors::BadRequest)
+      end
+    end
+
+    context 'when the response status is 401' do
+      let(:status) { 401 }
+
+      it "raises a not authorized error" do
+        expect { subject }.to raise_exception(SearchKit::Errors::Unauthorized)
+      end
+    end
+
+    context 'when the response status is 404' do
+      let(:status) { 404 }
+
+      it "raises an index not found error" do
+        expect { subject }.to raise_exception(SearchKit::Errors::IndexNotFound)
+      end
+    end
+
+    context 'when the response status is 422' do
+      let(:status) { 422 }
+
+      it "raises an unprocessable error" do
+        expect { subject }.to raise_exception(SearchKit::Errors::Unprocessable)
+      end
+    end
+
+  end
+
+  describe '#delete' do
+    subject { client.delete(slug, id) }
+
+    it "calls #connection.get with the base events path" do
+      expect(client.connection)
+        .to receive(:delete)
+        .with("#{slug}/#{id}", token: token)
+
+      subject
+    end
+
+    it "parses the json response" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    context 'when the response status is 401' do
+      let(:status) { 401 }
+
+      it "raises a not authorized error" do
+        expect { subject }.to raise_exception(SearchKit::Errors::Unauthorized)
+      end
+    end
+
+    context 'when the response status is 404' do
+      let(:status) { 404 }
+
+      it "raises an index not found error" do
+        expect { subject }.to raise_exception(SearchKit::Errors::IndexNotFound)
+      end
+    end
+
+  end
+
+  describe '#show' do
+    subject { client.show(slug, id) }
+
+    it "calls #connection.get with the given id" do
+      expect(client.connection)
+        .to receive(:get)
+        .with("#{slug}/#{id}", token: token)
+
+      subject
+    end
+
+    it "parses the json response" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    context 'when the response status is 401' do
+      let(:status) { 401 }
+
+      it "raises a not authorized error" do
+        expect { subject }.to raise_exception(SearchKit::Errors::Unauthorized)
+      end
+    end
+
+    context 'when the response status is 404' do
+      let(:status) { 404 }
+
+      it "raises an index not found error" do
+        expect { subject }.to raise_exception(SearchKit::Errors::IndexNotFound)
+      end
+    end
+
+  end
+
+  describe '#update' do
+    let(:document) { { id: id, title: "The first document" } }
+
+    let(:params) do
+      {
+        token: token,
+        data: { type: "documents", id: id, attributes: document }
+      }
+    end
+
+    subject { client.update(slug, id, document) }
+
+    it "calls #connection.patch with the slug, id and document" do
+      expect(client.connection)
+        .to receive(:patch)
+        .with("#{slug}/#{id}", params)
+
+      subject
+    end
+
+    it "parses the json response" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    context 'when the response status is 400' do
+      let(:status) { 400 }
+
+      it "raises a bad request error" do
+        expect { subject }.to raise_exception(SearchKit::Errors::BadRequest)
+      end
+    end
+
+    context 'when the response status is 401' do
+      let(:status) { 401 }
+
+      it "raises a not authorized error" do
+        expect { subject }.to raise_exception(SearchKit::Errors::Unauthorized)
+      end
+    end
+
+    context 'when the response status is 422' do
+      let(:status) { 422 }
+
+      it "raises an unprocessable error" do
+        expect { subject }.to raise_exception(SearchKit::Errors::Unprocessable)
+      end
+    end
+
+    context 'when the response status is 404' do
+      let(:status) { 404 }
+
+      it "raises an index not found error" do
+        expect { subject }.to raise_exception(SearchKit::Errors::IndexNotFound)
+      end
+    end
+
+  end
+
+end

data/spec/search_kit/clients/events_spec.rb

@@ -0,0 +1,202 @@
+require 'ostruct'
+require 'spec_helper'
+
+describe SearchKit::Clients::Events do
+  let(:client)   { described_class.new }
+  let(:id)       { 1 }
+  let(:hash)     { {} }
+  let(:json)     { hash.to_json }
+  let(:response) { OpenStruct.new(status: status, body: json) }
+  let(:status)   { 200 }
+  let(:token)    { SearchKit.config.app_token }
+
+  before do
+    allow(client.connection).to receive(:delete).and_return(response)
+    allow(client.connection).to receive(:get).and_return(response)
+    allow(client.connection).to receive(:post).and_return(response)
+    allow(JSON).to receive(:parse).and_return(hash)
+  end
+
+  subject { client }
+
+  it { is_expected.to respond_to :token }
+
+  describe '#connection' do
+    subject { client.connection }
+    it { is_expected.to be_instance_of Faraday::Connection }
+  end
+
+  describe '#complete' do
+    subject { client.complete(id) }
+
+    it { is_expected.to be_instance_of SearchKit::Models::Event }
+
+    it "calls #connection.get with the base events path" do
+      expect(client.connection).to receive(:delete).with(id, token: token)
+      subject
+    end
+
+    it "parses the json response" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    context 'when given status 401' do
+      let(:status) { 401 }
+
+      it do
+        expect { subject }.to raise_exception(SearchKit::Errors::Unauthorized)
+      end
+    end
+
+    context 'when given status 404' do
+      let(:status) { 404 }
+
+      it do
+        expect { subject }.to raise_exception(SearchKit::Errors::EventNotFound)
+      end
+    end
+  end
+
+  describe '#index' do
+    subject { client.index }
+
+    it { is_expected.to be_instance_of SearchKit::Models::Events }
+
+    it "calls #connection.get with the base events path" do
+      expect(client.connection).to receive(:get).with(token: token)
+      subject
+    end
+
+    it "parses the json response" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    context 'when given status 401' do
+      let(:status) { 401 }
+
+      it do
+        expect { subject }.to raise_exception(SearchKit::Errors::Unauthorized)
+      end
+    end
+  end
+
+  describe '#pending' do
+    let(:channel) { "colon:separated:string" }
+
+    subject { client.pending(channel) }
+
+    it { is_expected.to be_instance_of SearchKit::Models::Events }
+
+    it "calls #connection.get with the base events path" do
+      expect(client.connection)
+        .to receive(:get)
+        .with('', "filter[channel]" => channel, token: token)
+
+      subject
+    end
+
+    it "parses the json response" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    context 'when given status 401' do
+      let(:status) { 401 }
+
+      it do
+        expect { subject }.to raise_exception(SearchKit::Errors::Unauthorized)
+      end
+    end
+
+  end
+
+  describe '#publish' do
+    let(:channel) { "colon:separated:string" }
+    let(:options) { { channel: channel, payload: payload } }
+
+    let(:payload) do
+      { one_key: true, two_key: true, red_key: true, blue_key: true }
+    end
+
+    let(:params) do
+      {
+        token: token,
+        data: {
+          type: 'events',
+          attributes: { channel: channel, payload: payload }
+        }
+      }
+    end
+
+    subject { client.publish(channel, payload) }
+
+    it { is_expected.to be_instance_of SearchKit::Models::Event }
+
+    it "calls #connection.get with the base events path" do
+      expect(client.connection).to receive(:post).with('', params)
+      subject
+    end
+
+    it "parses the json response" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    context 'when given status 400' do
+      let(:status) { 400 }
+
+      it do
+        expect { subject }.to raise_exception(SearchKit::Errors::BadRequest)
+      end
+    end
+
+    context 'when given status 401' do
+      let(:status) { 401 }
+
+      it do
+        expect { subject }.to raise_exception(SearchKit::Errors::Unauthorized)
+      end
+    end
+
+    context 'when given status 404' do
+      let(:status) { 422 }
+
+      it do
+        expect { subject }.to raise_exception(SearchKit::Errors::Unprocessable)
+      end
+    end
+  end
+
+  describe '#show' do
+    subject { client.show(id) }
+
+    it "calls #connection.get with the base events path / id" do
+      expect(client.connection).to receive(:get).with(id, token: token)
+      subject
+    end
+
+    it "parses the json response" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    context 'when given status 401' do
+      let(:status) { 401 }
+
+      it do
+        expect { subject }.to raise_exception(SearchKit::Errors::Unauthorized)
+      end
+    end
+
+    context 'when given status 404' do
+      let(:status) { 404 }
+
+      it do
+        expect { subject }.to raise_exception(SearchKit::Errors::EventNotFound)
+      end
+    end
+  end
+
+end

data/spec/search_kit/clients/indices_spec.rb

@@ -0,0 +1,193 @@
+require 'ostruct'
+require 'spec_helper'
+
+describe SearchKit::Clients::Indices do
+  let(:json)          { response_body.to_json }
+  let(:response)      { OpenStruct.new(status: status, body: json) }
+  let(:status)        { 200 }
+  let(:client)        { described_class.new }
+  let(:response_body) { { data: [] } }
+  let(:token)         { SearchKit.config.app_token }
+
+  before do
+    allow(client.connection).to receive(:delete).and_return(response)
+    allow(client.connection).to receive(:get).and_return(response)
+    allow(client.connection).to receive(:patch).and_return(response)
+    allow(client.connection).to receive(:post).and_return(response)
+  end
+
+  subject { client }
+
+  it { is_expected.to respond_to :token }
+
+  describe '#connection' do
+    subject { client.connection }
+    it { is_expected.to be_instance_of Faraday::Connection }
+  end
+
+  describe '#archive' do
+    let(:slug) { "slug" }
+
+    subject { client.archive(slug) }
+
+    it "calls #connection.delete with given slug" do
+      expect(client.connection).to receive(:delete).with(slug, token: token)
+      subject
+    end
+
+    it "parses the json response" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    context 'when given status 401' do
+      let(:status) { 401 }
+
+      it "throws an unauthorized error" do
+        expect { subject }.to raise_exception SearchKit::Errors::Unauthorized
+      end
+    end
+
+    context 'when given status 404' do
+      let(:status) { 404 }
+
+      it "throws a not found error" do
+        expect { subject }.to raise_exception SearchKit::Errors::IndexNotFound
+      end
+    end
+  end
+
+  describe '#create' do
+    let(:name) { "name" }
+
+    let(:params) do
+      { token: token, data: { type: 'indices', attributes: { name: name } } }
+    end
+
+    subject { client.create(name) }
+
+    it "calls #connection.post with given name" do
+      expect(client.connection).to receive(:post).with('', params)
+      subject
+    end
+
+    it "parses the json response" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    context 'when given status 400' do
+      let(:status) { 400 }
+
+      it "throws a Bad Request error" do
+        expect { subject }.to raise_exception SearchKit::Errors::BadRequest
+      end
+    end
+    context 'when given status 401' do
+      let(:status) { 401 }
+
+      it "throws an unauthorized error" do
+        expect { subject }.to raise_exception SearchKit::Errors::Unauthorized
+      end
+    end
+
+    context 'when given status 422' do
+      let(:status) { 422 }
+
+      it "throws an Unprocessable error" do
+        expect { subject }.to raise_exception SearchKit::Errors::Unprocessable
+      end
+    end
+
+  end
+
+  describe '#show' do
+    let(:slug) { "slug" }
+
+    subject { client.show(slug) }
+
+    it "calls #connection.get with given slug" do
+      expect(client.connection).to receive(:get).with(slug, token: token)
+      subject
+    end
+
+    it "parses the json response" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    context 'when given status 401' do
+      let(:status) { 401 }
+
+      it "throws an unauthorized error" do
+        expect { subject }.to raise_exception SearchKit::Errors::Unauthorized
+      end
+    end
+
+    context 'when given status 404' do
+      let(:status) { 404 }
+
+      it "throws a not found error" do
+        expect { subject }.to raise_exception SearchKit::Errors::IndexNotFound
+      end
+    end
+
+  end
+
+  describe '#update' do
+    let(:new_name) { "New name" }
+    let(:slug)     { "name" }
+
+    let(:params) do
+      {
+        token: token,
+        data: { type: 'indices', attributes: { name: new_name } }
+      }
+    end
+
+    subject { client.update(slug, name: new_name) }
+
+    it "calls #connection.patch with given slug and attributes" do
+      expect(client.connection).to receive(:patch).with(slug, params)
+      subject
+    end
+
+    it "parses the json response" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    context 'when given status 400' do
+      let(:status) { 400 }
+
+      it "throws a bad request error" do
+        expect { subject }.to raise_exception SearchKit::Errors::BadRequest
+      end
+    end
+
+    context 'when given status 401' do
+      let(:status) { 401 }
+
+      it "throws an unauthorized error" do
+        expect { subject }.to raise_exception SearchKit::Errors::Unauthorized
+      end
+    end
+
+    context 'when given status 404' do
+      let(:status) { 404 }
+
+      it "throws a not found error" do
+        expect { subject }.to raise_exception SearchKit::Errors::IndexNotFound
+      end
+    end
+
+    context 'when given status 422' do
+      let(:status) { 422 }
+
+      it "throws an unprocessable error" do
+        expect { subject }.to raise_exception SearchKit::Errors::Unprocessable
+      end
+    end
+
+  end
+end