vend 0.0.8 → 0.0.9

data/spec/vend/http_client_spec.rb

@@ -1,29 +1,38 @@
 require 'spec_helper'
 
 describe Vend::HttpClient do
-
   let(:base_url)  { "https://foo/bar/" }
   let(:username)  { "username" }
   let(:password)  { "password" }
-  let(:options)   {
-    {:base_url => base_url, :username => username, :password => password}
-  }
+  let(:options)   do
+    {base_url: base_url, username: username, password: password}
+  end
 
-  subject {
+  subject do
     described_class.new(options)
-  }
+  end
+
+  it_behaves_like "it has a logger"
 
-  it_should_behave_like "it has a logger"
+  specify :base_url do
+    expect(subject.base_url).to eq base_url
+  end
+
+  specify :username do
+    expect(subject.username).to eq username
+  end
 
-  its(:base_url) { should == base_url }
-  its(:username) { should == username }
-  its(:password) { should == password }
+  specify :password do
+    expect(subject.password).to eq password
+  end
 
   describe "#verify_ssl?" do
-    its(:verify_ssl) { should be_truthy }
+    specify :verify_ssl do
+      expect(subject.verify_ssl).to be_truthy
+    end
 
     context "when overridden in the options" do
-      subject { described_class.new(options.merge(:verify_ssl => false)) }
+      subject { described_class.new(options.merge(verify_ssl: false)) }
     end
   end
 
@@ -34,115 +43,114 @@ describe Vend::HttpClient do
     let(:port)        { 42 }
 
     before do
-      subject.stub(:verify_mode => verify_mode)
-      http.should_receive(:use_ssl=).with(true)
-      http.should_receive(:verify_mode=).with(verify_mode)
-      http.should_receive(:read_timeout=).with(240)
+      subject.stub(verify_mode: verify_mode)
+      expect(http).to receive(:use_ssl=).with(true)
+      expect(http).to receive(:verify_mode=).with(verify_mode)
+      expect(http).to receive(:read_timeout=).with(240)
       Net::HTTP.stub(:new).with(host, port) { http }
     end
 
     it "returns the http_connection" do
-      subject.get_http_connection(host, port).should == http
+      expect(subject.get_http_connection(host, port)).to eq http
     end
   end
 
   describe "#verify_mode" do
-
     context "when verify_ssl? is true" do
       before do
-        subject.stub(:verify_ssl? => true)
+        subject.stub(verify_ssl?: true)
+      end
+      specify :verify_mode do
+        expect(subject.verify_mode).to eq OpenSSL::SSL::VERIFY_PEER
       end
-      its(:verify_mode) { should == OpenSSL::SSL::VERIFY_PEER }
     end
 
     context "when verify_ssl? is false" do
       before do
-        subject.stub(:verify_ssl? => false)
+        subject.stub(verify_ssl?: false)
+      end
+      specify :verify_mode do
+        expect(subject.verify_mode).to eq OpenSSL::SSL::VERIFY_NONE
       end
-      its(:verify_mode) { should == OpenSSL::SSL::VERIFY_NONE }
     end
-
   end
 
   describe "#request" do
-
     context "when using invalid credentials" do
-
       let(:username)  { "invalid" }
 
       it "raises an error" do
-        stub_request(:get, "https://invalid:password@foo/bar/products").
-          to_return(:status => 401)
+        stub_request(:get, "https://invalid:password@foo/bar/products")
+          .to_return(status: 401)
 
-        expect {
+        expect do
           subject.request('products')
-        }.to raise_error(Vend::Unauthorized)
+        end.to raise_error(Vend::Unauthorized)
       end
-
     end
 
     it "throws an error when an invalid request is made" do
-      stub_request(:get, "https://username:password@foo/bar/invalid").
-        to_return(:status => 404, :body => '{"foo":"bar"}', :headers => {})
+      stub_request(:get, "https://username:password@foo/bar/invalid")
+        .to_return(status: 404, body: '{"foo":"bar"}', headers: {})
 
-      expect {
+      expect do
         subject.request('invalid')
-      }.to raise_error(Vend::HTTPError)
+      end.to raise_error(Vend::HTTPError)
     end
 
     it "returns parsed JSON" do
