vend 0.0.7 → 0.0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 36886eb6986fbeb8cea81493ff3f87cfc75d2e7c
+  data.tar.gz: d0bc6a8d32403071b1bcead22e49bd74771cb83b
+SHA512:
+  metadata.gz: de2eeb7b4b76dd5d1fbbad65784fb63df20c1cd80314886e7cf9bbc5e69642c92340bbcd94c7ff9988d13f07481b9b38cabaac129094e81129bc8d414e352a44
+  data.tar.gz: e1539bfb0b731bb01b9ce40a38d888518b32db7dc66bc259fb223bc5b31048a07f388e52f6c22889641f4adb8e280a7c9e06645f6405e4c5cc01b9f461b885f3

data/.gitignore

@@ -4,3 +4,5 @@ Gemfile.lock
 pkg/*
 doc/*
 .rvmrc
+use-cases/
+.idea*

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
 rvm:
-  - 1.9.2
   - 1.9.3
+  - 2.0.0
+  - 2.1.1

data/README.rdoc

@@ -1,4 +1,4 @@
-= Vend API Gem
+= Vend API Gem {<img src="https://travis-ci.org/trineo/vend-ruby.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/trineo/vend-ruby]
 
 This gem provides access to Vend's REST API.
 
@@ -6,3 +6,40 @@ This gem provides access to Vend's REST API.
 
 At the time of writing, this is located at
 https://docs.google.com/document/pub?id=13JiV6771UcrkmawFRxzvVl3tf5PGSTBH56RYy0-5cps
+
+== Using Vend API via Oauth 2.0
+
+You will need to implement the following steps to connect your application to a Vend Retailer account.
+
+=====1 Requesting authorisation url. User must be redirected to this url in order to receive authorisation code.
+
+    auth_code = Vend::Oauth2::AuthCode.new(STORE, CLIENT_ID, SECRET, REDIRECT_URI)
+    url = auth_code.authorize_url
+
+Url will look like:
+ https://secure.vendhq.com/connect?response_type=code&client_id={client_id}&redirect_uri={redirect_uri}&state={state}
+
+After successful authorisation, you will be redirected to:
+ {redirect_uri}?code={code}&domain_prefix={domain_prefix}&state={state}
+
+
+=====2 Requesting access token.
+
+    auth_code = Vend::Oauth2::AuthCode.new(STORE, CLIENT_ID, SECRET, REDIRECT_URI)
+    token = auth_code.token_from_code(params[:code])
+
+Where <b>token</b> is an instance of OAuth2::AccessToken http://www.rubydoc.info/gems/oauth2/1.0.0/OAuth2/AccessToken
+
+=====3  Using the token to access the Vend API.
+
+    client = Vend::Oauth2::Client.new(STORE, AUTH_TOKEN)
+    client.Product.all.each do |product|
+      puts product.name
+    end
+
+=====4 Refreshing the access token
+
+    auth_code = Vend::Oauth2::AuthCode.new(STORE, CLIENT_ID, SECRET, REDIRECT_URI)
+    token = auth_code.refresh_token(auth_token, refresh_token)
+
+The response payload may include a refresh token, if so, you need to update your currently stored refresh token.

data/Rakefile

@@ -2,7 +2,7 @@ require "bundler/gem_tasks"
 
 require 'rubygems'
 require 'rspec/core/rake_task'
-require 'rake/rdoctask'
+require 'rdoc/task'
 
 Dir.glob('lib/tasks/*.rake').each { |r| import r }
 

data/lib/vend.rb

@@ -22,3 +22,6 @@ require 'vend/resource/user'
 
 require 'vend/http_client'
 require 'vend/client'
+
+require 'vend/oauth2/client'
+require 'vend/oauth2/auth_code'

data/lib/vend/base.rb

@@ -1,5 +1,4 @@
 module Vend
-
   # This Base class provides the basic mapping between Vend::Resource subclasses
   # and the HTTP endpoints in the Vend API.
   #
@@ -90,9 +89,9 @@ module Vend
       end
       available_scopes << method_name
     end
-    
+
     def self.findable_by(field, options = {})
-      
+
       (class << self ; self ; end).instance_eval do
         define_method("find_by_#{field}") do |client, *args|
           search(client, options[:as] || field, *args)

data/lib/vend/http_client.rb

@@ -10,13 +10,14 @@ module Vend
 
     include Logable
 
-    attr_accessor :base_url, :verify_ssl, :username, :password
+    attr_accessor :base_url, :verify_ssl, :username, :password, :auth_token
     alias :verify_ssl? :verify_ssl
 
     def initialize(options = {})
       @base_url = options[:base_url]
       @username = options[:username]
       @password = options[:password]
+      @auth_token = options[:auth_token]
       @verify_ssl = if options.has_key?(:verify_ssl)
                       options[:verify_ssl]
                     else
@@ -74,7 +75,8 @@ module Vend
       # FIXME extract method
       method = ("Net::HTTP::" + options[:method].to_s.classify).constantize
       request = method.new(url.path + url_params_for(options[:url_params]))
-      request.basic_auth username, password
+      request.basic_auth username, password if username && password
+      request['Authorization'] = "Bearer #{auth_token}" if auth_token
 
       request.body = options[:body] if options[:body]
       logger.debug url

data/lib/vend/oauth2/auth_code.rb

@@ -0,0 +1,48 @@
+require 'oauth2'
+
+module Vend
+  module Oauth2
+
+    class AuthCode
+
+      DEFAULT_OPTIONS = {}
+      AUTHORIZE_URL = '/connect'
+      TOKEN_URL = '/api/1.0/token'
+
+      attr_accessor :store, :client_id, :secret, :redirect_uri
+
+      def initialize(store, client_id, secret, redirect_uri, options = {})
+        @store = store
+        @client_id = client_id
+        @secret = secret
+        @redirect_uri = redirect_uri
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+
+      def authorize_url
+        get_oauth2_client.auth_code.authorize_url(:redirect_uri => redirect_uri)
+      end
+
+      def token_from_code(code)
+        client = get_oauth2_client(store)
+        client.auth_code.get_token(code, :redirect_uri => redirect_uri)
+      end
+
+      def refresh_token(auth_token, refresh_token)
+        access_token = OAuth2::AccessToken.new(get_oauth2_client(store), auth_token, {refresh_token: refresh_token})
+        access_token.refresh!
+      end
+
+      protected
+      def get_oauth2_client(domain_prefix = 'secure')
+        OAuth2::Client.new(client_id, secret, {
+            site: "https://#{domain_prefix}.vendhq.com",
+            authorize_url: AUTHORIZE_URL,
+            token_url: TOKEN_URL
+        })
+      end
+
+    end
+
+  end
+end

data/lib/vend/oauth2/client.rb

@@ -0,0 +1,31 @@
+module Vend
+  module Oauth2
+
+    class Client < Vend::Client
+
+      DEFAULT_OPTIONS = {}
+
+      include Logable
+
+      attr_accessor :store, :auth_token
+
+      def initialize(store, auth_token, options = {})
+        @store = store
+        @auth_token = auth_token
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+
+      def http_client
+        @http_client ||= Vend::HttpClient.new(http_client_options)
+      end
+
+      def http_client_options
+        options.merge(
+            :auth_token => @auth_token, :base_url => base_url
+        )
+      end
+
+    end
+
+  end
+end

data/lib/vend/resource_collection.rb

@@ -90,7 +90,7 @@ module Vend
     end
 
     def get_scope(name)
-      
+
       result = scopes.find { |scope| scope.name == name }
       if result.nil?
         raise ScopeNotFoundError.new(

data/lib/vend/version.rb

@@ -1,3 +1,3 @@
 module Vend #:nodoc:
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/spec/integration/product_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Vend::Resource::Product do
-
   let(:expected_attributes) do
     {
       'id'      => '6cc53042-3d5f-11e0-8697-4040f540b50a',

data/spec/spec_helper.rb

@@ -2,13 +2,16 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'rubygems'
 require 'bundler/setup'
 require 'webmock/rspec'
+require 'rspec/its'
+require 'pry'
 Dir["./spec/support/**/*.rb"].each {|f| require f}
 
 require 'cgi'
 require 'vend'
 
 RSpec.configure do |config|
