yelp 1.0.0 → 2.0.0

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'yelp'
+require 'support/request_error'
+require 'support/shared_configuration'
+require 'vcr'
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
+  c.hook_into :webmock
+
+  c.filter_sensitive_data('<YELP_CONSUMER_KEY>') { ENV['YELP_CONSUMER_KEY'] }
+  c.filter_sensitive_data('<YELP_CONSUMER_SECRET>') { ENV['YELP_CONSUMER_SECRET'] }
+  c.filter_sensitive_data('<YELP_TOKEN>') { ENV['YELP_TOKEN'] }
+  c.filter_sensitive_data('<YELP_TOKEN_SECRET>') { ENV['YELP_TOKEN_SECRET'] }
+end

data/spec/support/request_error.rb

@@ -0,0 +1,11 @@
+shared_examples 'a request error' do
+  context 'API' do
+    let(:response_body) { "{\"error\": {\"text\": \"error message\", \"id\": \"INTERNAL_ERROR\"}}" }
+    let(:bad_response)  { double('response', status: 400, body: response_body) }
+
+    it 'should raise an error' do
+      client.stub_chain(:connection, :get).and_return(bad_response)
+      expect { request }.to raise_error(Yelp::InternalError)
+    end
+  end
+end

data/spec/support/shared_configuration.rb

@@ -0,0 +1,11 @@
+shared_context "shared configuration" do
+  let(:valid_api_keys) { Hash[consumer_key: 'abc',
+                          consumer_secret: 'def',
+                          token: 'ghi',
+                          token_secret: 'jkl'] }
+  let(:real_api_keys) { Hash[consumer_key: ENV['YELP_CONSUMER_KEY'],
+                    consumer_secret: ENV['YELP_CONSUMER_SECRET'],
+                    token: ENV['YELP_TOKEN'],
+                    token_secret: ENV['YELP_TOKEN_SECRET']] }
+  let(:invalid_api_keys) { valid_api_keys.merge(consumer_key: nil) }
+end

data/spec/yelp/burst_struct_spec.rb

@@ -0,0 +1,124 @@
+require 'yelp/burst_struct'
+
+describe BurstStruct::Burst do
+  describe '#foo' do
+    subject(:struct) { BurstStruct::Burst.new(foo: 'bar') }
+
+    context 'when a key exists' do
+      it 'should return' do
+        expect(struct.foo).to eql 'bar'
+      end
+    end
+
+    context 'when a key does not exist' do
+      it 'should not respond to it' do
+        expect(struct.respond_to? :super_foo).to eql false
+      end
+    end
+  end
+
+  context 'n deep nested hash' do
+    let(:hash) { Hash[ futurama: { characters: { robots: { best: 'bender' } } } ] }
+
+    subject(:struct) { BurstStruct::Burst.new(hash) }
+
+    describe '#foo#bar#baz#biz' do
+      it 'should return' do
+        expect(struct.futurama.characters.robots.best).to eql 'bender'
+      end
+    end
+  end
+
+  context 'arrays' do
+    let(:hash) { Hash[ businesses: [ { name: 'Yelp', location: 'San Francisco' },
+                                     { name: 'Ice Cream', flavor: 'Chocolate' },
+                                     [ { name: 'Moe', occupation: 'Bartender' } ] ] ] }
+
+    subject(:struct) { BurstStruct::Burst.new(hash) }
+
+    describe '#businesses[0].name' do
+      it 'should return' do
+        expect(struct.businesses[0].name).to eql 'Yelp'
+        expect(struct.businesses[0].location).to eql 'San Francisco'
+      end
+    end
+
+    describe '#business[1].name' do
+      it 'should return' do
+        expect(struct.businesses[1].name).to eql 'Ice Cream'
+        expect(struct.businesses[1].flavor).to eql 'Chocolate'
+      end
+    end
+
+    describe 'nested arrays' do
+      it 'should parse arrays all the way down' do
+        expect(struct.businesses[2][0].name).to eql 'Moe'
+      end
+    end
+  end
+
+  context 'large hash' do
+    let(:hash) do
+      { foo: 1,
+        bar: {
+          baz: 2,
+          bender: {
+            bending: {
+              rodriguez: true
+            }
+          }
+        },
+        fry: [
+          {past: true},
+          {present: true},
+          {future: true}
+        ],
+        turunga: 'leela',
+        'hubert' => 'farnsworth',
+        zoidberg: [
+          'doctor',
+          'homeowner',
+          'moviestar'
+        ]
+      }
+    end
+
+    subject(:struct) { BurstStruct::Burst.new(hash) }
+
+    it 'turns top level into a struct' do
+      expect(struct.foo).to eql 1
+    end
+
+    it 'recursively creates structs all the way down the hash' do
+      expect(struct.bar.baz).to equal 2
+      expect(struct.bar.bender.bending.rodriguez).to eql true
+    end
+
+    it 'creates arrays with hashes into new structs' do
+      expect(struct.fry[0].past).to eql true
+      expect(struct.fry[1].present).to eql true
+      expect(struct.fry[2].future).to eql true
+    end
+
+    it 'turns string keys into structs' do
+      expect(struct.hubert).to eql 'farnsworth'
+    end
+
+    it 'should maintain arrays with non hashes' do
+      expect(struct.zoidberg.size).to eql 3
+      expect(struct.zoidberg[0]).to eql 'doctor'
+    end
+  end
+
+  context 'deserialize' do
+    let(:hash) do
+      { name: 'Bender', company: 'Yelp', title: 'Bending Engineer' }
+    end
+
+    subject(:struct) { BurstStruct::Burst.new(hash) }
+
+    it 'should deserialize to the same json' do
+      expect(struct.to_json).to eql hash.to_json
+    end
+  end
+end

