drink-socially 0.0.4

data/lib/drink-socially/version.rb

@@ -0,0 +1,8 @@
+module NRB
+  module Untappd
+    VERSION = '0.0.4'
+    def self.version
+      VERSION
+    end
+  end
+end

data/spec/cases/drink-socially/api/credential_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe NRB::Untappd::API::Credential do
+
+  let(:app_credential_attrs) { { client_id: 'NewRepublicBrewing', client_secret: 'good_beer' } }
+  let(:app_credentials) { NRB::Untappd::API::Credential.new app_credential_attrs }
+
+  let(:user_credential_attrs) { {  access_token: 'brundage' } }
+  let(:user_credentials) { NRB::Untappd::API::Credential.new user_credential_attrs }
+
+
+  context 'initialzation error checking' do
+
+    it 'blows up when creating a credential with no attributes' do
+      expect { NRB::Untappd::API::Credential.new }.to raise_error(NRB::Untappd::API::Credential::IncompleteCredentialError)
+    end
+
+
+    it 'blows up when creating a credential with just a client_id' do
+      expect { NRB::Untappd::API::Credential.new client_id: 'bmc' }.to raise_error(NRB::Untappd::API::Credential::IncompleteCredentialError)
+    end
+
+
+    it 'blows up when creating a credential with just a client_secret' do
+      expect { NRB::Untappd::API::Credential.new client_secret: 'corn' }.to raise_error(NRB::Untappd::API::Credential::IncompleteCredentialError)
+    end
+
+
+    it 'does not raise error for a valid app credential' do
+      expect { app_credentials }.not_to raise_error
+    end
+
+
+    it 'does not raise error for a valid user credential' do
+      expect { user_credentials }.not_to raise_error
+    end
+
+  end
+
+
+  it 'returns the credentials as a hash' do
+    user_credentials.to_h.should eq user_credential_attrs
+  end
+
+
+  shared_examples_for 'has an accessor method' do
+    it "makes an accessor method for the accessor" do
+      credentials.should respond_to(accessor)
+    end
+    it "provides the accessor" do
+      credentials.send(accessor).should eq attrs[accessor]
+    end
+  end
+
+
+  context 'app credentials' do
+
+    let(:attrs) { app_credential_attrs }
+    let(:credentials) { app_credentials }
+
+    it_behaves_like 'has an accessor method' do
+      let(:accessor) { :client_id }
+    end
+
+    it_behaves_like 'has an accessor method' do
+      let(:accessor) { :client_secret }
+    end
+
+    it 'correctly answers is_app?' do
+      credentials.should be_is_app
+    end
+
+    it 'correctly answers is_client?' do
+      credentials.should be_is_client
+    end
+
+    it 'correctly answers is_user?' do
+      credentials.should_not be_is_user
+    end
+
+  end
+
+
+  context 'user credentials' do
+
+    let(:attrs) { user_credential_attrs }
+    let(:credentials) { user_credentials }
+
+    it_behaves_like 'has an accessor method' do
+      let(:accessor) { :access_token }
+    end
+
+    it 'correctly answers is_app?' do
+      credentials.should_not be_is_app
+    end
+
+    it 'correctly answers is_client?' do
+      credentials.should_not be_is_client
+    end
+
+    it 'correctly answers is_user?' do
+      credentials.should be_is_user
+    end
+
+  end
+
+end