-      stub_request(:get, "https://username:password@foo/bar/bun").
-        to_return(:status => 200, :body => '{"foo":"bar"}', :headers => {})
-      subject.request("bun").should == {"foo" => "bar"}
+      stub_request(:get, "https://username:password@foo/bar/bun")
+        .to_return(status: 200, body: '{"foo":"bar"}', headers: {})
+      expect(subject.request("bun")).to eq({"foo" => "bar"})
     end
 
     it "returns nil if the response was empty" do
-      stub_request(:get, "https://username:password@foo/bar/bun").
-        to_return(:status => 200, :body => '', :headers => {})
-      subject.request("bun").should be_nil
+      stub_request(:get, "https://username:password@foo/bar/bun")
+        .to_return(status: 200, body: '', headers: {})
+      expect(subject.request("bun")).to be_nil
     end
     it "allows us to specify HTTP method" do
-      stub_request(:post, "https://username:password@foo/bar/foo").
-        to_return(:status => 200, :body => '{"foo":"bar"}', :headers => {})
+      stub_request(:post, "https://username:password@foo/bar/foo")
+        .to_return(status: 200, body: '{"foo":"bar"}', headers: {})
 
-      response = subject.request('foo', :method => :post)
-      response.should == {"foo" => "bar"}
+      response = subject.request('foo', method: :post)
+      expect(response).to eq({"foo" => "bar"})
     end
 
     it "allows us to set a request body" do
-      stub_request(:post, "https://username:password@foo/bar/foo").
-        with(:body => "{\"post\":\"data\"}").
-        to_return(:status => 200, :body => '{"foo":"bar"}', :headers => {})
+      stub_request(:post, "https://username:password@foo/bar/foo")
+        .with(body: "{\"post\":\"data\"}")
+        .to_return(status: 200, body: '{"foo":"bar"}', headers: {})
 
-      response = subject.request('foo', :method => :post, :body => '{"post":"data"}')
-      response.should == {"foo" => "bar"}
+      response = subject.request('foo', method: :post, body: '{"post":"data"}')
+      expect(response).to eq({"foo" => "bar"})
     end
 
     it "allows us to specify url parameters" do
-      stub_request(:get, "https://username:password@foo/bar/foo?foo=bar&baz=baloo&flum%5B0%5D=blob&flum%5B1%5D=splat").
-        to_return(:status => 200, :body => '{"foo":"bar"}', :headers => {})
+      stub_request(:get, "https://username:password@foo/bar/foo?foo=bar&baz=baloo&flum%5B0%5D=blob&flum%5B1%5D=splat")
+        .to_return(status: 200, body: '{"foo":"bar"}', headers: {})
 
-      response = subject.request('foo', :url_params => {:foo => "bar", :baz => "baloo", :flum => ["blob","splat"]})
-      response.should == {"foo" => "bar"}
+      response = subject.request('foo', url_params: {foo: "bar", baz: "baloo", flum: ["blob", "splat"]})
+      expect(response).to eq({"foo" => "bar"})
     end
 
     it "follows redirects" do
-      stub_request(:get, "https://username:password@foo/bar/foo").
-        to_return(:status => 302, :body => '{"bar":"baz"}', :headers => {"Location" => "http://username:password@foo/bar/floo"})
+      stub_request(:get, "https://username:password@foo/bar/foo")
+        .to_return(status: 302, body: '{"bar":"baz"}', headers: {"Location" => "http://username:password@foo/bar/floo"})
 
-      stub_request(:get, "http://username:password@foo/bar/floo").
-        to_return(:status => 200, :body => '{"foo":"bar"}', :headers => {})
+      stub_request(:get, "http://username:password@foo/bar/floo")
+        .to_return(status: 200, body: '{"foo":"bar"}', headers: {})
 
       response = subject.request('foo')
-      response.should == {"foo" => "bar"}
+      expect(response).to eq({"foo" => "bar"})
     end
 
     it "raises an exception when the redirection limit is exceeded" do