data/spec/yelp/client_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Yelp::Client do
+  include_context 'shared configuration'
+
+  let(:client) { Yelp::Client.new(api_keys) }
+  let(:api_keys) { valid_api_keys }
+
+  def configure_client_with_api_keys(api_keys)
+    client.configure do |config|
+      api_keys.each { |key, value| config.send("#{key}=", value) }
+    end
+  end
+
+  describe '#initialize' do
+    subject { client }
+
+    context 'with valid configuration' do
+      its(:configuration) { should be_a(Yelp::Configuration) }
+      its(:configuration) { should be_frozen }
+
+      it 'should not be reconfigurable' do
+        expect {
+          configure_client_with_api_keys(valid_api_keys)
+        }.to raise_error
+      end
+    end
+
+    context 'with invalid configuration' do
+      let(:api_keys) { invalid_api_keys }
+
+      it 'should raise an error when configuration is invalid' do
+        expect { client }.to raise_error
+      end
+    end
+  end
+
+  describe '#configure' do
+    subject { client.configuration }
+    let(:client) { Yelp::Client.new }
+
+    context 'with valid configuration' do
+      before { configure_client_with_api_keys(api_keys) }
+
+      it 'should set the configuration values' do
+        valid_api_keys.each do |key, value|
+          expect(client.configuration.send(key)).to eql(value)
+        end
+      end
+
+      it 'should not be reconfigurable' do
+        expect { configure_client_with_api_keys(valid_api_keys) }.to raise_error
+      end
+
+      it { should be_a(Yelp::Configuration) }
+      it { should be_frozen }
+    end
+
+    context 'with invalid configuration' do
+      it 'should raise an error' do
+        expect { configure_client_with_api_keys(invalid_api_keys) }.to raise_error
+      end
+    end
+  end
+
+  describe '#connection' do
+    let(:client) { Yelp::Client.new }
+
+    context 'without configuration' do
+      it 'should raise an error' do
+        expect { client.connection }.to raise_error
+      end
+    end
+  end
+end

data/spec/yelp/configuration_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Yelp::Configuration do
+  include_context 'shared configuration'
+
+  let(:api_keys) { valid_api_keys }
+  let(:configuration) { Yelp::Configuration.new(api_keys) }
+
+  describe '#initialize' do
+    subject { configuration }
+
+    Yelp::Configuration::AUTH_KEYS.each do |auth_key|
+      its(auth_key) { should eql(api_keys[auth_key]) }
+    end
+  end
+
+  describe '#auth_keys' do
+    subject { configuration.auth_keys }
+    it { should eql(api_keys) }
+  end
+
+  describe "#valid?" do
+    subject { configuration.valid? }
+
+    context "when keys are valid" do
+      it { should be_true }
+    end
+
+    context "when keys are not set" do
+      let(:api_keys) { Hash.new }
+      it { should be_false }
+    end
+
+    context "when a key is an empty string" do
+      let(:api_keys) { valid_api_keys.merge(consumer_key: '') }
+      it { should be_false }
+    end
+
+    context "when a key is nil" do
+      let(:api_keys) { valid_api_keys.merge(token: nil) }
+      it { should be_false }
+    end
+  end
+end

data/spec/yelp/endpoint/business_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Yelp::Endpoint::Business do
+  include_context 'shared configuration'
+
+  let(:api_keys) { real_api_keys }
+  let(:business) { 'yelp-san-francisco' }
+  let(:client) { Yelp::Client.new(api_keys) }
+
+  describe '#business' do
+    subject {
+      VCR.use_cassette('business') do
+        client.business(business)
+      end
+    }
+
+    it { should be_a(BurstStruct::Burst) }
+    its(:name) { should eql('Yelp') }
+  end
+
+  describe 'errors' do
+    it_behaves_like 'a request error' do
+      let(:request) { client.business(business) }
+    end
+  end
+end