-
+  config.mock_with(:rspec) { |c| c.syntax = [:should, :expect] }
+  config.expect_with(:rspec) { |c| c.syntax = [:should, :expect] }
 end
 
 def get_mock_response(file)

data/spec/support/matchers/have_attributes.rb

@@ -5,7 +5,7 @@ RSpec::Matchers.define :have_attributes do |expected|
     end
   end
 
-  failure_message_for_should do |actual|
+  failure_message do |actual|
     "expected #{actual.attrs} to match #{expected}"
   end
 end

data/spec/support/shared_examples/integration.rb

@@ -18,10 +18,9 @@ def build_receiver
 end
 
 shared_examples "a resource with a collection GET endpoint" do
-
-  let(:username)  {"foo"}
-  let(:password)  {"bar"}
-  let(:store)     {"baz"}
+  let(:username)  { "foo".freeze }
+  let(:password)  { "bar".freeze }
+  let(:store)     { "baz".freeze }
   let(:append_to_url) { '' }
 
   let(:client) do
@@ -33,23 +32,23 @@ shared_examples "a resource with a collection GET endpoint" do
       username, password, store, class_basename.to_s.underscore.pluralize,
       append_to_url
     ]
+
     stub_request(:get, url).to_return(
       :status => 200, :body => get_mock_from_path(:get)
     )
 
     collection = build_receiver.all