-      stub_request(:get, "https://username:password@foo/bar/foo").
-        to_return(:status => 302, :body => '{"bar":"baz"}', :headers => {"Location" => "https://username:password@foo/bar/foo"})
-      expect {
+      stub_request(:get, "https://username:password@foo/bar/foo")
+        .to_return(status: 302, body: '{"bar":"baz"}', headers: {"Location" => "https://username:password@foo/bar/foo"})
+      expect do
         subject.request('foo')
-      }.to raise_exception(Vend::RedirectionLimitExceeded)
+      end.to raise_exception(Vend::RedirectionLimitExceeded)
     end
   end
 end

data/spec/vend/null_logger_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
 describe Vend::NullLogger do
-  it_should_behave_like "a logger"
+  it_behaves_like "a logger"
 end

data/spec/vend/oauth2/auth_code_spec.rb

@@ -1,13 +1,16 @@
 require 'spec_helper'
 
 describe Vend::Oauth2::AuthCode do
-
   subject { described_class.new('store', 'client_id', 'secret', 'redirect_uri') }
 
-  its(:store) { is_expected.to eq('store') }
-  its(:client_id) { is_expected.to eq('client_id') }
-  its(:secret) { is_expected.to eq('secret') }
-  its(:redirect_uri) { is_expected.to eq('redirect_uri') }
+  describe "#initialize" do
+    it "sets up the attr_readers" do
+      expect(subject.store).to        eq 'store'
+      expect(subject.client_id).to    eq 'client_id'
+      expect(subject.secret).to       eq 'secret'
+      expect(subject.redirect_uri).to eq 'redirect_uri'
+    end
+  end
 
   it "creates an instance of Client" do
     expect(subject).to be_a Vend::Oauth2::AuthCode
@@ -19,21 +22,20 @@ describe Vend::Oauth2::AuthCode do
     end
   end
 
-
   describe "#token_from_code" do
-    let(:store) {"store"}
+    let(:store) { "store" }
     let(:token_type) { "Bearer" }
-    let(:access_token) { "Uy4eObSRn1RwzQbAitDMEkY6thdHsDJjwdGehpgr"}
-    let(:refresh_token) {"nbCoejmJp1XZgs7as6FeQQ5QZLlUfefzaBjrxvtV"}
+    let(:access_token) { "Uy4eObSRn1RwzQbAitDMEkY6thdHsDJjwdGehpgr" }
+    let(:refresh_token) { "nbCoejmJp1XZgs7as6FeQQ5QZLlUfefzaBjrxvtV" }
 
     before do
-      stub_request(:post, "https://store.vendhq.com/api/1.0/token").
-          to_return(:status => 200, :body => {token_type: token_type,
-	                expires: 2435942384,
-                  domain_prefix: store,
-                  access_token: access_token,
-                  refresh_token: refresh_token,
-                  expires_at: 2435942383}.to_json, :headers=>{ 'Content-Type' => 'application/json' })
+      stub_request(:post, "https://store.vendhq.com/api/1.0/token")
+          .to_return(status: 200, body: {token_type: token_type,
+                                         expires: 2435942384,
+                                         domain_prefix: store,
+                                         access_token: access_token,
+                                         refresh_token: refresh_token,
+                                         expires_at: 2435942383}.to_json, headers: { 'Content-Type' => 'application/json' })
     end
 
     it "return access token" do
@@ -43,5 +45,4 @@ describe Vend::Oauth2::AuthCode do
       expect(token.refresh_token).to eq(refresh_token)
     end
   end
-
 end

data/spec/vend/oauth2/client_spec.rb

@@ -1,13 +1,16 @@
 require 'spec_helper'
 
 describe Vend::Oauth2::Client do
-
   subject { described_class.new('store', 'auth_token') }
 
-  it_should_behave_like "it has a logger"
+  it_behaves_like "it has a logger"
 
-  its(:store) { is_expected.to eq('store') }
-  its(:auth_token) { is_expected.to eq('auth_token') }
+  describe "#initialize" do
+    it "sets up the attr_readers" do
+      expect(subject.store).to      eq('store')
+      expect(subject.auth_token).to eq('auth_token')
+    end
+  end
 
   it "creates an instance of Client" do
     expect(subject).to be_a Vend::Oauth2::Client
