search-kit 0.0.3 → 0.0.4

data/spec/search_kit/clients/search_spec.rb

@@ -0,0 +1,87 @@
+require 'ostruct'
+require 'spec_helper'
+
+describe SearchKit::Clients::Search do
+  let(:client)        { described_class.new }
+  let(:json)          { response_body.to_json }
+  let(:response_body) { { data: {} } }
+  let(:response)      { OpenStruct.new(body: json, status: status) }
+  let(:status)        { 200 }
+  let(:token)         { SearchKit.config.app_token }
+
+  before do
+    allow(client.connection).to receive(:post).and_return(response)
+    allow(JSON).to receive(:parse).and_return(response_body)
+  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 '#search' do
+    let(:filters) { { size: 10.5, width: "Wide", gender: "Mens" } }
+    let(:options) { { phrase: phrase, filters: filters } }
+    let(:phrase)  { "red boots" }
+    let(:slug)    { "an-index-slug" }
+
+    let(:params) do
+      {
+        token: token,
+        data: { type: 'searches', attributes: options }
+      }
+    end
+
+    subject { client.search(slug, options) }
+
+    it { is_expected.to be_instance_of SearchKit::Models::Search }
+
+    it "calls #connection.get with the base events path" 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 an unauthorized 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
+end

data/spec/search_kit/clients/subscribers_spec.rb

@@ -0,0 +1,166 @@
+require 'ostruct'
+require 'spec_helper'
+
+describe SearchKit::Clients::Subscribers do
+  let(:client)        { described_class.new }
+  let(:email)         { "email@example.com" }
+  let(:json)          { response_body.to_json }
+  let(:password)      { "password" }
+  let(:response_body) { { data: {} } }
+  let(:response)      { OpenStruct.new(status: status, body: json) }
+  let(:subscriber)    { SearchKit::Models::Subscriber.new }
+  let(:status)        { 200 }
+  let(:token)         { SearchKit.config.app_token }
+
+  before do
+    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)
+    allow(JSON).to receive(:parse).and_return(response_body)
+  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(:params) do
+      {
+        data: {
+          type: 'subscribers',
+          attributes: { email: email, password: password }
+        }
+      }
+    end
+
+    subject { client.create(email: email, password: password) }
+
+    it { is_expected.to be_instance_of SearchKit::Models::Subscriber }
+
+    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 422' do
+      let(:status) { 422 }
+
+      it "throws an unprocessable error" do
+        expect { subject }.to raise_exception SearchKit::Errors::Unprocessable
+      end
+    end
+
+  end
+
+  describe '#info' do
+    subject { client.info }
+
+    it { is_expected.to be_instance_of SearchKit::Models::Subscriber }
+
+    it "calls #connection.get" 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 "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::SubscriberNotFound
+      end
+    end
+
+  end
+
+  describe '#update' do
+    let(:params) do
+      {
+        token: token,
+        data: {
+          type: 'subscribers',
+          attributes: { email: email, password: password }
+        }
+      }
+    end
+
+    subject { client.update(email: email, password: password) }
+
+    it { is_expected.to be_instance_of SearchKit::Models::Subscriber }
+
+    it "calls #connection.patch with given id and attributes" do
+      expect(client.connection).to receive(:patch).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 a not found 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::SubscriberNotFound
+      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

data/spec/search_kit/configuration_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe SearchKit::Configuration do
+  let(:klass) { Class.new }
+
+  before { klass.extend(described_class) }
+
+  subject { klass }
+
+  it { is_expected.to respond_to :config }
+  it { is_expected.to respond_to :configure }
+
+  describe "Arbitrary assignment" do
+    it "allows any arbitrary setting to hold a value" do
+      expect {
+        klass.configure do |config|
+          config.arbitrary_setting = "value"
+        end
+      }.to change { klass.config.arbitrary_setting }
+        .from(nil)
+        .to("value")
+    end
+  end
+
+end

