gecko 0.0.1

data/spec/gecko/pie_spec.rb

@@ -0,0 +1,36 @@
+require 'helper'
+
+describe Gecko::Widget::Pie do
+  it_behaves_like "a Gecko::Widget"
+
+  describe '#payload' do
+    before(:each) do
+      @widget = described_class.new('widget_key')
+    end
+
+    it 'should be empty by default' do
+      expect(@widget.payload).to be_a_valid_payload(
+        TEST_API_KEY,
+        {
+          :item => []
+        }
+      )
+    end
+
+    it 'should be correct hash when values assigned' do
+      @widget.add(1, 'first', '#cc0000')
+      @widget.add(2, 'second', '#ffffff')
+      @widget.add(3, 'third')
+      expect(@widget.payload).to be_a_valid_payload(
+        TEST_API_KEY,
+        {
+          :item => [
+            {:value => 1, :label => 'first', :colour => '#cc0000'},
+            {:value => 2, :label => 'second', :colour => '#ffffff'},
+            {:value => 3, :label => 'third'},
+          ]
+        }
+      )
+    end
+  end
+end

data/spec/gecko/rag_spec.rb

@@ -0,0 +1,48 @@
+require 'helper'
+
+shared_examples "a RAG" do
+  it_behaves_like "a Gecko::Widget"
+
+  describe '#payload' do
+    before(:each) do
+      @widget = described_class.new('widget_key')
+    end
+
+    it 'should be empty by default' do
+      expect(@widget.payload).to be_a_valid_payload(
+       TEST_API_KEY,
+       {:item => [
+         {:value => nil, :text => nil},
+         {:value => nil, :text => nil},
+         {:value => nil, :text => nil}
+       ]}
+     )
+    end
+
+    it 'should be correct hash when values assigned' do
+      @widget.green_text = 'green text'
+      @widget.green_value = 1
+      @widget.amber_text = 'amber text'
+      @widget.amber_value = 2
+      @widget.red_text = 'red text'
+      @widget.red_value = 3
+
+      expect(@widget.payload).to be_a_valid_payload(
+        TEST_API_KEY,
+        {:item => [
+          {:value => 3, :text => 'red text'},
+          {:value => 2, :text => 'amber text'},
+          {:value => 1, :text => 'green text'},
+        ]}
+      )
+    end
+  end
+end
+
+describe Gecko::Widget::Rag do
+  it_behaves_like "a RAG"
+end
+
+describe Gecko::Widget::RagColumns do
+  it_behaves_like "a RAG"
+end

data/spec/gecko/text_spec.rb

