tankard 0.1.0 → 0.2.0

data/spec/tankard/api/style_spec.rb

@@ -4,58 +4,139 @@ describe Tankard::Api::Style do
   let(:style) { Tankard::Api::Style.new(@request) }
 
   before do
-    @request = mock("request")
+    @request = double('request')
   end
 
-  describe "#find" do
+  describe '#find' do
 
     before do
-      @request.stub(:get).with("style/1", {}).and_return({ "data" => "valid1_found"})
-      @request.stub(:get).with("style/2", {}).and_return({ "data" => "valid2_found"})
-      @request.stub(:get).with("style/3", {}).and_raise(Tankard::Error::HttpError)
-      @request.stub(:get).with("style/4", {}).and_raise(Tankard::Error::HttpError)
+      @request.stub(:get).with('style/1', {}).and_return('data' => 'valid1_found')
+      @request.stub(:get).with('style/2', {}).and_return('data' => 'valid2_found')
+      @request.stub(:get).with('style/3', {}).and_raise(Tankard::Error::HttpError)
+      @request.stub(:get).with('style/4', {}).and_raise(Tankard::Error::HttpError)
     end
 
-    it_should_behave_like "the find method" do
+    it_should_behave_like 'the find method' do
       let(:context) { style }
       let(:valid_items) { [1, 2] }
-      let(:valid_responses) { ["valid1_found", "valid2_found"] }
+      let(:valid_responses) { %w(valid1_found valid2_found) }
       let(:invalid_items) { [3, 4] }
       let(:valid_invalid_items) { valid_items + invalid_items }
     end
   end
 
-  describe "#id" do
+  describe '#id' do
 
-    it "sets the options[:id] for the style id passed in" do
+    it 'sets the options[:id] for the style id passed in' do
       style.id(1)
-      style_options = style.instance_variable_get(:"@options")
+      style_options = style.instance_variable_get(:"@http_request_parameters")
       expect(style_options[:id]).to eql(1)
     end
 
-    it "returns itself" do
+    it 'returns itself' do
       expect(style.object_id).to eql(style.id(1).object_id)
     end
   end
 
-  describe "when making a request" do
+  describe 'when making a request' do
 
-    context "and the id for a style is not set" do
+    context 'and the id for a style is not set' do
 
-      it "raises a Tankard::Error::NoStyleId" do
-        expect { style.each { |s| p s } }.to raise_error(Tankard::Error::MissingParameter, "No style id set")
+      it 'raises a Tankard::Error::NoStyleId' do
+        expect { style.each { |s| p s } }.to raise_error(Tankard::Error::MissingParameter, 'No style id set')
       end
     end
 
-    context "and the id for a style is set" do
+    context 'and the id for a style is set' do
 
       before do
-        @request.stub(:get).with("style/1", {}).and_return({ "data" => ["style_valid"] })
+        @request.stub(:get).with('style/1', {}).and_return('data' => ['style_valid'])
       end
 
-      it "uses the style id in the uri" do
-        expect(style.id(1).collect { |x| x}).to eql(["style_valid"])
+      it 'uses the style id in the uri' do
+        expect(style.id(1).map { |x| x }).to eql(['style_valid'])
       end
     end
   end
-end
+
+  describe 'private methods' do
+
+    describe '#raise_if_no_id_in_options' do
+
+      context 'when an ID is not set' do
+
+        it 'raises Tankard::Error::MissingParameter' do
+          expect { style.send(:raise_if_no_id_in_options) }.to raise_error(Tankard::Error::MissingParameter, 'No style id set')
+        end
+      end
+
+      context 'when an ID is set' do
+
+        before do
+          style.instance_variable_get(:"@http_request_parameters")[:id] = 'test'
+        end
+
+        it 'returns the id from options' do
+          expect(style.send(:raise_if_no_id_in_options)).to eql('test')
+        end
+
+        it 'removes the id from options' do
+          style.send(:raise_if_no_id_in_options)
+          expect(style.instance_variable_get(:"@http_request_parameters")[:id]).to be_nil
+        end
+
+        it 'can be called multiple times and not raise error' do
+          style.send(:raise_if_no_id_in_options)
+          expect { style.send(:raise_if_no_id_in_options) }.not_to raise_error
+        end
+
+        it 'caches the ID for future method calls' do
+          style.send(:raise_if_no_id_in_options)
+          expect(style.send(:raise_if_no_id_in_options)).to eql('test')
+        end
+
+        it 'updates the cache value if the user sets a new ID' do
+          style.send(:raise_if_no_id_in_options)
+          style.instance_variable_get(:"@http_request_parameters")[:id] = 'test1'
+          expect(style.send(:raise_if_no_id_in_options)).to eql('test1')
+        end
+      end
+    end
+
+    describe '#route' do
+
+      it 'returns the route for the api request' do
+        expect(style.send(:route)).to eql('style')
+      end
+    end
+
+    describe '#http_request_uri' do
+
+      before do
+        style.stub(:route).and_return('style')
+        style.stub(:raise_if_no_id_in_options).and_return('123')
+      end
+
+      context 'no endpoint is set' do
+
+        it 'returns the route with the id' do
+          expect(style.send(:http_request_uri)).to eql('style/123')
+        end
+      end
+    end
+
+    describe '#http_client' do
+
+      it 'returns the request variable that is passed when the class is created' do
+        expect(style.send(:http_client).object_id).to eql(@request.object_id)
+      end
+    end
+
+    describe '#http_request_parameters' do
+
+      it 'returns the options for the request' do
+        expect(style.send(:http_request_parameters).object_id).to eql(style.instance_variable_get(:"@http_request_parameters").object_id)
+      end
+    end
+  end
+end