data/spec/cases/drink-socially/api/object_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+describe NRB::Untappd::API::Object do
+
+  let(:body) { { llama: { llama: { llama: { llamas: :all_the_way_down,
+                                            dude: :sweet 
+                                          } } } } }
+  let(:headers) { { stupid: :llama } }
+  let(:response) { NRB::Untappd::API::Object.new body: body, headers: headers, status: status }
+  let(:status) { 200 }
+
+  it 'has a pagination object' do
+    response.should respond_to(:pagination)
+  end
+
+
+  context 'extracting an object from the body' do
+
+    let(:path) { [ :llama, :llama, :llama ] }
+    let(:response) { NRB::Untappd::API::Object.new body: body, headers: headers, status: status, results_path: path }
+    let(:target) { response.body[:llama][:llama][:llama] }
+
+     it 'assingns the extraction to @results' do
+      response.results.should eq target
+    end
+
+    it 'updates @attributes with the hash keys' do
+      response.attributes.collect(&:to_sym).sort.should eq target.keys.collect(&:to_sym).sort
+    end
+
+
+    it 'defines a methods on response for each hash key' do
+      target.keys.each { |m| response.should respond_to(m) }
+    end
+
+  end
+
+
+  context 'errored responses' do
+
+    let(:error_detail) { "This Venue ID is invalid" }
+    let(:error_type) { "invalid_param" }
+    let(:status) { 500 }
+
+    context 'v4' do
+
+      let(:body) { { meta: { code: 500,
+                             error_detail: error_detail,
+                             error_type: error_type,
+                             response_time: { time: 0.089,
+                                              measure: "seconds" }
+                           },
+                     response: [] } }
+
+      it 'creates an errored response' do
+        response.should be_errored
+      end
+
+      it 'has an error message' do
+        response.error_message.should_not be_nil
+      end
+
+      it 'tells you the error detail' do
+        response.error_message.should match /#{error_detail}/
+      end
+
+      it 'tells you the error type' do
+        response.error_message.should match /#{error_type}/
+      end
+
+    end
+
+
+    context 'legacy' do
+
+      let(:body) { { error: error_detail } }
+
+      it 'has an error message' do
+        response.error_message.should_not be_nil
+      end
+
+      it 'tells you the error detail' do
+        response.error_message.should match /#{error_detail}/
+      end
+
+    end
+
+
+    context 'unrecognized' do
+      let(:body) { { } }
+
+      it 'has an error message' do
+        response.error_message.should_not be_nil
+      end
+
+    end
+
+
+    context 'successful requests' do
+
+      let(:status) { 200 }
+
+      it 'should not have an error_message' do
+        response.error_message.should be_nil
+      end
+
+    end
+
+  end
+
+
+
+end

data/spec/cases/drink-socially/api/pagination_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+describe NRB::Untappd::API::Pagination do
+
+  let(:body) { { response: { pagination: pagination_hash } } }
+  let(:headers) { {} }
+  let(:max_id) { 16546450 }
+  let(:next_url) { "http://api.untappd.com/v4/brewery/checkins/8767?min_id=16546450" }
+  let(:pagination) { NRB::Untappd::API::Pagination.from_response(response) }
+  let(:pagination_hash) { {
+                            since_url: since_url,
+                            next_url: next_url,
+                            max_id: max_id
+                        } }
+  let(:response) { NRB::Untappd::API::Object.new body: body, headers: headers, status: status }
+  let(:since_url) { "http://api.untappd.com/v4/brewery/checkins/8767?min_id=16546450" }
+  let(:status) { 200 }
+
+
+  context 'from a response without pagination' do
+
+    let(:body) { { response: { } } }
+
+    it 'gives you nil' do
+      pagination.should be_nil
+    end
+  end
+
+
+  it 'gives you a pagination object' do
+    pagination.should be_a(NRB::Untappd::API::Pagination)
+  end
+
+
+  it 'has the correct next_id' do
+    pagination.next_id.should eq (max_id + 1)
+  end
+
+
+  it 'has the correct prev_id' do
+    pagination.prev_id.should eq (max_id - 1)
+  end
+
+end

data/spec/cases/drink-socially/api/rate_limit_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+describe NRB::Untappd::API::RateLimit do
+
+  let(:headers) { { 'x-ratelimit-limit' => 5, 'x-ratelimit-remaining' => 4 } }
+  let(:rate_limit) { NRB::Untappd::API::RateLimit.new headers }
+
+  it 'correctly assigns limit' do
+    rate_limit.limit.should eq headers['x-ratelimit-limit']
+  end
+
+  it 'correctly assigns remaining' do
+    rate_limit.remaining.should eq headers['x-ratelimit-remaining']
+  end
+
+end

data/spec/cases/drink-socially/api/url_tokenizer_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe NRB::Untappd::API::URLTokenizer do
+
+  let(:map)   { { token => :llama } }
+  let(:result) { tokenizer.tr }
+  let(:token) { :blark }
+  let(:tokenizer) { NRB::Untappd::API::URLTokenizer.new map: map, string: string }
+
+
+  it 'raises ArgumentError with no map' do
+    expect { NRB::Untappd::API::URLTokenizer.new string: "" }.to raise_error(ArgumentError)
+  end
+
+
+  it 'raises ArgumentError with no string' do
+    expect { NRB::Untappd::API::URLTokenizer.new map: map }.to raise_error(ArgumentError)
+  end
+
+
+  context 'a non-tokenized string' do
+    let(:string) { "some/url#{token}#its_cool" }
+    it 'leaves the string alone' do
+      result.should eq string
+    end
+  end
+
+
+  context 'a tokenized string' do
+    let(:string) { "some/:#{token}:/url" }
+    it 'changes a string with a single token' do
+      result.should eq "some/#{map[token]}/url"
+    end
+
+    it 'changes multiple tokens' do
+      t = NRB::Untappd::API::URLTokenizer.new map: { token1: :llama, token2: :beer }, string: "/some/:token2:/path/:token1:"
+      t.tr.should eq "/some/beer/path/llama"
+    end
+  end
+
+end