data/spec/yelp/endpoint/search_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Yelp::Endpoint::Search do
+  include_context 'shared configuration'
+
+  let(:api_keys) { real_api_keys }
+  let(:location) { 'San Francisco' }
+  let(:params) { Hash[term: 'restaurants',
+                      category_filter: 'discgolf'] }
+  let(:client) { Yelp::Client.new(api_keys) }
+
+  describe '#search' do
+    subject(:results) {
+      VCR.use_cassette('search') do
+        client.search(location)
+      end
+    }
+
+    it { should be_a(BurstStruct::Burst) }
+    it 'should get results' do
+      expect(results.businesses.size).to be > 0
+    end
+  end
+
+  describe '#search_bounding_box' do
+    let(:bounding_box) { Hash[sw_latitude: 37.7577,
+                              sw_longitude: -122.4376,
+                              ne_latitude: 37.785381,
+                              ne_longitude: -122.391681] }
+
+    subject(:results) {
+      VCR.use_cassette('search_bounding_box') do
+        client.search_by_bounding_box(bounding_box)
+      end
+    }
+
+    it 'should get results' do
+      expect(results.businesses.size).to be > 0
+    end
+  end
+
+  describe '#search_by_coordinates' do
+    let(:coordinates) { Hash[latitude: 37.7577,
+                             longitude: -122.4376] }
+
+    subject(:results) {
+      VCR.use_cassette('search_by_coordinates') do
+        client.search_by_coordinates(coordinates)
+      end
+    }
+
+    it 'should get results' do
+      expect(results.businesses.size).to be > 0
+    end
+  end
+
+  describe 'errors' do
+    context 'search' do
+      it 'raises when #search_by_coordinates params are empty' do
+        expect { client.search_by_coordinates({}, params) }.to raise_error(Yelp::MissingLatLng)
+      end
+
+      it 'raises when #search_by_bounding_box params are empty' do
+        expect { client.search_by_bounding_box({}, params) }.to raise_error(Yelp::BoundingBoxNotComplete)
+      end
+    end
+
+    it_behaves_like 'a request error' do
+      let(:request) { client.search(location) }
+    end
+  end
+end

data/spec/yelp/error_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'yelp'
+
+describe Yelp::Error do
+  context '#from_request' do
+    let(:response_body) { "{\"error\": {\"text\": \"error message\", \"id\": \"INTERNAL_ERROR\"}}" }
+    let(:good_response) { double('response', status: 200) }
+    let(:bad_response)  { double('response', status: 400, body: response_body) }
+
+    it 'should not raise an error' do
+      expect {
+        Yelp::Error.check_for_error(good_response)
+      }.to_not raise_error
+    end
+
+    it 'should raise an internal error' do
+      expect {
+        Yelp::Error.check_for_error(bad_response)
+      }.to raise_error(Yelp::InternalError, 'error message')
+    end
+  end
+end

data/spec/yelp/yelp_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Yelp do
+  describe "#client" do
+    subject { Yelp.client }
+
+    it { should be_a(Yelp::Client) }
+    its(:configuration) { should be_nil }
+  end
+end

data/tasks/console.rake

@@ -0,0 +1,4 @@
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "pry --gem"
+end

data/yelp.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'yelp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'yelp'
+  spec.version       = Yelp::VERSION
+  spec.authors       = ['Tomer Elmalem', 'Yelp']
+  spec.email         = ['telmalem@gmail.com', 'partnerships@yelp.com']
+  spec.summary       = %q{Ruby client library for the Yelp API}
+  spec.description   = 'Provides easy way to interact with the Yelp API in any kind of application'
+  spec.homepage      = 'https://github.com/yelp/yelp.rb'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake', '~> 10.0', '>= 10.0.0'
+  spec.add_development_dependency 'rspec', '~> 2.6'
+  spec.add_development_dependency 'pry', '~> 0.9', '>= 0.9.0'
+  spec.add_development_dependency 'vcr', '~> 2.8', '>= 2.8.0'
+  spec.add_development_dependency 'webmock', '~> 1.17', '>= 1.17.0'
+  spec.add_development_dependency 'yard', '~> 0.8'
+
+  spec.add_runtime_dependency 'faraday', '~> 0.8', '>= 0.8.0'
+  spec.add_runtime_dependency 'faraday_middleware', '~> 0.8', '>= 0.8.0'
+  spec.add_runtime_dependency 'simple_oauth', '~> 0.2', '>= 0.2.0'
+end