data/spec/tankard/api/styles_spec.rb

@@ -5,14 +5,14 @@ describe Tankard::Api::Styles do
   let(:styles) { Tankard::Api::Styles.new(@request) }
 
   before do
-    @request = mock("request")
+    @request = double('request')
   end
 
-  describe "when making a request" do
+  describe 'when making a request' do
 
-    it "returns the data portion of the request" do
-      @request.stub(:get).with("styles", {}).and_return({"data" => ["test1", "test2"]})
-      expect(styles.collect { |x| x}).to eql(["test1", "test2"])
+    it 'returns the data portion of the request' do
+      @request.stub(:get).with('styles', {}).and_return('data' => %w(test1 test2))
+      expect(styles.map { |x| x }).to eql(%w(test1 test2))
     end
   end
-end
+end

data/spec/tankard/api/utils/find_spec.rb

@@ -4,24 +4,24 @@ describe Tankard::Api::Utils::Find do
 
   let(:find) { Class.new { include Tankard::Api::Utils::Find }.new }
 
-  describe "#route" do
+  describe '#route' do
 
-    it "raises NoMethodError" do
-      expect { find.send(:route) }.to raise_error(NoMethodError, "Must implement and return the base route")
+    it 'raises NoMethodError' do
+      expect { find.send(:route) }.to raise_error(NoMethodError, 'Must implement and return the base route')
     end
   end
 
-  describe "#http_client" do
+  describe '#http_client' do
 
-    it "raises NoMethodError" do
-      expect { find.send(:http_client) }.to raise_error(NoMethodError, "Must return the http object to make requests with")
+    it 'raises NoMethodError' do
+      expect { find.send(:http_client) }.to raise_error(NoMethodError, 'Must return the http object to make requests with')
     end
   end
 
-  describe "#http_request_parameters" do
+  describe '#http_request_parameters' do
 
-    it "raises NoMethodError" do
-      expect { find.send(:http_request_parameters) }.to raise_error(NoMethodError, "Must return a hash like structure with request parameters")
+    it 'raises NoMethodError' do
+      expect { find.send(:http_request_parameters) }.to raise_error(NoMethodError, 'Must return a hash like structure with request parameters')
     end
   end
-end
+end

data/spec/tankard/api/utils/page_finders_spec.rb

@@ -4,113 +4,116 @@ describe Tankard::Api::Utils::PageFinders do
 
   let(:finders) { Class.new { include Tankard::Api::Utils::PageFinders }.new }
 
-  describe "private methods" do
+  describe 'private methods' do
 
     before do
-      @request = mock("request")
+      @request = double('request')
     end
 
-    describe "#http_request_uri" do
+    describe '#http_request_uri' do
 
-      it "raises NoMethodError" do
+      it 'raises NoMethodError' do
         expect { finders.send(:http_request_uri) }.to raise_error(NoMethodError)
       end
     end
 
-    describe "#http_client" do
+    describe '#http_client' do
 
-      it "raises NoMethodError" do
+      it 'raises NoMethodError' do
         expect { finders.send(:http_client) }.to raise_error(NoMethodError)
       end
     end
 
-    describe "#http_request_parameters" do
+    describe '#http_request_parameters' do
 
-      it "raises NoMethodError" do
+      it 'raises NoMethodError' do
         expect { finders.send(:http_request_parameters) }.to raise_error(NoMethodError)
       end
     end
 
-    describe "#call_block_with_data" do
+    describe '#call_block_with_data' do
 
-      it "raises Tankard::Error::InvalidResponse when no data" do
+      it 'raises Tankard::Error::InvalidResponse when no data' do
         expect { finders.send(:call_block_with_data, nil, nil) }.to raise_error(Tankard::Error::InvalidResponse)
       end
 
-      it "accepts a hash of data" do
+      it 'accepts a hash of data' do
         result = []
         block = -> n { result.push(n) }
