search-kit 0.0.3 → 0.0.4

data/search-kit.gemspec

@@ -14,23 +14,18 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/qbox-io/search-kit"
   spec.license       = "MIT"
 
-  spec.bindir        = "bin"
+  spec.files         = Dir.glob('**/*')
+  spec.test_files    = Dir.glob('spec/**/*')
   spec.require_paths = ["lib"]
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |file|
-    file.match(%r{^(test|spec|features)/})
-  end
-
-  spec.executables   = spec.files.grep(%r{^bin/}) do |file|
-    File.basename(file)
-  end
+  spec.executables   << 'search-kit'
 
   spec.add_dependency "ansi", "~> 1.5"
   spec.add_dependency "faraday", "~> 0.9"
-  spec.add_dependency "thor", "~> 0.19"
-  spec.add_dependency "user_config", "~> 0.0"
   spec.add_dependency "highline", "~> 1.7"
   spec.add_dependency "i18n", "~> 0.7"
+  spec.add_dependency "thor", "~> 0.19"
+  spec.add_dependency "user_config", "~> 0.0"
   spec.add_dependency "virtus", "~> 1.0"
 
   spec.add_development_dependency "bundler", "~> 1.8"
@@ -40,5 +35,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rack-test", "~> 0.6"
   spec.add_development_dependency "simplecov", "~> 0.10"
   spec.add_development_dependency "ruby-prof", "~> 0.15"
-
 end

data/spec/integrations/subscriber_model_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe "Modeling incoming subscriber data" do
+  let(:subscriber_id) { "5659f64d21de3bfe6c000004" }
+  let(:subscriber_email) { "joseph@qbox.io" }
+  let(:subscriber_uri) { "/api/subscribers" }
+
+  let(:key_token) { "2bad61a9ea4f5adf1d36952e59ddda2b" }
+  let(:key_name) { "Universal access key" }
+  let(:key_id) { "5659f64d21de3bfe6c000005" }
+  let(:key_uri) { "/api/keys/5659f64d21de3bfe6c000005" }
+
+  let(:response) do
+    {
+      data: {
+        type:       "subscribers",
+        id:         subscriber_id,
+        attributes: { id: subscriber_id, email: subscriber_email },
+        links:      { self: subscriber_uri },
+        relationships: {
+          keys: [
+            {
+              type: "keys",
+              id:   key_id,
+              attributes: {
+                id:        key_id,
+                name:      key_name,
+                token:     key_token,
+                privilege: "creator"
+              },
+              links: { self: key_uri }
+            }
+          ]
+        }
+      }
+    }
+  end
+
+  let(:subscriber) do
+    SearchKit::Models::Subscriber.new(response.fetch(:data))
+  end
+
+  subject { subscriber }
+
+  describe '#creator_tokens' do
+    subject { subscriber.creator_tokens.first }
+    it { is_expected.to eq key_token }
+  end
+
+  describe '#email' do
+    subject { subscriber.email }
+    it { is_expected.to eq subscriber_email }
+  end
+
+  describe '#id' do
+    subject { subscriber.id }
+    it { is_expected.to eq subscriber_id }
+  end
+
+  describe '#keys' do
+    let(:key) { subscriber.keys.first }
+
+    subject { key }
+
+    describe '#id' do
+      subject { key.id }
+      it { is_expected.to eq key_id }
+    end
+
+    describe '#name' do
+      subject { key.name }
+      it { is_expected.to eq key_name }
+    end
+
+    describe '#token' do
+      subject { key.token }
+      it { is_expected.to eq key_token }
+    end
+
+    describe '#uri' do
+      subject { key.uri }
+      it { is_expected.to eq key_uri }
+    end
+  end
+
+  describe '#uri' do
+    subject { subscriber.uri }
+    it { is_expected.to eq subscriber_uri }
+  end
+
+end

