reviewed 0.0.6 → 0.0.7

data/spec/base_spec.rb

@@ -1,87 +1,50 @@
 require 'spec_helper'
 
-module Reviewed
-  class Example < Base
-  end
-end
+describe Reviewed::Base do
 
-module Reviewed
-  class Article < Base
-  end
-end
+  let(:article_id) { '509d166d60de7db97c05ce71' }
 
-describe Reviewed::Base do
-  before(:each) do
-    Reviewed.api_key = TEST_KEY
-  end
+  class Example < Reviewed::Base; end
 
   describe 'Class' do
+
     it 'responds to model_name' do
-      Reviewed::Example.model_name.should eql("Reviewed::Example")
+      Example.model_name.should eql("Example")
     end
   end
 
-  describe 'initialization' do
-    it 'raises an error if a resource ID is not present' do
-      expect {
-        Reviewed::Example.new
-      }.to raise_error(Reviewed::ResourceError)
+  describe 'initialize' do
+
+    it 'objectifies data' do
+      Example.any_instance.should_receive(:objectify).with({})
+      obj = Example.new( {} )
     end
 
-    it 'returns a value' do
-      model = Reviewed::Example.new(id: 1234, name: 'Test')
-      model.id.should == 1234
+    it 'sets the data in the @attributes var' do
+      obj = Example.new( { foo: 'bar' } )
+      obj.instance_variable_get(:@attributes).should eql( { foo: 'bar' } )
     end
   end
 
   describe 'find' do
-    before(:each) do
-      Reviewed::Example.resource_name = 'article' # test
-    end
-
-    it 'raises an error if the api key is not set' do
-      Reviewed.api_key = nil
+    use_vcr_cassette 'base/article/find'
 
-      expect {
-        Reviewed::Example.find('test')
-      }.to raise_error(Reviewed::ConfigurationError)
+    it 'returns an article' do
+      Reviewed::Article.find("#{article_id}").should be_an_instance_of(Reviewed::Article)
     end
 
-    context 'with a valid request' do
-      use_vcr_cassette 'base/find_ok'
-
-      before(:each) do
-        @article = Reviewed::Article.find('big-green-egg-medium-charcoal-grill-review')
-      end
-
-      it 'fetches content from the api' do
-        model = Reviewed::Example.find(@article.id)
-        model.raw_response.should_not be_nil
-      end
-
-      it 'parses response json and returns an object' do
-        model = Reviewed::Example.find(@article.id)
-        model.class.should == Reviewed::Example
-        model.name.should == 'Big Green Egg Medium Charcoal Grill Review'
-      end
+    it 'calls object_from_response with correct params' do
+      Reviewed::Article.should_receive(:object_from_response).with(
+        :get, "articles/#{article_id}", {}
+      )
+      Reviewed::Article.find("#{article_id}")
     end
+  end
 
-    context 'with an invalid request' do
-      use_vcr_cassette 'base/find_error_key'
-
-      it 'complains if the api key is unauthorized' do
-        Reviewed.api_key = 'xxxxxxxxxxxxxxxx'
-
-        expect {
-          Reviewed::Example.find('50241b9c5da4ac8d38000001')
-        }.to raise_error(Reviewed::ResourceError, /unauthorized/i)
-      end
+  describe 'resource_url' do
 
-      it 'complains if the requested resource is not found' do
-        expect {
-          Reviewed::Example.find('notfound')
-        }.to raise_error(Reviewed::ResourceError, /not found/i)
-      end
+    it 'should the demodulized resource name' do
+      Reviewed::Article.resource_url.should eql("articles")
     end
   end
 
@@ -89,7 +52,7 @@ describe Reviewed::Base do
     use_vcr_cassette 'base/where_collection'
 
     it 'returns a collection' do
-      collection = Reviewed::Article.all
+      collection = Reviewed::Article.where
       collection.class.should == Reviewed::Collection
     end
 