-        finders.send(:call_block_with_data, {"test" => "something"}, block)
-        expect(result).to eql([{"test"=> "something"}])
+        finders.send(:call_block_with_data, { 'test' => 'something' }, block)
+        expect(result).to eql([{ 'test' => 'something' }])
       end
 
-      it "loops through an array of data" do
+      it 'loops through an array of data' do
         result = []
-        block = -> n { result.push(n+1) }
-        finders.send(:call_block_with_data, [1,2,3], block)
-        expect(result).to eql([2,3,4])
+        block = -> n { result.push(n + 1) }
+        finders.send(:call_block_with_data, [1, 2, 3], block)
+        expect(result).to eql([2, 3, 4])
       end
     end
 
-    describe "#find_on_single_page" do
+    describe '#find_on_single_page' do
 
-      it "sends response[data] to call_block_with_data" do
-        finders.stub!(:get_request).and_return({"data" => ["test"]})
-        finders.should_receive(:call_block_with_data).with(["test"], nil)
-        finders.send(:find_on_single_page, "test", @request, {}, nil)
+      before do
+        finders.stub(:http_request_uri).and_return('test')
+        finders.stub(:http_client).and_return(@request)
+        finders.stub(:call_block_with_data).with(['test'], nil)
+      end
+
+      it 'sends response[data] to call_block_with_data' do
+        finders.stub(:get_request).and_return('data' => ['test'])
+        finders.send(:find_on_single_page, {}, nil)
       end
 
-      it "returns 0 when number of pages is not set" do
-        finders.stub!(:get_request).and_return({"data" => ["test"]})
-        finders.stub!(:call_block_with_data).with(["test"], nil)
-        expect(finders.send(:find_on_single_page, "test", @request, {}, nil)).to eql(0)
+      it 'returns 0 when number of pages is not set' do
+        finders.stub(:get_request).and_return('data' => ['test'])
+        expect(finders.send(:find_on_single_page, {}, nil)).to eql(0)
       end
 
-      it "returns a value when number of pages is set" do
-        finders.stub!(:get_request).and_return({"data" => ["test"], "numberOfPages" => "3"})
-        finders.stub!(:call_block_with_data).with(["test"], nil)
-        expect(finders.send(:find_on_single_page, "test", @request, {}, nil)).to eql(3)
+      it 'returns a value when number of pages is set' do
+        finders.stub(:get_request).and_return('data' => ['test'], 'numberOfPages' => '3')
+        expect(finders.send(:find_on_single_page, {}, nil)).to eql(3)
       end
 
     end
 
-    describe "#find_on_all_pages" do
+    describe '#find_on_all_pages' do
 
-      it "only sets the page when the page is greater than 1" do
-        finders.should_receive(:find_on_single_page).with("test", @request, {}, nil).and_return(2)
-        finders.should_not_receive(:find_on_single_page).with("test", @request, {p:1}, nil)
-        finders.should_receive(:find_on_single_page).with("test", @request, {p:2}, nil).and_return(2)
+      it 'only sets the page when the page is greater than 1' do
+        finders.should_receive(:find_on_single_page).with({}, nil).and_return(2)
+        finders.should_not_receive(:find_on_single_page).with({ p: 1 }, nil)
+        finders.should_receive(:find_on_single_page).with({ p: 2 }, nil).and_return(2)
 
-        finders.send(:find_on_all_pages, "test", @request, {}, nil)
+        finders.send(:find_on_all_pages, {}, nil)
       end
     end
 
-    describe "#find_on_single_or_all_pages" do
+    describe '#find_on_single_or_all_pages' do
 
-      it "calls find_with_options when a page is set in options" do
-        finders.should_receive(:find_on_single_page).with("test", nil, {p:2}, nil)
-        finders.send(:find_on_single_or_all_pages, "test", nil, {p:2}, nil)
+      it 'calls find_with_options when a page is set in options' do
+        finders.should_receive(:find_on_single_page).with({ p: 2 }, nil)
+        finders.send(:find_on_single_or_all_pages, { p: 2 }, nil)
       end
 
-      it "calls find_on_all_pages when a page is not set in options" do
-        finders.should_receive(:find_on_all_pages).with("test", nil, {}, nil)
-        finders.send(:find_on_single_or_all_pages, "test", nil, {}, nil)
+      it 'calls find_on_all_pages when a page is not set in options' do
+        finders.should_receive(:find_on_all_pages).with({}, nil)
+        finders.send(:find_on_single_or_all_pages, {}, nil)
       end
     end
 
-    describe "#each" do
+    describe '#each' do
 
       before do
-        finders.stub!(:http_request_uri).and_return("test")
-        finders.stub!(:http_client).and_return(nil)
-        finders.stub!(:http_request_parameters).and_return({})
+        finders.stub(:http_request_uri).and_return('test')
+        finders.stub(:http_client).and_return(nil)
+        finders.stub(:http_request_parameters).and_return({})
       end
 
