api-model 0.0.2 → 0.0.3

data/spec/api-model/configuration_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'support/mock_models/banana'
+require 'support/mock_models/multiple_hosts'
+
+describe ApiModel, "Configuration" do
+
+  after(:each) do
+    Banana.reset_api_configuration
+  end
+
+  describe "api_host" do
+    it "should set the api host for all classes which inherit ApiModel::Base" do
+      ApiModel::Base.api_config do |config|
+        config.host = "foobarbaz.com"
+      end
+
+      Banana.api_model_configuration.host.should eq "foobarbaz.com"
+    end
+
+    it "should not override different classes configurations" do
+      MultipleHostsFoo.api_model_configuration.host.should eq("http://foo.com")
+      MultipleHostsBar.api_model_configuration.host.should eq("http://bar.com")
+      MultipleHostsNone.api_model_configuration.host.should be_nil
+    end
+  end
+
+  describe "json_root" do
+    it 'should be possible to set on a class' do
+      Banana.api_config do |config|
+        config.json_root = "foo_bar"
+      end
+
+      Banana.api_model_configuration.json_root.should eq "foo_bar"
+    end
+  end
+
+  describe "headers" do
+    it 'should create default headers for content type and accepts' do
+      headers = Banana.api_model_configuration.headers
+      headers["Content-Type"].should eq "application/json; charset=utf-8"
+      headers["Accept"].should eq "application/json"
+    end
+
+    it 'should be possible to set new headers' do
+      ApiModel::Base.api_config { |config| config.headers = { foo: "bar" } }
+      Banana.api_model_configuration.headers[:foo].should eq "bar"
+    end
+
+    it 'should retain the default headers when you add a new one' do
+      ApiModel::Base.api_config { |config| config.headers = { foo: "bar" } }
+
+      headers = Banana.api_model_configuration.headers
+      headers.should have_key "Accept"
+      headers.should have_key "Content-Type"
+    end
+
+    it 'should be possible to override default headers' do
+      ApiModel::Base.api_config { |config| config.headers = { "Accept" => "image/gif" } }
+      Banana.api_model_configuration.headers["Accept"].should eq "image/gif"
+    end
+  end
+
+  it 'should not unset other config values when you set a new one' do
+    ApiModel::Base.api_config { |c| c.host = "foo.com" }
+    Banana.api_config { |c| c.json_root = "banana" }
+
+    Banana.api_model_configuration.host.should eq "foo.com"
+    Banana.api_model_configuration.json_root.should eq "banana"
+  end
+
+  it 'should override config values from the superclass if it is changed' do
+    ApiModel::Base.api_config { |c| c.host = "will-go.com" }
+    Banana.api_config { |c| c.host = "new-host.com" }
+
+    Banana.api_model_configuration.host.should eq "new-host.com"
+  end
+
+end

data/spec/api-model/http_request_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'support/mock_models/blog_post'
+
+describe ApiModel::HttpRequest do
+
+  describe "default attributes" do
+    subject { ApiModel::HttpRequest.new }
+
+    it "should default #method to :get" do
+      subject.method.should eq :get
+    end
+
+    it "should default #options to a hash with headers" do
+      subject.options.should be_a Hash
+      subject.options[:headers].should_not be_nil
+    end
+  end
+
+  describe "callbacks" do
+    class ApiModel::HttpRequest
+      before_run :do_something_before_run
+      def do_something_before_run; end
+    end
+
+    it 'should be possible to set callbacks on the run method' do
+      ApiModel::HttpRequest.any_instance.should_receive(:do_something_before_run).once
+      VCR.use_cassette('posts') { BlogPost.get_json "http://api-model-specs.com/single_post"}
+    end
+  end
+
+  describe "using api_host" do
+    let(:blog_post) do
+      BlogPost.api_config do |config|
+        config.host = "http://api-model-specs.com"
+      end
+
+      VCR.use_cassette('posts') do
+        BlogPost.get_json "/single_post"
+      end
+    end
+
+    it "should be used with #path to generate a #full_path" do
+      blog_post.http_response.api_call.request.url.should eq "http://api-model-specs.com/single_post"
+    end
+  end
+
+  describe "headers" do
+    let :request_headers do
+      BlogPost.api_config { |config| config.host = "http://api-model-specs.com" }
+      blog_post = VCR.use_cassette('posts') { BlogPost.get_json "/single_post" }
+      blog_post.http_response.api_call.request.options[:headers]
+    end
+
+    it 'should use the default content type header' do
+      request_headers["Content-Type"].should eq ApiModel::Configuration.new.headers["Content-Type"]
+    end
+
+    it 'should use the default accept header' do
+      request_headers["Accept"].should eq ApiModel::Configuration.new.headers["Accept"]
+    end
+  end
+
+  describe "sending a GET request" do
+    let(:request) { ApiModel::HttpRequest.new path: "http://api-model-specs.com/posts", method: :get }
+
+    it "should use typhoeus to send a request" do
+      VCR.use_cassette('posts') do
+        request.run
+      end
+
+      request.api_call.success?.should eq true
+    end
+  end
+end