@@ -15,33 +18,30 @@ describe Vend::Oauth2::Client do
 
   describe "resource factories" do
     it "gets all products" do
-      Vend::Resource::Product.should_receive(:all).and_return([])
-      subject.Product.all.should == []
+      expect(Vend::Resource::Product).to receive(:all).and_return([])
+      expect(subject.Product.all).to eq []
     end
   end
 
   describe "#http_client_options" do
-
-    let(:options)   { {:foo => 'bar'} }
+    let(:options)   { {foo: 'bar'} }
     let(:base_url)  { "http://foo/" }
     let(:auth_token)  { "auth_token" }
 
     before do
       subject.stub(
-          :options => options,
-          :base_url => base_url,
-          :auth_token => auth_token
+        options: options,
+        base_url: base_url,
+        auth_token: auth_token
       )
     end
 
-    its(:http_client_options) {
-      should == {
-          :foo => 'bar',
-          :base_url => base_url,
-          :auth_token => auth_token
-      }
-    }
+    specify :http_client_options do
+      expect(subject.http_client_options).to eq({
+        foo: 'bar',
+        base_url: base_url,
+        auth_token: auth_token
+      })
+    end
   end
-
-
-end
+end

data/spec/vend/pagination_info_spec.rb

@@ -1,48 +1,71 @@
 require 'spec_helper'
 
 describe Vend::PaginationInfo do
-
   subject { described_class.new(response) }
 
   let(:response)  { double("response") }
 
-  its(:response)  { should == response }
+  specify :response do
+    expect(subject.response).to eq response
+  end
 
   context "when response has pagination info" do
-    let(:response)  {
+    let(:response)  do
       {
         "pagination" => {
           "results"   => 7461,
           "page"      => 41,
           "page_size" => 100,
-          "pages"     => 75 
+          "pages"     => 75
         }
       }
-    }
+    end
 
-    its(:pages) { should == 75 }
-    its(:page)  { should == 41 }
-    it { should be_paged }
+    specify :pages do
+      expect(subject.pages).to eq 75
+    end
 
-    describe "#last_page?" do
+    specify :page do
+      expect(subject.page).to eq 41
+    end
+
+    specify :paged do
+      expect(subject).to be_paged
+    end
 
-      it { should_not be_last_page }
+    describe "#last_page?" do
+      specify :is_not_last_page do
+        expect(subject).to_not be_last_page
+      end
 
       context "when page is equal to pages" do
         before do
-          subject.stub(:page => 42, :pages => 42)
+          subject.stub(page: 42, pages: 42)
         end
-        it { should be_last_page }
-      end
 
+        specify :is_last_page do
+          expect(subject).to be_last_page
+        end
+      end
     end
   end
 
   context "when response does not have pagination info" do
     let(:response)  { Hash.new }
-    its(:pages) { should == 1 }
-    its(:page)  { should == 1 }
-    it { should be_last_page }
-    it { should_not be_paged }
+    specify :pages do
+      expect(subject.pages).to eq 1
+    end
+
+    specify :page do
+      expect(subject.page).to eq 1
+    end
+
+    specify :is_last_page do
+      expect(subject).to be_last_page
+    end
+
+    specify :is_paged do
+      expect(subject).to_not be_paged
+    end
   end
 end

data/spec/vend/resource/register_sale_product_spec.rb

@@ -5,23 +5,25 @@ describe Vend::Resource::RegisterSaleProduct do
 
   subject { described_class.new(attrs) }
 
-  its(:attrs) { should == attrs }
+  specify :attrs do
+    expect(subject.attrs).to eq attrs
+  end
 
   describe "provides an attr reader for the attributes in attrs" do
     let(:attr1) { double("attr1") }
 
-    let(:attrs) { 
-      { 
+    let(:attrs) do
+      {
         "attr1" => attr1
       }
-    }
+    end
 
     it "responds to attr1" do
-      subject.send(:attr1).should == attr1
+      expect(subject.send(:attr1)).to eq attr1
     end
 
     it "does not respond to attr2" do
-      lambda { subject.send(:attr2) }.should raise_error NoMethodError
+      expect { subject.send(:attr2) }.to raise_error NoMethodError
     end
   end
 end