-    collection.count.should == expected_collection_length
+    expect(collection.count).to eq(expected_collection_length)
 
     first = collection.first
-    first.should have_attributes(expected_attributes)
+    expect(first).to have_attributes(expected_attributes)
   end
 end
 
 shared_examples "a resource with a singular GET endpoint" do
-
-  let(:username)  {"foo"}
-  let(:password)  {"bar"}
-  let(:store)     {"baz"}
+  let(:username)  { "foo".freeze }
+  let(:password)  { "bar".freeze }
+  let(:store)     { "baz".freeze }
 
   let(:client) do
     Vend::Client.new(store, username, password)
@@ -65,21 +64,20 @@ shared_examples "a resource with a singular GET endpoint" do
 end
 
 shared_examples "a resource with a DELETE endpoint" do
-
-  let(:username)  {"foo"}
-  let(:password)  {"bar"}
-  let(:store)     {"baz"}
+  let(:username)  { "foo".freeze }
+  let(:password)  { "bar".freeze }
+  let(:store)     { "baz".freeze }
 
   let(:client) do
     Vend::Client.new(store, username, password)
   end
 
   it "deletes the resource" do
+
     stub_request(:delete, "https://#{username}:#{password}@#{store}.vendhq.com/api/#{class_basename.to_s.underscore.pluralize}/#{expected_attributes['id']}").
-    to_return(:status => 200, :body => {})
+    to_return(status: 200, body: {}.to_json)
 
     objekt = build_receiver.build(expected_attributes)
-    objekt.delete.should be_true
+    expect(objekt.delete).to be_truthy
   end
-
 end

data/spec/support/shared_examples/logger.rb

@@ -9,7 +9,7 @@ end
 shared_examples_for "it has a logger" do
   describe "#logger" do
 
-    let(:logger)  { mock("logger") }
+    let(:logger)  { double("logger") }
 
     it "defaults to a null logger" do
       subject.logger.should be_instance_of(Vend::NullLogger)

data/spec/vend/base_factory_spec.rb

@@ -7,7 +7,7 @@ describe Vend::BaseFactory do
   class Vend::Resource::Foo < Vend::Base #:nodoc:
   end
 
-  let(:client) { mock() }
+  let(:client) { double() }
   subject { Vend::Resource::FooFactory.new(client, Vend::Resource::Foo) }
 
   it "initializes correctly" do

data/spec/vend/base_spec.rb