@@ -113,24 +76,26 @@ describe Reviewed::Base do
     end
   end
 
+  describe 'all' do
+
+    it 'calls where with empty params' do
+      Reviewed::Article.should_receive(:where).with({})
+      Reviewed::Article.all
+    end
+  end
+
   describe 'attributes' do
     it 'returns the named attribute (via method missing)' do
-      model = Reviewed::Example.new(:id => 'id', :super_awesome => 'true')
+      model = Example.new(:id => 'id', :super_awesome => 'true')
       model.super_awesome.should == 'true'
     end
   end
 
-  describe 'resource url' do
-    it 'returns an individual resource' do
-      Reviewed::Example.resource_url('article-123').should == 'https://the-guide-staging.herokuapp.com/api/v1/articles/article-123'
-    end
-
-    it 'returns a collection of resources' do
-      Reviewed::Example.resource_url(nil).should == 'https://the-guide-staging.herokuapp.com/api/v1/articles'
-    end
+  describe 'resource_url' do
 
-    it 'includes a query parameter' do
-      Reviewed::Example.resource_url(nil, page: 2).should == 'https://the-guide-staging.herokuapp.com/api/v1/articles?page=2'
+    it 'returns the pluralized demodulized class name' do
+      Reviewed::Article.resource_url.should eql('articles')
+      Example.resource_url.should eql('examples')
     end
   end
 end

data/spec/client_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper.rb'
+
+describe Reviewed::Client do
+
+  let(:client) { Reviewed::Client.new }
+
+  describe 'variables' do
+
+    [:api_key, :base_uri, :api_version].each do |var|
+      describe "#{var}" do
+
+        it 'exists' do
+          client.instance_variables.should include(:"@#{var}")
+        end
+      end
+    end
+  end
+
+  describe '#delete' do
+
+    it 'delegates to request' do
+      client.should_receive(:request).with(:delete, "path", kind_of(Hash))
+      client.delete("path", {})
+    end
+  end
+
+  describe '#get' do
+
+    it 'delegates to request' do
+      client.should_receive(:request).with(:get, "path", kind_of(Hash))
+      client.get("path", {})
+    end
+  end
+
+  describe '#post' do
+
+    it 'delegates to request' do
+      client.should_receive(:request).with(:post, "path", kind_of(Hash))
+      client.post("path", {})
+    end
+  end
+
+  describe '#put' do
+
+    it 'delegates to request' do
+      client.should_receive(:request).with(:put, "path", kind_of(Hash))
+      client.put("path", {})
+    end
+  end
+
+  describe '#url' do
+
+    it 'returns a url' do
+      client.url.should eql('http://localhost:3000/api/v1')
+    end
+  end
+
+  describe '#request' do
+
+    it 'verifies the key' do
+      client.stub_chain(:connection, :send).and_return(nil)
+      client.should_receive(:verify_key!)
+      client.send(:request, :get, 'test')
+    end
+  end
+
+  describe '#connnection' do
+
+    let(:conn) { client.send(:connection) }
+
+    it 'returns a Faraday object' do
+      conn.should be_an_instance_of(Faraday::Connection)
+    end
+
+    it 'uses the UrlEncoded middleware' do
+      conn.builder.handlers.should include(Faraday::Request::UrlEncoded)
+    end
+
+    it 'uses a Json middleware' do
+      conn.builder.handlers.should include(FaradayMiddleware::ParseJson)
+    end
+
+    it 'uses a Hashie middleware' do
+      conn.builder.handlers.should include(FaradayMiddleware::Mashify)
+    end
+
+    it 'uses the NetHttp adapter' do
+      conn.builder.handlers.should include(Faraday::Adapter::NetHttp)
+    end
+
+    it 'sets the url' do
+      conn.url_prefix.to_s.should eql('http://localhost:3000/api/v1')
+    end
+  end
+end

data/spec/collection_spec.rb