@@ -0,0 +1,49 @@
+require 'helper'
+
+describe Gecko::Widget::Text do
+  it_behaves_like "a Gecko::Widget"
+
+  describe described_class::Item do
+    describe '#initialize' do
+      it 'should raise error if undefined type given' do
+        expect{ described_class::Item.new('text', :undefined_type) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#reset' do
+    before(:each) do
+      @widget = described_class.new('widget_key')
+      @widget.add('this is test')
+    end
+    it 'should clear items' do
+      @widget.reset
+      expect(@widget.count).to be(0)
+    end
+  end
+
+  describe '#payload' do
+    before(:each) do
+      @widget = described_class.new('widget_key')
+    end
+
+    it 'should be empty by default' do
+      expect(@widget.payload).to be_a_valid_payload(
+        TEST_API_KEY,
+        {:item => []}
+      )
+    end
+
+    it 'should be correct hash when values assigned' do
+      @widget.add('this is the text')
+      @widget.add('more text', :alert)
+      expect(@widget.payload).to be_a_valid_payload(
+        TEST_API_KEY,
+        {:item => [
+          {:text => 'this is the text', :type => described_class::Item::TYPES[:normal]},
+          {:text => 'more text', :type => described_class::Item::TYPES[:alert]}
+        ]}
+      )
+    end
+  end
+end

data/spec/gecko_spec.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+describe Gecko do
+  describe '#config' do
+    it 'should return a config object' do
+      expect(described_class.config).to be_a described_class::Configurator
+    end
+
+    it 'should yield config object' do
+      expect{ |p| described_class.config(&p) }.to yield_with_args(described_class::Configurator)
+    end
+
+    it 'should allow setting/getting #api_key' do
+      api_key = 'abc1234'
+      described_class.config.api_key = api_key
+      described_class.config.api_key.should eql api_key
+    end
+
+    it '#http_builder by default should not respond to call' do
+      described_class.config.http_builder # nil out any previous values
+      expect(described_class.config.connection_builder.respond_to?(:call)).to be_false
+    end
+
+    it '#http_builder should allow setting via block' do
+      proc = Proc.new { 1 }
+      described_class.config.http_builder(&proc)
+      expect(described_class.config.connection_builder.respond_to?(:call)).to be_true
+      expect(described_class.config.connection_builder).to be proc
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,25 @@
+require 'gecko'
+require 'rspec'
+
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
+
+Faraday.default_adapter = :test
+
+RSpec::Matchers.define :be_a_valid_payload do |api_key, data|
+  def payload(api_key, data)
+    {:api_key => api_key, :data => data}
+  end
+  match do |actual|
+    actual.kind_of?(Hash) && actual == payload(api_key, data)
+  end
+  failure_message_for_should do |actual|
+    "expected that\n#{actual.inspect}\nwould be\n#{payload(api_key, data).inspect}"
+  end
+end
+
+# Thanks https://gist.github.com/1428875
+class MockBlock
+  def to_proc
+    lambda { |*a| call(*a) }
+  end
+end

data/spec/http_spec.rb

@@ -0,0 +1,141 @@
+require 'helper'
+
+describe Gecko::Http do
+  def stub_post(url, request_body = {}, &response)
+    stub = Faraday::Adapter::Test::Stubs.new do |stub|
+      stub.post(url, MultiJson.encode(request_body), &response)
+    end
+    described_class.new do |builder|
+      builder.adapter :test, stub
+    end
+  end
+
+  describe '#initialize' do
+    after(:all) do
+      # reset config
+      Gecko.config.http_builder {  }
+    end
+
+    it 'should yield connection builder' do
+      expect{ |p| described_class.new(&p) }.to yield_with_args(Faraday::Connection)
+    end
+
+    it 'should use Gecko.config.connection_builder' do
+      Gecko.config.http_builder { |c|
+        expect(c).to be_a(Faraday::Connection)
+      }
+      Gecko.config.connection_builder.should_receive(:call).and_call_original
+      described_class.new
+    end
+  end
+
+  describe '#post' do
+    it 'fails if non-json result given' do
+      http = stub_post('/test', {:test => true}) { [200, {}, 'caca'] }
+      expect { http.post('/test', {:test => true}) }.to raise_exception(MultiJson::DecodeError)
+    end
+
+    it 'should return a Result object' do
+      http = stub_post('/test', {:test => true}) { [200, {}, MultiJson.encode({})] }
+      expect(http.post('/test', {:test => true})).to be_a(described_class::Result)
+    end
+
+    it 'should yield a Faraday::Request instance' do
+      http = stub_post('/test', {:test => true}) { [200, {}, MultiJson.encode({})] }
+      expect { |p| http.post('/test', {:test => true}, &p) }.to yield_with_args(Faraday::Request)
+    end
+
+    describe described_class::Result do
+      context 'success response' do
+        before(:each) do
+          @http = stub_post('/test', {:test => true}) { [200, {}, MultiJson.encode({:success => true, :other_key => {:nested_key => 1234}})] }
+          @response = @http.post('/test', {:test => true})
+        end
+
+        it '#response_body should be a converted from JSON' do
+          expect(@response.response_body).to eq({:success => true, :other_key => {:nested_key => 1234}})
+        end
+
+        it '#http_200? should be true' do
+          expect(@response.http_200?).to be_true
+        end
+
+        it '#error? should be false' do
+          expect(@response.error?).to be_false
+        end
+
+        it '#success? should be true' do
+          expect(@response.success?).to be_true
+        end
+
+        it '#fetch should work with nested keys' do
+          expect(@response.fetch(:other_key, :nested_key)).to eq(1234)
+        end
+
+        it '#fetch should return nil if key does not exist' do
+          expect(@response.fetch(:weird_key, :nested_key)).to be_nil
+        end
+
+        it '#error should return an Error instance' do
+          expect(@response.error).to be_a(described_class::Result::Error)
+        end
+
+        it '#error should be empty' do
+          error = @response.error
+          expect(error.text).to be_nil
+          expect(error.status).to eq(200)
+        end
+
+        it '#on_complete should call block with correct params' do
+          expect{ |p| @response.on_complete(&p) }.to yield_with_args(true, described_class::Result)
+        end
+      end
+
+      context 'error response' do
+        before(:each) do
+          @http = stub_post('/test', {:test => true}) { [400, {}, MultiJson.encode({:success => false, :error => {:nested_key => 1234}})] }
+          @response = @http.post('/test', {:test => true})
+        end
+
+        it '#response_body should be a converted from JSON' do
+          expect(@response.response_body).to eq({:success => false, :error => {:nested_key => 1234}})
+        end
+
+        it '#http_200? should be true' do
+          expect(@response.http_200?).to be_false
+        end
+
+        it '#error? should be false' do
+          expect(@response.error?).to be_true
+        end
+
+        it '#success? should be true' do
+          expect(@response.success?).to be_false
+        end
+
+        it '#fetch should work with nested keys' do
+          expect(@response.fetch(:error, :nested_key)).to eq(1234)
+        end
+
+        it '#fetch should return nil if key does not exist' do
+          expect(@response.fetch(:weird_key, :nested_key)).to be_nil
+        end
+
+        it '#error should return an Error instance' do
+          expect(@response.error).to be_a(described_class::Result::Error)
+        end
+
+        it '#error should be populated' do
+          error = @response.error
+          expect(error.text).to eq({:nested_key => 1234})
+          expect(error.status).to eq(400)
+        end
+
+        it '#on_complete should call block with correct params' do
+          expect { |p| @response.on_complete(&p) }.to yield_with_args(false, described_class::Result)
+        end
+      end
+    end
+  end
+
+end

data/spec/support/shared_examples_for_widget.rb

@@ -0,0 +1,64 @@
+require 'helper'
+
+TEST_API_KEY = 'gecko.rb-api_key'
+shared_examples 'a Gecko::Widget' do
+  before(:all) do
+    Gecko.config do |c|
+      c.api_key = TEST_API_KEY
+    end
+  end
+
+  describe '#initialize' do
+    it 'should receive a list of keys' do
+      widget = described_class.new('widget_key_A', 'widget_key_B')
+      expect(widget.keys).to eq(['widget_key_A', 'widget_key_B'])
+    end
+
+    it 'should receive an array' do
+      widget = described_class.new(['widget_key_A', 'widget_key_B'])
+      expect(widget.keys).to eq(['widget_key_A', 'widget_key_B'])
+    end
+
+    it 'should yield itself to a block' do
+      expect { |p| described_class.new('widget_key', &p) }.to yield_with_args(described_class)
+    end
+
+    it 'should raise error if no keys given' do
+      expect { described_class.new }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#keys=' do
+    before(:each) do
+      @widget = described_class.new('key')
+    end
+    it 'should receive a key' do
+      @widget.keys = 'widget_key_A'
+      expect(@widget.keys).to eq(['widget_key_A'])
+    end
+
+    it 'should receive a list of keys' do
+      @widget.keys = 'widget_key_A', 'widget_key_B'
+      expect(@widget.keys).to eq(['widget_key_A', 'widget_key_B'])
+    end
+
+    it 'should receive an array of keys' do
+      @widget.keys = ['widget_key_A', 'widget_key_B']
+      expect(@widget.keys).to eq(['widget_key_A', 'widget_key_B'])
+    end
+  end
+
+  describe '#keys' do
+    it 'should be an array' do
+      widget = described_class.new('widget_key_1234')
+      expect(widget.keys).to be_kind_of(Array)
+    end
+  end
+
+  describe '#config' do
+    it 'should yield self' do
+      widget = described_class.new('widget_key_1234')
+      expect { |p| widget.config(&p) }.to yield_with_args(widget)
+    end
+  end
+end

data/spec/widget_spec.rb

@@ -0,0 +1,172 @@
+require 'helper'
+
+describe Gecko::Widget do
+  before(:all) do
+    Gecko.config do |c|
+      c.api_push_url = '/v1/send/:widget_key'
+      c.api_key = TEST_API_KEY
+    end
+  end
+
+  def create_widget(*keys, &response)
+    @widget = described_class.new(*keys)
+    stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+      @widget.keys.each do |key|
+        stub.post(@widget.push_url(key), MultiJson.encode(@widget.payload), &response)
+      end
+    end
+    Gecko.config.http_builder do |builder|
+      builder.adapter :test, stubs
+    end
+  end
+
+  context 'Widget with 1 key, successful response' do
+    before(:each) do
+      create_widget('widget_key1') do
+        [200, {}, MultiJson.encode({:success => true})]
+      end
+    end
+
+    describe '#update' do
+      it 'should return 1 request objects' do
+        update_result = @widget.update
+        expect(update_result).to be_a(Array)
+        expect(update_result).to have(1).items
+        update_result.each do |result|
+          expect(result).to be_a(Gecko::Http::Result)
+        end
+      end
+
+      it 'should evoke callback passed to #update' do
+        callback = MockBlock.new
+        callback.should_receive(:call).once.with do |success, result, key|
+          expect(success).to be_true
+          expect(result).to be_a(Gecko::Http::Result)
+          expect(key).to eq('widget_key1')
+        end
+        @widget.update(&callback)
+      end
+
+      it 'should evoke callback passed to #on_update' do
+        callback = MockBlock.new
+        callback.should_receive(:call).once.with do |success, result, key|
+          expect(success).to be_true
+          expect(result).to be_a(Gecko::Http::Result)
+          expect(key).to eq('widget_key1')
+        end
+        @widget.on_update(&callback)
+        @widget.update
+      end
+
+      context 'response object' do
+        let(:http_response) { @widget.update.first }
+
+        it 'should have no errors' do
+          expect(http_response.error?).to be_false
+        end
+      end
+
+    end
+  end
+
+  context 'Widget with 2 keys, successful response' do
+    before(:each) do
+      create_widget('widget_key1', 'widget_key2') do
+        [200, {}, MultiJson.encode({:success => true})]
+      end
+    end
+
+    describe '#update' do
+      it 'should return 2 request objects' do
+        update_result = @widget.update
+        expect(update_result).to be_a(Array)
+        expect(update_result).to have(2).items
+        update_result.each do |result|
+          expect(result).to be_a(Gecko::Http::Result)
+        end
+      end
+
+      it 'should evoke callback passed to #update' do
+        callback = MockBlock.new
+        callback.should_receive(:call).twice.with do |success, result, key|
+          expect(success).to be_true
+          expect(result).to be_a(Gecko::Http::Result)
+          expect(key).to match(/widget_key[1|2]/)
+        end
+        @widget.update(&callback)
+      end
+
+      it 'should evoke callback passed to #on_update' do
+        callback = MockBlock.new
+        callback.should_receive(:call).twice.with do |success, result, key|
+          expect(success).to be_true
+          expect(result).to be_a(Gecko::Http::Result)
+          expect(key).to match(/widget_key[1|2]/)
+        end
+        @widget.on_update(&callback)
+        @widget.update
+      end
+
+      context 'response objects' do
+        let(:http_responses) { @widget.update }
+
+        it 'should have no errors' do
+          http_responses.each do |http_response|
+            expect(http_response.error?).to be_false
+          end
+        end
+      end
+    end
+  end
+
+  context 'Widget with 2 keys, errors response' do
+    before(:each) do
+      create_widget('widget_key1', 'widget_key2') do
+        [200, {}, MultiJson.encode({:success => false, :error => 'Push operation failed due to an unknown reason. Please try again!'})]
+      end
+    end
+
+    describe '#update' do
+      it 'should return 2 request objects' do
+        update_result = @widget.update
+        expect(update_result).to be_a(Array)
+        expect(update_result).to have(2).items
+        update_result.each do |result|
+          expect(result).to be_a(Gecko::Http::Result)
+        end
+      end
+
+      it 'should evoke callback passed to #update' do
+        callback = MockBlock.new
+        callback.should_receive(:call).twice.with do |success, result, key|
+          expect(success).to be_false
+          expect(result).to be_a(Gecko::Http::Result)
+          expect(key).to match(/widget_key[1|2]/)
+        end
+        @widget.update(&callback)
+      end
+
+      it 'should evoke callback passed to #on_update' do
+        callback = MockBlock.new
+        callback.should_receive(:call).twice.with do |success, result, key|
+          expect(success).to be_false
+          expect(result).to be_a(Gecko::Http::Result)
+          expect(key).to match(/widget_key[1|2]/)
+        end
+        @widget.on_update(&callback)
+        @widget.update
+      end
+
+      context 'response objects' do
+        let(:http_responses) { @widget.update }
+
+        it 'should have errors' do
+          http_responses.each do |http_response|
+            expect(http_response.error?).to be_true
+            expect(http_response.error.to_s).to eq('Push operation failed due to an unknown reason. Please try again!')
+          end
+        end
+      end
+    end
+  end
+end