data/spec/{lib → api-model}/initializer_spec.rb

@@ -3,6 +3,10 @@ require 'support/mock_models/banana'
 
 describe ApiModel::Initializer do
 
+  Banana.class_eval do
+    include ApiModel::Initializer
+  end
+
   let(:banana) { Banana.new color: "yellow", size: "large" }
 
   it "should set attributes when initializing with a hash" do
@@ -16,16 +20,12 @@ describe ApiModel::Initializer do
     expect(banana.size).to eq "small"
   end
 
-  it "should not blog up if update_attributes is called with nil" do
+  it "should not blow up if update_attributes is called with nil" do
     expect {
       banana.update_attributes nil
     }.to_not raise_error
   end
 
-  it "should run callbacks on initialize" do
-    banana.ripe.should eq true
-  end
-
   it "should log if an attempt was made to set an attribute which is not defined" do
     ApiModel::Log.should_receive(:debug).with "Could not set foo on Banana"
     Banana.new foo: "bar"

data/spec/api-model/response_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+require 'support/mock_models/blog_post'
+require 'support/mock_models/user'
+
+describe ApiModel::Response do
+
+  let(:valid_response) do
+    VCR.use_cassette('posts') do
+      ApiModel::HttpRequest.new(path: "http://api-model-specs.com/single_post", method: :get, builder: BlogPost).run
+    end
+  end
+
+  describe "parsing the json body" do
+    it "should produce a hash given valid json" do
+      valid_response.json_response_body.should be_a(Hash)
+      valid_response.json_response_body["name"].should eq "foo"
+    end
+
+    it "should catch errors from parsing invalid json" do
+      valid_response.stub_chain(:http_response, :api_call, :body).and_return "blah"
+      ApiModel::Log.should_receive(:info).with "Could not parse JSON response: blah"
+
+      expect {
+        valid_response.json_response_body
+      }.to_not raise_error
+    end
+  end
+
+  describe "using a custom json root on the response body" do
+    let :users do
+      User.api_config do |c|
+        c.json_root = "users"
+      end
+      VCR.use_cassette('users') { User.get_json "http://api-model-specs.com/users" }
+    end
+
+    it 'should use the json root to build from' do
+      users.should be_a Array
+      users.size.should eq 3
+
+      users.each do |user|
+        user.should be_a User
+      end
+    end
+  end
+
+  describe "using a multi-level json root on the response body" do
+    let :user_search do
+      VCR.use_cassette('users') { User.get_json "http://api-model-specs.com/search" }
+    end
+
+    it 'should use the deep json root to build from' do
+      User.api_config { |c| c.json_root = "search.results.users" }
+
+      user_search.should be_a Array
+      user_search.size.should eq 3
+
+      user_search.each do |user|
+        user.should be_a User
+      end
+    end
+
+    it 'should raise a ApiModel::ResponseBuilderError exception if the hash does not contain the key' do
+      User.api_config { |c| c.json_root = "search.results.users.foo" }
+
+      expect {
+        user_search
+      }.to raise_error(ApiModel::ResponseBuilderError)
+    end
+  end
+
+  describe "#build" do
+    it "should use the builder.build method if present" do
+      builder = double
+      builder.should_receive(:build).with something: "foo"
+
+      valid_response.build builder, something: "foo"
+    end
+
+    it "should use builder.new if there's no builder.build method" do
+      builder = double
+      builder.should_receive(:new).with something_else: "hi"
+
+      valid_response.build builder, something_else: "hi"
+    end
+  end
+
+  describe "#build_objects" do
+    let(:single_object) do
+      valid_response.stub(:json_response_body).and_return name: "foo"
+      valid_response.build_objects
+    end
+
+    let(:array_of_objects) do
+      valid_response.stub(:json_response_body).and_return [{name: "foo"}, {name: "bar"}]
+      valid_response.build_objects
+    end
+
+    let(:empty_response) do
+      valid_response.stub(:json_response_body).and_return nil
+      valid_response.build_objects
+    end
+
+    it "should build a single object" do
+      single_object.should be_a(BlogPost)
+      single_object.name.should eq "foo"
+    end
+
+    it "should build an array of objects" do
+      array_of_objects[0].should be_a(BlogPost)
+      array_of_objects[0].name.should eq "foo"
+
+      array_of_objects[1].should be_a(BlogPost)
+      array_of_objects[1].name.should eq "bar"
+    end
+
+    it "should include the ApiModel::HttpRequest object" do
+      single_object.http_response.should be_a(ApiModel::HttpRequest)
+    end
+
+    it "should include the #json_response_body" do
+      single_object.json_response_body.should eq name: "foo"
+    end
+
+    it 'should return nil if the api returns an empty body' do
+      empty_response.should be_nil
+    end
+  end
+
+  describe "passing core methods down to the built class" do
+    ApiModel::Response::FALL_THROUGH_METHODS.each do |fall_trhough_method|
+      it "should pass ##{fall_trhough_method} on the built object class" do
+        allow_message_expectations_on_nil
+        valid_response.objects.should_receive(fall_trhough_method)
+        valid_response.send fall_trhough_method
+      end
+    end
+  end
+
+  describe "raising exceptions" do
+    describe "for requests which return a 401" do
+      let :api_request do
+        VCR.use_cassette('errors') do
+          BlogPost.get_json "http://api-model-specs.com/needs_auth"
+        end
+      end
+
+      it 'should raise an ApiModel::UnauthenticatedError if raise_on_unauthenticated is true' do
+        BlogPost.api_config { |c| c.raise_on_unauthenticated = true }
+        expect {
+          api_request
+        }.to raise_error(ApiModel::UnauthenticatedError)
+      end
+
+      it 'should not raise an ApiModel::UnauthenticatedError if raise_on_unauthenticated is false' do
+        BlogPost.api_config { |c| c.raise_on_unauthenticated = false }
+        expect {
+          api_request
+        }.to_not raise_error
+      end
+    end
+
+    describe "for requests which return a 404" do
+      let :api_request do
+        VCR.use_cassette('errors') do
+          BlogPost.get_json "http://api-model-specs.com/not_found"
+        end
+      end
+
+      it 'should raise an ApiModel::NotFoundError if raise_on_not_found is true' do
+        BlogPost.api_config { |c| c.raise_on_not_found = true }
+        expect {
+          api_request
+        }.to raise_error(ApiModel::NotFoundError)
+      end
+
+      it 'should not raise an ApiModel::NotFoundError if raise_on_not_found is false' do
+        BlogPost.api_config { |c| c.raise_on_not_found = false }
+        expect {
+          api_request
+        }.to_not raise_error
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -8,4 +8,13 @@ require 'api-model'
 VCR.configure do |c|
   c.cassette_library_dir = 'spec/support/fixtures'
   c.hook_into :webmock # or :fakeweb