@@ -14,6 +14,7 @@ describe Reviewed::Collection do
   end
 
   describe 'collection data' do
+
     it 'is enumerable' do
       @collection.each do |product|
         product.class.should == Reviewed::Product
@@ -21,16 +22,13 @@ describe Reviewed::Collection do
       end
     end
 
-    it 'contains the raw response' do
-      @collection.raw_response.should_not be_blank
-    end
-
     it 'fetches the first page by default' do
       @collection.current_page.should == 1
     end
   end
 
   describe 'next page' do
+
     it 'fetches the next page of results' do
       page2 = @collection.next_page
       page2.current_page.should == 2
@@ -38,11 +36,11 @@ describe Reviewed::Collection do
   end
 
   describe 'previous page' do
+
     it 'fetches the previous page of results' do
       page2 = @collection.next_page
       page1 = page2.previous_page
-      @collection.should == page1
-      page1.current_page.should == 1
+      @collection.current_page == page1.current_page
     end
 
     it 'returns nil if there is no previous page' do
@@ -51,6 +49,7 @@ describe Reviewed::Collection do
   end
 
   describe 'page attributes (pagination)' do
+
     it 'returns the total item count' do
       @collection.total.should > 1
     end

data/spec/configurable_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper.rb'
+
+describe Reviewed::Configurable do
+
+  let(:client) { Reviewed::Client.new }
+
+  describe '.options' do
+
+    it 'returns a default set of options' do
+      Reviewed::Configurable.options.should be_an_instance_of(Hash)
+    end
+  end
+
+  describe '#configure' do
+
+    it 'returns self' do
+      client.configure{}.should be_an_instance_of(Reviewed::Client)
+    end
+
+    it 'yields self' do
+      client.configure do |config|
+        config.api_key = 'test_key'
+      end
+      client.api_key.should eql('test_key')
+    end
+  end
+
+  describe '#verify_key' do
+
+    after(:each) { Reviewed.api_key = TEST_KEY }
+
+    it 'allow when api_key is present' do
+      client.base_uri.should_not be_nil
+      client.verify_key!
+    end
+
+    it 'raises a ConfigurationError if api_key not present' do
+      Reviewed.api_key = nil
+      expect {
+        client.verify_key!
+      }.to raise_error(Reviewed::ConfigurationError)
+    end
+  end
+end