data/spec/search_kit/messages_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe SearchKit::Messages do
+  let(:messages) { described_class.new }
+  let(:message) { "Just about any string" }
+
+  before do
+    SearchKit.config.verbose = true
+
+    allow(Kernel).to receive(:warn)
+    allow(Kernel).to receive(:puts)
+    allow(SearchKit.logger).to receive(:warn)
+    allow(SearchKit.logger).to receive(:info)
+  end
+
+  after { SearchKit.config.verbose = false }
+
+  describe "#info" do
+    subject { messages.info(message) }
+
+    it "warns in stderr" do
+      expect(Kernel).to receive(:puts)
+      subject
+    end
+
+    it "logs a warning" do
+      expect(SearchKit.logger).to receive(:info).with(message)
+      subject
+    end
+  end
+
+  describe "#warning" do
+    subject { messages.warning(message) }
+
+    it "warns in stderr" do
+      expect(Kernel).to receive(:warn)
+      subject
+    end
+
+    it "logs a warning" do
+      expect(SearchKit.logger).to receive(:warn).with(message)
+      subject
+    end
+  end
+end

data/spec/search_kit/models/document_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe SearchKit::Models::Document do
+  let(:document_data) { {} }
+  let(:document) { described_class.new(document_data) }
+
+  subject { document }
+
+  it { is_expected.to respond_to :id }
+  it { is_expected.to respond_to :source }
+  it { is_expected.to respond_to :score }
+
+  describe '#get' do
+    let(:key) { :a_key }
+
+    subject { document.get(key) }
+
+    context 'when the source has the available content' do
+      let(:content)       { :key_content }
+      let(:document_data) { { attributes: { key => content } } }
+
+      it "returns the content" do
+        expect(subject).to eq content
+      end
+    end
+
+    context 'otherwise' do
+      it "raises an attribute not found error" do
+        expect { subject }
+          .to raise_exception(described_class::AttributeNotFound)
+      end
+    end
+  end
+end

data/spec/search_kit/models/documents_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe SearchKit::Models::Documents do
+  let(:document_data) { [{}] }
+  let(:documents)     { described_class.new(document_data) }
+
+  subject { documents }
+
+  it { is_expected.to respond_to :contents }
+  it { is_expected.to respond_to :each }
+
+end

data/spec/search_kit/models/event_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe SearchKit::Models::Event do
+  let(:event_data) { {} }
+  let(:event) { described_class.new(event_data) }
+
+  subject { event }
+
+  it { is_expected.to respond_to :id }
+  it { is_expected.to respond_to :channel }
+  it { is_expected.to respond_to :payload }
+  it { is_expected.to respond_to :state }
+
+end

data/spec/search_kit/models/events_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe SearchKit::Models::Events do
+  let(:event_data) { [{}] }
+  let(:events)     { described_class.new(event_data) }
+
+  subject { events }
+
+  it { is_expected.to respond_to :contents }
+  it { is_expected.to respond_to :each }
+
+end

data/spec/search_kit/models/key_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe SearchKit::Models::Key do
+  let(:model) { described_class.new }
+
+  subject { model }
+
+  it { is_expected.to be_instance_of SearchKit::Models::Key }
+  it { is_expected.to respond_to :uri }
+  it { is_expected.to respond_to :token }
+  it { is_expected.to respond_to :name }
+
+  describe '#creator?' do
+    subject { model.creator? }
+    
+    context 'when #privilege is set to "creator"' do
+      before { model.privilege = 'creator' }
+      it { is_expected.to be true }
+    end
+
+    context 'otherwise' do
+      it { is_expected.to be false }
+    end
+  end
+
+end

data/spec/search_kit/models/keys_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe SearchKit::Models::Keys do
+  let(:creator_key) do
+    SearchKit::Models::Key.new(
+      attributes: {
+        privilege: 'creator',
+        token:     creator_token
+      }
+    )
+  end
+
+  let(:consumer_key) do
+    SearchKit::Models::Key.new(
+      attributes: {
+        privilege: 'consumer',
+        token:     consumer_token
+      }
+    )
+  end
+
+  let(:creator_token)  { "12345" }
+  let(:consumer_token) { "67890" }
+  let(:keys)           { [ creator_key, consumer_key ] }
+  let(:model)          { described_class.new(keys) }
+
+  subject { model }
+
+  describe "#creator" do
+    subject { model.creator }
+    it { is_expected.to be_instance_of described_class }
+    it { is_expected.to match described_class.new([creator_key]) }
+  end
+
+  describe "#tokens" do
+    subject { model.tokens }
+    it { is_expected.to match [creator_token, consumer_token] }
+  end
+end