+end
+
+RSpec.configure do |config|
+
+  # Reset any config changes after each spec
+  config.after(:each) do
+    ApiModel::Base.reset_api_configuration
+  end
+
 end

data/spec/support/fixtures/cars.yml

@@ -0,0 +1,84 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: http://cars.com/one_convertable
+    headers:
+      User-Agent:
+      - Typhoeus - https://github.com/typhoeus/typhoeus
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Server:
+      - nginx/1.4.1
+      Date:
+      - Thu, 28 Nov 2013 16:02:56 GMT
+      Content-Type:
+      - text/plain; charset=utf-8
+      Content-Length:
+      - '248'
+      Connection:
+      - keep-alive
+    body:
+      encoding: UTF-8
+      string: "{\"numberOfDoors\":2,\"top_speed\":60}"
+    http_version:
+  recorded_at: Thu, 28 Nov 2013 16:02:20 GMT
+
+- request:
+    method: get
+    uri: http://cars.com/fast_ones
+    headers:
+      User-Agent:
+      - Typhoeus - https://github.com/typhoeus/typhoeus
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Server:
+      - nginx/1.4.1
+      Date:
+      - Thu, 28 Nov 2013 16:02:56 GMT
+      Content-Type:
+      - text/plain; charset=utf-8
+      Content-Length:
+      - '248'
+      Connection:
+      - keep-alive
+    body:
+      encoding: UTF-8
+      string: "[{\"numberOfDoors\":2,\"top_speed\":60},{\"numberOfDoors\":4,\"top_speed\":30,\"name\":\"Ford\"}]"
+    http_version:
+  recorded_at: Thu, 28 Nov 2013 16:02:20 GMT
+
+- request:
+    method: get
+    uri: http://cars.com/new_model
+    headers:
+      User-Agent:
+      - Typhoeus - https://github.com/typhoeus/typhoeus
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Server:
+      - nginx/1.4.1
+      Date:
+      - Thu, 28 Nov 2013 16:02:56 GMT
+      Content-Type:
+      - text/plain; charset=utf-8
+      Content-Length:
+      - '248'
+      Connection:
+      - keep-alive
+    body:
+      encoding: UTF-8
+      string: "{\"numberOfDoors\":2,\"top_speed\":60,\"shiney\":true}"
+    http_version:
+  recorded_at: Thu, 28 Nov 2013 16:02:20 GMT
+
+recorded_with: VCR 2.8.0