@@ -5,349 +5,316 @@ describe Vend::Base do
     url_scope :bar
   end
 
-  let(:client) { mock(:client) }
-  let(:attribute_hash) { {:key => "value"} }
-  let(:mock_response) { 
-      {
-        "foos"=>[
-            {"id"=>"1","bar"=>"baz"},
-            {"id"=>"2","flar"=>"flum"}
-        ]
-      }
+  let(:client) { double(:client) }
+  let(:attribute_hash) { { key: 'value', 'id' => 1} }
+  let(:mock_response) {
+    {
+      'foos'=>[
+        {'id'=>'1','bar'=>'baz'},
+        {'id'=>'2','flar'=>'flum'}
+      ]
+    }
   }
 
   subject { Vend::Resource::Foo.new(client, :attrs => attribute_hash) }
 
-  it "creates an instance of Foo" do
-    subject.should be_instance_of(Vend::Resource::Foo)
+  it 'creates an instance of Foo' do
+    expect(subject).to be_instance_of(Vend::Resource::Foo)
   end
 
-  it "assigns the client" do
-    subject.client.should == client
+  it 'assigns the client' do
+    expect(subject.client).to eq client
   end
 
-  it "assigns the attributes" do
-    subject.attrs.should == attribute_hash
+  it 'assigns the attributes' do
+    expect(subject.attrs).to eq attribute_hash
   end
 
   describe '.build' do
-    it "builds a Foo" do
-      Vend::Resource::Foo.build(client, :attrs => attribute_hash).should
-        be_instance_of(Vend::Resource::Foo)
+    it 'builds a Foo' do
+      expect(Vend::Resource::Foo.build(client, attrs: attribute_hash)).to be_instance_of(Vend::Resource::Foo)
     end
   end
 
   describe '.initialize_singular' do
-
-    it "initializes a singular resource from parsed JSON results" do
-      resource = Vend::Resource::Foo.initialize_singular(client,mock_response)
-      resource.should be_a Vend::Resource::Foo
-      resource.bar.should == "baz"
+    it 'initializes a singular resource from parsed JSON results' do
+      resource = Vend::Resource::Foo.initialize_singular(client, mock_response)
+      expect(resource).to be_a Vend::Resource::Foo
+      expect(resource.bar).to eq 'baz'
     end
 
   end
 
   describe '.initialize_collection' do
-
     subject { Vend::Resource::Foo }
 
-    let(:endpoint)            { mock("endpoint") }
-    let(:args)                { mock("args") }
-    let(:resource_collection) { mock("resource_collection") }
+    let(:endpoint)            { double('endpoint') }
+    let(:args)                { double('args') }
+    let(:resource_collection) { double('resource_collection') }
 
     before do
-      Vend::ResourceCollection.should_receive(:new).with(
+      expect(Vend::ResourceCollection).to receive(:new).with(
         client, subject, endpoint, args
       ) { resource_collection }
     end
 
-    it "creates a ResourceCollection instance" do
-      subject.initialize_collection(
-        client, endpoint, args
-      ).should == resource_collection
+    it 'creates a ResourceCollection instance' do
+      expect(
+        subject.initialize_collection(client, endpoint, args)
+      ).to eq resource_collection
     end
-
   end
 
   describe '.endpoint_name' do
-
-    it "returns the endpoint name" do
-      Vend::Resource::Foo.endpoint_name.should == 'foo'
+    it 'returns the endpoint name' do
+      expect(Vend::Resource::Foo.endpoint_name).to eq 'foo'
     end
-
   end
 
   describe '.collection_name' do
-
-    it "returns the collection name" do
-      Vend::Resource::Foo.collection_name.should == 'foos'
+    it 'returns the collection name' do
+      expect(Vend::Resource::Foo.collection_name).to eq 'foos'
     end
-
   end
 
   describe '.singular_name' do
-
-    it "returns the collection name plus the id" do
-      Vend::Resource::Foo.singular_name("1").should == 'foos/1'
-      Vend::Resource::Foo.singular_name(42).should == 'foos/42'
+    it 'returns the collection name plus the id' do
+      expect(Vend::Resource::Foo.singular_name('1')).to eq 'foos/1'
+      expect(Vend::Resource::Foo.singular_name(42)).to eq 'foos/42'
     end
-
   end
 
-  describe "#singular_name" do
-
-    let(:singular_name) { mock("singular_name")}
-    let(:id)            { 42 }
-
-    before do
-      subject.stub(:id => id)
-      described_class.stub(:singular_name).with(id) { singular_name }
+  describe '#singular_name' do
+    it :singular_name do
+      expect(subject.singular_name).to eq "foos/#{subject.id}"
     end
-
-    its(:singular_name) { should == singular_name }
-
   end
 
   describe '.find' do
-
     let(:id) { 1 }
-    let(:singular_name) { "foos/1" }
+    let(:singular_name) { 'foos/1' }
 
     before do
       Vend::Resource::Foo.stub(:singular_name).with(id) { singular_name }
     end
 
-    it "finds a Foo by id" do
-      mock_response = {"foos"=>[{"id"=>"1","bar"=>"baz"}]}
-      client.should_receive(:request).with(singular_name) { mock_response }
+    it 'finds a Foo by id' do
+      mock_response = { 'foos' => [{ 'id' => '1', 'bar' => 'baz' }]}
+      expect(client).to receive(:request).with(singular_name) { mock_response }
       foo = Vend::Resource::Foo.find(client, id)
-      foo.should be_instance_of(Vend::Resource::Foo)
-      foo.bar.should == "baz"
+      expect(foo).to be_instance_of(Vend::Resource::Foo)
+      expect(foo.bar).to eq 'baz'
     end
-
   end
 
   describe '.all' do
-
     subject { Vend::Resource::Foo }
 
-    let(:collection_name)     { mock("collection_name") }
-    let(:resource_collection) { mock("resource_collection") }
+    let(:collection_name)     { double('collection_name') }
+    let(:resource_collection) { double('resource_collection') }
 
     before do
       subject.stub(:collection_name => collection_name)
     end
 
-    it "calls initialize_collection with the collection_name" do
-      subject.should_receive(:initialize_collection).with(
+    it 'calls initialize_collection with the collection_name' do
+      expect(subject).to receive(:initialize_collection).with(
         client, collection_name
       ) { resource_collection }
-      subject.all(client).should == resource_collection
+      expect(subject.all(client)).to eq resource_collection
     end
-
   end
 
   describe '.url_scope' do
-
     subject { Vend::Resource::Foo }
 
-    let(:collection_name)     { mock("collection_name") }
-    let(:resource_collection) { mock("resource_collection") }
-    let(:bar)                 { mock("bar") }
+    let(:collection_name)     { double('collection_name') }
+    let(:resource_collection) { double('resource_collection') }
+    let(:bar)                 { double('bar') }
 
     before do
       subject.stub(:collection_name => collection_name)
     end
 
-    it "calls initialize_collection with collection_name and :bar arg" do
-      subject.should_receive(:initialize_collection).with(
+    it 'calls initialize_collection with collection_name and :bar arg' do
+      expect(subject).to receive(:initialize_collection).with(
         client, collection_name
       ) { resource_collection }
-      resource_collection.should_receive(:scope).with(:bar, bar) {
+      expect(resource_collection).to receive(:scope).with(:bar, bar) {
         resource_collection
       }
-      subject.bar(client, bar).should == resource_collection
+      expect(subject.bar(client, bar)).to eq resource_collection
     end
-
   end
 
-  describe ".search" do
-
+  describe '.search' do
     subject { Vend::Resource::Foo }
 
-    let(:collection_name)     { mock("collection_name") }
-    let(:resource_collection) { mock("resource_collection") }
-    let(:field)               { "field" }
-    let(:query)               { "query" }
+    let(:collection_name)     { double('collection_name') }
+    let(:resource_collection) { double('resource_collection') }
+    let(:field)               { 'field' }
+    let(:query)               { 'query' }
 
     before do
       subject.stub(:collection_name => collection_name)
     end
 
-    it "calls initialize_collection with collection_name and :outlet_id arg" do
-      subject.should_receive(:initialize_collection).with(
+    it 'calls initialize_collection with collection_name and :outlet_id arg' do
+      expect(subject).to receive(:initialize_collection).with(
         client, collection_name, :url_params => { field.to_sym => query }
       ) { resource_collection }
-      subject.search(client, field, query).should == resource_collection
+      expect(subject.search(client, field, query)).to eq resource_collection
     end
-
   end
 
-  describe ".build_from_json" do
-
+  describe '.build_from_json' do
     subject { Vend::Resource::Foo }
 
-    let(:json)              { {"foos" => attributes_array} }
-    let(:attributes_one)    { mock("attributes_one") }
-    let(:attributes_two)    { mock("attributes_two") }
+    let(:json)              { {'foos' => attributes_array} }
+    let(:attributes_one)    { double('attributes_one') }
+    let(:attributes_two)    { double('attributes_two') }
     let(:attributes_array)  { [attributes_one, attributes_two] }
-    let(:instance_one)      { mock("instance_one") }
-    let(:instance_two)      { mock("instance_two") }
+    let(:instance_one)      { double('instance_one') }
+    let(:instance_two)      { double('instance_two') }
 
     specify do
       subject.stub(:build).with(client, attributes_one) { instance_one }
       subject.stub(:build).with(client, attributes_two) { instance_two }
-      subject.build_from_json(client, json).should == [
+      expect(subject.build_from_json(client, json)).to eq [
         instance_one, instance_two
       ]
     end
-
   end
 
-  describe "dynamic instance methods" do
-    let(:attrs) { { "one" => "foo", "two" => "bar", "object_id" => "fail" } }
+  describe 'dynamic instance methods' do
+    let(:attrs) { { 'one' => 'foo', 'two' => 'bar', 'object_id' => 'fail' } }
     subject { Vend::Resource::Foo.new(client, :attrs => attrs) }
 
-    it "responds to top level attributes" do
-      subject.should respond_to(:one)
-      subject.should respond_to(:two)
-      subject.should respond_to(:object_id)
-
-      subject.one.should == "foo"
-      subject.two.should == "bar"
-      subject.object_id.should_not == "fail"
-      subject.attrs['object_id'].should == "fail"
+    it 'responds to top level attributes' do
+      expect(subject).to respond_to(:one)
+      expect(subject).to respond_to(:two)
+      expect(subject).to respond_to(:object_id)
+      expect(subject.one).to eq 'foo'
+      expect(subject.two).to eq 'bar'
+      expect(subject.object_id).to_not eq 'fail'
+      expect(subject.attrs['object_id']).to eq 'fail'
     end
   end
 
-  describe "delete!" do
-
-    context "when id is present" do
+  describe 'delete!' do
+    context 'when id is present' do
       subject { Vend::Resource::Foo.new(client, :attrs => {'id' => 1}) }
 
-      let(:singular_name) { mock("singular_name")}
+      let(:singular_name) { double('singular_name')}
 
       before do
         subject.stub(:singular_name => singular_name)
       end
 
-      it "deletes the object" do
-        client.should_receive(:request).with(singular_name, :method => :delete)
+      it 'deletes the object' do
+        expect(client).to receive(:request).with(singular_name, method: :delete)
         subject.delete!
       end
     end
 
-    context "when id is absent" do
+    context 'when id is absent' do
       subject { Vend::Resource::Foo.new(client, :attrs => {:foo => 'bar'}) }
 
-      it "raises Vend::Resource::IllegalAction" do
-        client.should_not_receive(:request)
+      it 'raises Vend::Resource::IllegalAction' do
+        expect(client).to_not receive(:request)
         expect {
           subject.delete!
-        }.to raise_error(Vend::Resource::IllegalAction, "Vend::Resource::Foo has no unique ID")
+        }.to raise_error(Vend::Resource::IllegalAction, 'Vend::Resource::Foo has no unique ID')
       end
     end
-
   end
 
   describe 'delete' do
-
-    it "returns false when no id is present" do
-      objekt = Vend::Resource::Foo.new(client, :attrs => {:foo => 'bar'})
-      client.should_not_receive(:request)
-      objekt.delete.should be_false
+    it 'returns false when no id is present' do
+      subject = Vend::Resource::Foo.new(client, :attrs => {:foo => 'bar'})
+      expect(client).to_not receive(:request)
+      expect(subject.delete).to be_falsey
     end
-
   end
 
   describe '.default_collection_request_args' do
     subject { Vend::Resource::Foo }
-    its(:default_collection_request_args) { should == {} }
+    it :default_collection_request_args do
+      expect(subject.default_collection_request_args).to eq({})
+    end
   end
 
-  describe ".paginates?" do
-
+  describe '.paginates?' do
     subject { Vend::Resource::Foo }
 
-    it "defaults to false" do
-      subject.paginates?.should be_false
+    it 'defaults to false' do
+      expect(subject.paginates?).to be_falsey
     end
-
   end
 
-  describe ".available_scopes" do
+  describe '.available_scopes' do
     subject { Vend::Resource::Foo }
-    its(:available_scopes)  { should == [:bar] }
+    it :available_scopes do
+      expect(subject.available_scopes).to eq [:bar]
+    end
   end
 
-  describe ".accepts_scope?" do
+  describe '.accepts_scope?' do
     let(:scope_name) {:scope_name}
     subject { Vend::Resource::Foo }
-    
-    context "when scope is accepted" do
+
+    context 'when scope is accepted' do
       before do
-        subject.stub(:available_scopes => [scope_name])
+        subject.stub(available_scopes: [scope_name])
       end
       specify do
-        subject.accepts_scope?(scope_name).should be_true
+        expect(subject.accepts_scope?(scope_name)).to be_truthy
       end
     end
 
-    context "when scope is not accepted" do
+    context 'when scope is not accepted' do
       before do
-        subject.stub(:available_scopes => [])
+        subject.stub(available_scopes: [])
       end
       specify do
-        subject.accepts_scope?(scope_name).should be_false
+        expect(subject.accepts_scope?(scope_name)).to be_falsey
       end
     end
   end
 
-  describe ".findable_by" do
+  describe '.findable_by' do
     subject { Vend::Resource::Foo }
 
-    let(:args)  { mock("args") }
+    let(:args)  { double('args') }
 
-    it "creates a find_by_foo method on the class" do
-      subject.should_not respond_to(:find_by_foo)
+    it 'creates a find_by_foo method on the class' do
+      expect(subject).to_not respond_to(:find_by_foo)
       subject.findable_by(:foo)
-      subject.should respond_to(:find_by_foo)
+      expect(subject).to respond_to(:find_by_foo)
     end
 
-    it "proxies to search" do
+    it 'proxies to search' do
       subject.findable_by(:foo)
-      subject.should_receive(:search).with(client, :foo, args)
+      expect(subject).to receive(:search).with(client, :foo, args)
       subject.find_by_foo(client, args)
     end
 
-    it "allows a different method name" do
-      subject.findable_by(:foo, :as => :bar)
-      subject.should_receive(:search).with(client, :bar, args)
+    it 'allows a different method name' do
+      subject.findable_by(:foo, as: :bar)
+      expect(subject).to receive(:search).with(client, :bar, args)
       subject.find_by_foo(client, args)
     end
-
   end
 
-  describe ".cast_attribute" do
-
+  describe '.cast_attribute' do
     subject { Vend::Resource::Foo }
 
     let(:attrs) { {'floater' => '1.23'} }
 
-    it "casts to float" do
+    it 'casts to float' do
       subject.cast_attribute :floater, Float
-      foo = Vend::Resource::Foo.new(client, :attrs => attrs)
-      foo.floater.should == 1.23
+      foo = Vend::Resource::Foo.new(client, attrs: attrs)
+      expect(foo.floater).to eq 1.23
     end
   end
 end