-      it "calls find_on_single_or_all_pages" do
-        finders.should_receive(:find_on_single_or_all_pages).with("test", nil, {}, nil)
+      it 'calls find_on_single_or_all_pages' do
+        finders.should_receive(:find_on_single_or_all_pages).with({}, nil)
         finders.each
       end
     end
   end
 
-end
+end

data/spec/tankard/client_spec.rb

@@ -2,112 +2,112 @@ require 'spec_helper'
 
 describe Tankard::Client do
 
-  let(:client) { Tankard::Client.new({api_key: "abc123"}) }
+  let(:client) { Tankard::Client.new(api_key: 'abc123') }
 
-  describe "#beer" do
+  describe '#beer' do
 
-    context "when called" do
+    context 'when called' do
 
-      it "does not reuse an existing beer object" do
+      it 'does not reuse an existing beer object' do
         first_beer = client.beer
         expect(first_beer.object_id != client.beer.object_id).to be_true
       end
     end
 
-    context "when passed a hash of options" do
+    context 'when passed a hash of options' do
 
       before do
-        @request = mock("request")
-        Tankard::Request.stub!(:new).and_return(@request)
+        @request = double('request')
+        Tankard::Request.stub(:new).and_return(@request)
       end
 
-      it "passes the options to the beer object" do
-        Tankard::Api::Beer.should_receive(:new).with(@request, {test: 123})
-        client.beer({test: 123})
+      it 'passes the options to the beer object' do
+        Tankard::Api::Beer.should_receive(:new).with(@request, test: 123)
+        client.beer(test: 123)
       end
     end
   end
 
-  describe "#beers" do
+  describe '#beers' do
 
-    context "when called" do
+    context 'when called' do
 
-      it "does not reuse an existing beer object" do
+      it 'does not reuse an existing beer object' do
         beers = client.beers
         expect(beers.object_id != client.beers.object_id).to be_true
       end
     end
 
-    context "when passed a hash of options" do
+    context 'when passed a hash of options' do
 
-      before do 
-        @request = mock("request")
-        Tankard::Request.stub!(:new).and_return(@request)
+      before do
+        @request = double('request')
+        Tankard::Request.stub(:new).and_return(@request)
       end
 
-      it "passes the options to the beer object" do
-        Tankard::Api::Beers.should_receive(:new).with(@request, {test: 123})
-        client.beers({test: 123})
+      it 'passes the options to the beer object' do
+        Tankard::Api::Beers.should_receive(:new).with(@request, test: 123)
+        client.beers(test: 123)
       end
     end
   end
 
-  describe "#search" do
+  describe '#search' do
 
-    context "when called" do
+    context 'when called' do
 
-      it "does not reuse an existing search object" do
+      it 'does not reuse an existing search object' do
         search = client.search
         expect(search.object_id).not_to eql(client.search.object_id)
       end
     end
 
-    context "when passed a hash of options" do
+    context 'when passed a hash of options' do
 
       before do
-        @request = mock("request")
-        Tankard::Request.stub!(:new).and_return(@request)
+        @request = double('request')
+        Tankard::Request.stub(:new).and_return(@request)
       end
 
-      it "passes the options to the search object" do
-        Tankard::Api::Search.should_receive(:new).with(@request, { test: 123 })
-        client.search({ test: 123 })
+      it 'passes the options to the search object' do
+        Tankard::Api::Search.should_receive(:new).with(@request, test: 123)
+        client.search(test: 123)
       end
     end
   end
 
-  describe "#styles" do
+  describe '#styles' do
 
-    context "when called" do
+    context 'when called' do
 
-      it "does not reuse an existing styles object" do
+      it 'does not reuse an existing styles object' do
         styles = client.styles
         expect(styles.object_id != client.styles.object_id).to be_true
       end
     end
   end
 
-  describe "#style" do
+  describe '#style' do
 
-    context "when called" do
+    context 'when called' do
 
-      it "does not reuse an existing style object" do
+      it 'does not reuse an existing style object' do
         style = client.style
         expect(style.object_id).not_to eql(client.style.object_id)
       end
     end
 
-    context "when passed a hash of options" do
+    context 'when passed a hash of options' do
 
       before do
-        @request = mock("request")
-        Tankard::Request.stub!(:new).and_return(@request)
+        @request = double('request')
+        Tankard::Request.stub(:new).and_return(@request)
       end
 
-      it "passes the options to the style object" do
-        Tankard::Api::Style.should_receive(:new).with(@request, { test: 123 })
-        client.style({ test: 123 })
+      it 'passes the options to the style object' do
+        Tankard::Api::Style.should_receive(:new).with(@request, test: 123)
+        client.style(test: 123)
       end
     end
   end
-end
+end