data/spec/cases/drink-socially/api_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe NRB::Untappd::API do
+
+  context 'class methods' do
+
+    it 'has a version' do
+      NRB::Untappd::API.should respond_to :api_version
+    end
+
+    it 'has a server' do
+      NRB::Untappd::API.should respond_to :server
+    end
+
+    describe 'default helper classes' do
+
+      it 'uses RateLimit' do
+        NRB::Untappd::API.default_rate_limit_class.should eq NRB::Untappd::API::RateLimit
+      end
+
+      it 'uses Object' do
+        NRB::Untappd::API.default_response_class.should eq NRB::Untappd::API::Object
+      end
+
+    end
+
+  end
+
+
+  let(:api) { NRB::Untappd::API.new options }
+  let(:options) { { access_token: 'NewRepublicBrewing' } }
+
+  it 'has a credential accessor' do
+    api.should respond_to(:credential)
+  end
+
+
+  it 'has a credential object' do
+    api.credential.should be_a(NRB::Untappd::API::Credential)
+  end
+
+
+  context 'using an endpoint config' do
+
+    let(:api) { NRB::Untappd::API.new options }
+    let(:endpoints) { { endpoint1: { }, endpoint2: { } } }
+    let(:options) { { access_token: 'NewRepublicBrewing', endpoints: endpoints } }
+
+
+    it 'defines methods based on the top level of the config hash' do
+      endpoints.keys.each do |meth|
+        api.should respond_to(meth)
+      end
+    end
+
+
+    context 'with method aliases' do
+      let(:endpoints) { { endpoint1: { method_aliases: method_aliases } } }
+      let(:method_aliases) { [ :an_alias ] }
+      it 'defines methods for the aliases' do
+        method_aliases.each do |meth|
+           api.should respond_to(meth)
+         end
+      end
+    end
+
+
+    context 'with required arguments' do
+      let(:endpoints) { { method_name => { required_args: [:llama] } } }
+      let(:invalid_args) { { } }
+      let(:method_name) { :endpoint1 }
+      let(:valid_args) { { llama: :blark } }
+      it 'explodes without the required args' do
+        expect { api.send method_name, invalid_args }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+end

data/spec/cases/drink-socially/config_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+require 'yaml'
+
+describe NRB::Untappd::Config do
+
+  shared_examples_for 'a config object' do
+
+    it 'defines accessors from a hash' do
+      config_hash.keys.each do |key|
+        config.should respond_to(key)
+      end
+    end
+
+
+    it 'uses values from its data hash' do
+      config_hash.each do |k,v|
+        config.send(k).should eq v
+      end
+    end
+
+
+    it 'responds to :[]' do
+      config.should respond_to(:[])
+    end
+
+
+    it 'responds to #each' do
+      config.should respond_to(:each)
+    end
+
+
+    it 'responds to :keys' do
+      config.should respond_to(:keys)
+    end
+
+
+    it 'uses keys from its data hash' do
+      config.keys.should eq config.data.keys
+    end
+
+
+    it 'delegates [] to its data hash' do
+      config_hash.each do |k,v|
+        config[k].should eq v
+      end
+    end
+
+  end
+
+
+  context 'loading from a YAML file' do
+    let(:config_hash) { YAML.load_file filename }
+    let(:config) { NRB::Untappd::Config.new filename: filename }
+    let(:filename) { NRB::Untappd.config_file_path '../spec/support/config.yml' }
+    it_behaves_like 'a config object'
+  end
+
+
+  context 'loading from a stream' do
+    let(:config_hash) { { this: :is, a: :stream } }
+    let(:string) { config_hash.to_yaml }
+    let(:string_io) { StringIO.new(string) }
+    let(:config) { NRB::Untappd::Config.new stream: string_io }
+    it_behaves_like 'a config object'
+  end
+
+
+  context 'with no stream or filename argument' do
+    let(:config) { NRB::Untappd::Config.new Hash.new }
+    it 'explodes' do
+      expect { config }.to raise_error(NRB::Untappd::Config::NoConfig)
+    end
+  end
+
+
+  context 'loaders' do
+
+    before :all do
+      Loader = Struct.new(:data) { def load_stream(*args); data; end }
+    end
+
+    let(:config_array) { [ config_hash ] }
+    let(:config_hash) { { change: :the, stream: :loader } }
+    let(:loader) { Loader.new config_array }
+    let(:config) { NRB::Untappd::Config.new stream_loader: loader, stream: {} }
+
+    it 'allows you to change the config loader' do
+      config.should be_a(NRB::Untappd::Config)
+    end
+
+    it_behaves_like 'a config object'
+
+  end
+
+end