data/spec/embeddable_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper.rb'
+
+describe Reviewed::Embeddable do
+
+  after(:each) do
+    Reviewed::MockEmbeddable._embedded_many = nil
+    Reviewed::MockEmbeddable._embedded_one = nil
+  end
+
+  module Reviewed
+    class MockEmbeddable
+      include Reviewed::Embeddable
+    end
+  end
+
+  describe 'accessors' do
+
+    it '_embedded_many' do
+      Reviewed::MockEmbeddable._embedded_many = "test"
+      Reviewed::MockEmbeddable._embedded_many.should eql("test")
+    end
+
+    it '_embedded_one' do
+      Reviewed::MockEmbeddable._embedded_one = "test"
+      Reviewed::MockEmbeddable._embedded_one.should eql("test")
+    end
+  end
+
+  describe '#has_many' do
+
+    context 'no options' do
+
+      context 'valid name' do
+
+        it 'stores the correct embedded relationship' do
+          Reviewed::MockEmbeddable._embedded_many.should be_empty
+          Reviewed::MockEmbeddable.has_many("mock_embeddables")
+          Reviewed::MockEmbeddable._embedded_many.should eql([{ "mock_embeddables" => Reviewed::MockEmbeddable }])
+        end
+      end
+
+      context 'invalid name' do
+
+        it 'errors' do
+          expect {
+            Reviewed::MockEmbeddable.has_many("bad_name")
+          }.to raise_error
+        end
+      end
+    end
+
+    context ":as" do
+
+      it 'stores the correct embedded relationship' do
+        Reviewed::MockEmbeddable._embedded_many.should be_empty
+        Reviewed::MockEmbeddable.has_many("mock_embeddables", as: "test")
+        Reviewed::MockEmbeddable._embedded_many.should eql([{ "test" => Reviewed::MockEmbeddable }])
+      end
+    end
+
+    context "class_name" do
+
+      it 'stores the correct embedded relationship' do
+        Reviewed::MockEmbeddable._embedded_many.should be_empty
+        Reviewed::MockEmbeddable.has_many("mock_embeddables", class_name: "Reviewed::Article")
+        Reviewed::MockEmbeddable._embedded_many.should eql([{ "mock_embeddables" => Reviewed::Article }])
+      end
+    end
+  end
+
+  describe '#has_one' do
+
+    it 'stores the correct embedded relationship' do
+      Reviewed::MockEmbeddable._embedded_one.should be_empty
+      Reviewed::MockEmbeddable.has_one("mock_embeddable")
+      Reviewed::MockEmbeddable._embedded_one.should eql([{ "mock_embeddable" => Reviewed::MockEmbeddable }])
+    end
+  end
+
+  describe 'objectify' do
+
+    let(:mocked) { Reviewed::MockEmbeddable.new }
+    let(:data) { { articles: [1,2,3] } }
+
+    it 'calls objectify_has_many' do
+      mocked.should_receive(:objectify_has_many)
+      mocked.objectify({})
+    end
+
+    it 'calls objectify_has_one' do
+      mocked.should_receive(:objectify_has_one)
+      mocked.objectify({})
+    end
+  end
+
+  describe 'objectify_has_many' do
+
+    let(:data) { { "articles" => [{},{}] } }
+    let(:mocked) { Reviewed::MockEmbeddable.new }
+
+    before(:each) do
+      Reviewed::MockEmbeddable._embedded_many = [ { "articles" => Reviewed::Article } ]
+    end
+
+    it 'objectifies' do
+      mocked.objectify_has_many(data)["articles"].each do |obj|
+        obj.should be_an_instance_of Reviewed::Article
+      end
+    end
+  end
+
+  describe 'objectify_has_one' do
+
+    let(:data) { { "article" => {} } }
+    let(:mocked) { Reviewed::MockEmbeddable.new }
+
+    before(:each) do
+      Reviewed::MockEmbeddable._embedded_one = [ { "article" => Reviewed::Article } ]
+    end
+
+    it 'objectifies' do
+      mocked.objectify_has_one(data)["article"].should be_an_instance_of(Reviewed::Article)
+    end
+  end
+
+  describe '.embedded_name' do
+
+    context 'plural' do
+
+      it 'returns a class name' do
+        Reviewed::Embeddable.embedded_name("mock_embeddables").should eql("Reviewed::MockEmbeddable")
+      end
+    end
+
+    context 'singular' do
+
+      it 'returns a class name' do
+        Reviewed::Embeddable.embedded_name("mock_embeddable").should eql("Reviewed::MockEmbeddable")
+      end
+    end
+  end
+
+  describe '.embedded_class' do
+
+    context 'opts_name' do
+
+      context 'valid' do
+
+        it 'returns a class_constant' do
+          Reviewed::Embeddable.embedded_class("test", "Reviewed::MockEmbeddable")
+            .should eql(Reviewed::MockEmbeddable)
+        end
+      end
+
+      context 'invalid' do
+
+        it 'errors' do
+          expect {
+            Reviewed::Embeddable.embedded_class("test", "Reviewed::MockBad")
+          }.to raise_error
+        end
+      end
+    end
+
+    context 'name' do
+
+      context 'valid' do
+
+        it 'returns a class_constant' do
+          Reviewed::Embeddable.embedded_class("mock_embeddables")
+            .should eql(Reviewed::MockEmbeddable)
+        end
+      end
+    end
+  end
+end