data/spec/search_kit/cli/documents_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+describe SearchKit::CLI::Documents do
+  let(:cli)      { described_class.new }
+  let(:json)     { response.to_json }
+  let(:response) { {} }
+  let(:slug)     { "an-index-slug" }
+
+  subject { cli }
+
+  describe '#create' do
+    before { allow(cli.client).to receive(:create).and_return(response) }
+
+    subject { cli.create(slug, json) }
+
+    it "parses the given document json" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    it "calls client.create with the slug and document" do
+      expect(cli.client).to receive(:create).with(slug, {})
+      subject
+    end
+
+    it "reports on its results" do
+      expect(cli.messages).to receive(:info).with(response.to_json)
+      subject
+    end
+
+    context 'when given bad json' do
+      let(:json) { "Arglebargle" }
+      it "reports an error" do
+        expect(cli.messages).to receive(:json_parse_error)
+        subject
+      end
+    end
+
+    context 'error handling' do
+      before { allow(cli.client).to receive(:create).and_raise(*error) }
+
+      context 'not found error' do
+        let(:error) { SearchKit::Errors::IndexNotFound }
+
+        it do
+          expect(cli.messages).to receive(:not_found)
+          subject
+        end
+      end
+
+      context 'bad request error' do
+        let(:error) { SearchKit::Errors::BadRequest }
+
+        it do
+          expect(cli.messages).to receive(:bad_request)
+          subject
+        end
+      end
+
+      context 'unprocessable error' do
+        let(:error) { SearchKit::Errors::Unprocessable }
+
+        it do
+          expect(cli.messages).to receive(:unprocessable)
+          subject
+        end
+      end
+
+      context 'not found error' do
+        let(:error) { [Faraday::ConnectionFailed, "Message"] }
+
+        it do
+          expect(cli.messages).to receive(:no_service)
+          subject
+        end
+      end
+
+    end
+  end
+
+  describe '#delete' do
+    let(:id) { 1 }
+
+    before { allow(cli.client).to receive(:delete).and_return(response) }
+
+    subject { cli.delete(slug, id) }
+
+    it "calls client.create with the slug and document" do
+      expect(cli.client).to receive(:delete).with(slug, id)
+      subject
+    end
+
+    it "reports on its results" do
+      expect(cli.messages).to receive(:info).with(response.to_json)
+      subject
+    end
+
+    context 'error handling' do
+      before { allow(cli.client).to receive(:delete).and_raise(*error) }
+
+      context 'not found error' do
+        let(:error) { SearchKit::Errors::IndexNotFound }
+
+        it do
+          expect(cli.messages).to receive(:not_found)
+          subject
+        end
+      end
+
+      context 'not found error' do
+        let(:error) { [Faraday::ConnectionFailed, "Message"] }
+
+        it do
+          expect(cli.messages).to receive(:no_service)
+          subject
+        end
+      end
+
+    end
+  end
+
+  describe '#show' do
+    let(:id) { 1 }
+
+    before { allow(cli.client).to receive(:show).and_return(response) }
+
+    subject { cli.show(slug, id) }
+
+    it "calls client.create with the slug and document" do
+      expect(cli.client).to receive(:show).with(slug, id)
+      subject
+    end
+
+    it "reports on its results" do
+      expect(cli.messages).to receive(:info).with(response.to_json)
+      subject
+    end
+
+    context 'error handling' do
+      before { allow(cli.client).to receive(:show).and_raise(*error) }
+
+      context 'not found error' do
+        let(:error) { SearchKit::Errors::IndexNotFound }
+
+        it do
+          expect(cli.messages).to receive(:not_found)
+          subject
+        end
+      end
+
+      context 'not found error' do
+        let(:error) { [Faraday::ConnectionFailed, "Message"] }
+
+        it do
+          expect(cli.messages).to receive(:no_service)
+          subject
+        end
+      end
+
+    end
+  end
+
+  describe '#update' do
+    let(:id) { 1 }
+
+    before { allow(cli.client).to receive(:update).and_return(response) }
+
+    subject { cli.update(slug, id, json) }
+
+    it "parses the given document json" do
+      expect(JSON).to receive(:parse).with(json, symbolize_names: true)
+      subject
+    end
+
+    it "calls client.create with the slug and document" do
+      expect(cli.client).to receive(:update).with(slug, id, {})
+      subject
+    end
+
+    it "reports on its results" do
+      expect(cli.messages).to receive(:info).with(response.to_json)
+      subject
+    end
+
+    context 'when given bad json' do
+      let(:json) { "Arglebargle" }
+      it "reports an error" do
+        expect(cli.messages).to receive(:json_parse_error)
+        subject
+      end
+    end
+
+    context 'error handling' do
+      before { allow(cli.client).to receive(:update).and_raise(*error) }
+
+      context 'not found error' do
+        let(:error) { SearchKit::Errors::IndexNotFound }
+
+        it do
+          expect(cli.messages).to receive(:not_found)
+          subject
+        end
+      end
+
+      context 'bad request error' do
+        let(:error) { SearchKit::Errors::BadRequest }
+
+        it do
+          expect(cli.messages).to receive(:bad_request)
+          subject
+        end
+      end
+
+      context 'unprocessable error' do
+        let(:error) { SearchKit::Errors::Unprocessable }
+
+        it do
+          expect(cli.messages).to receive(:unprocessable)
+          subject
+        end
+      end
+
+      context 'not found error' do
+        let(:error) { [Faraday::ConnectionFailed, "Message"] }
+
+        it do
+          expect(cli.messages).to receive(:no_service)
+          subject
+        end
+      end
+
+    end
+  end
+end

data/spec/search_kit/cli/events_spec.rb

@@ -0,0 +1,243 @@
+require 'spec_helper'
+
+describe SearchKit::CLI::Events do
+  let(:channel)  { "colon:separated:values" }
+  let(:cli)      { described_class.new }
+  let(:json)     { response.to_json }
+  let(:response) { {} }
+  let(:event)    { SearchKit::Models::Event.new }
+  let(:events)   { SearchKit::Models::Events.new }
+  let(:slug)     { "an-index-slug" }
+
+  subject { cli }
+
+  describe '#complete' do
+    let(:id) { 1 }
+
+    before { allow(cli.client).to receive(:complete).and_return(event) }
+
+    subject { cli.complete(id) }
+
+    it "calls client.complete with the event id" do
+      expect(cli.client).to receive(:complete).with(id)
+      subject
+    end
+
+    it "reports on its results" do
+      expect(cli.messages).to receive(:info).with(an_instance_of(String))
+      subject
+    end
+
+    context 'error handling' do
+      before { allow(cli.client).to receive(:complete).and_raise(*error) }
+
+      context 'not found error' do
+        let(:error) { SearchKit::Errors::EventNotFound }
+
+        it do
+          expect(cli.messages).to receive(:not_found)
+          subject
+        end
+      end
+
+      context 'not found error' do
+        let(:error) { [Faraday::ConnectionFailed, "Message"] }
+
+        it do
+          expect(cli.messages).to receive(:no_service)
+          subject
+        end
+      end
+    end
+  end
+
+  describe '#pending' do
+    before do
+      allow(cli.client).to receive(:index).and_return(events)
+      allow(cli.client).to receive(:pending).and_return(events)
+    end
+
+    subject { cli.pending(channel) }
+
+    context 'when given a channel' do
+      it "calls client.pending with the channel" do
+        expect(cli.client).to receive(:pending).with(channel)
+        subject
+      end
+    end
+
+    context 'otherwise' do
+      let(:channel) { nil }
+
+      it "calls client.index" do
+        expect(cli.client).to receive(:index)
+        subject
+      end
+    end
+
+    it "reports on its results" do
+      expect(cli.messages).to receive(:info).with(an_instance_of(String))
+      subject
+    end
+
+    context 'error handling' do
+      before do
+        allow(cli.client).to receive(:index).and_raise(*error)
+        allow(cli.client).to receive(:pending).and_raise(*error)
+      end
+
+      context 'not found error' do
+        let(:error) { SearchKit::Errors::Unauthorized }
+
+        it do
+          expect(cli.messages).to receive(:unauthorized)
+          subject
+        end
+      end
+
+      context 'bad request error' do
+        let(:error) { SearchKit::Errors::BadRequest }
+
+        it do
+          expect(cli.messages).to receive(:bad_request)
+          subject
+        end
+      end
+
+      context 'unprocessable error' do
+        let(:error) { SearchKit::Errors::Unprocessable }
+
+        it do
+          expect(cli.messages).to receive(:unprocessable)
+          subject
+        end
+      end
+
+      context 'not found error' do
+        let(:error) { [Faraday::ConnectionFailed, "Message"] }
+
+        it do
+          expect(cli.messages).to receive(:no_service)
+          subject
+        end
+      end
+
+    end
+  end
+
+  describe '#publish' do
+    let(:payload)      { { one_fish: true, two_fish: true } }
+    let(:payload_json) { payload.to_json }
+
+    before do
+      allow(cli.client).to receive(:publish).and_return(event)
+    end
+
+    subject { cli.publish(channel, payload_json) }
+
+    it "parses the given document json" do
+      expect(JSON).to receive(:parse).with(payload_json, symbolize_names: true)
+      subject
+    end
+
+    it "calls client.create with the slug and document" do
+      expect(cli.client).to receive(:publish).with(channel, payload)
+      subject
+    end
+
+    it "reports on its results" do
+      expect(cli.messages).to receive(:info).with(an_instance_of(String))
+      subject
+    end
+
+    context 'when given bad json' do
+      let(:payload) { "Arglebargle" }
+
+      it "reports an error" do
+        expect(cli.messages).to receive(:json_parse_error)
+        subject
+      end
+    end
+
+    context 'error handling' do
+      before { allow(cli.client).to receive(:publish).and_raise(*error) }
+
+      context 'not found error' do
+        let(:error) { SearchKit::Errors::Unauthorized }
+
+        it do
+          expect(cli.messages).to receive(:unauthorized)
+          subject
+        end
+      end
+
+      context 'bad request error' do
+        let(:error) { SearchKit::Errors::BadRequest }
+
+        it do
+          expect(cli.messages).to receive(:bad_request)
+          subject
+        end
+      end
+
+      context 'unprocessable error' do
+        let(:error) { SearchKit::Errors::Unprocessable }
+
+        it do
+          expect(cli.messages).to receive(:unprocessable)
+          subject
+        end
+      end
+
+      context 'not found error' do
+        let(:error) { [Faraday::ConnectionFailed, "Message"] }
+
+        it do
+          expect(cli.messages).to receive(:no_service)
+          subject
+        end
+      end
+
+    end
+  end
+
+  describe '#status' do
+    let(:id) { 1 }
+
+    before { allow(cli.client).to receive(:show).and_return(event) }
+
+    subject { cli.status(id) }
+
+    it "calls client.show with the event id" do
+      expect(cli.client).to receive(:show).with(id)
+      subject
+    end
+
+    it "reports on its results" do
+      expect(cli.messages).to receive(:info).with(an_instance_of(String))
+      subject
+    end
+
+    context 'error handling' do
+      before { allow(cli.client).to receive(:show).and_raise(*error) }
+
+      context 'not found error' do
+        let(:error) { SearchKit::Errors::EventNotFound }
+
+        it do
+          expect(cli.messages).to receive(:not_found)
+          subject
+        end
+      end
+
+      context 'not found error' do
+        let(:error) { [Faraday::ConnectionFailed, "Message"] }
+
+        it do
+          expect(cli.messages).to receive(:no_service)
+          subject
+        end
+      end
+    end
+  end
+end