hello_sign 1.1.0 → 1.1.1

data/lib/hello_sign/version.rb

@@ -1,3 +1,3 @@
 module HelloSign
-  VERSION = '1.1.0'
+  VERSION = '1.1.1'
 end

data/spec/helper.rb

@@ -6,9 +6,3 @@ RSpec.configure do |config|
   config.color_enabled = true
   config.tty           = true
 end
-
-class Module
-  def _set_internal_collaborator(role, collaborator)
-    instance_variable_set("@#{role.to_s}", collaborator)
-  end
-end

data/spec/integration/hello_sign_spec.rb

@@ -3,7 +3,13 @@ require 'json'
 
 describe HelloSign do
   context "when returning a response with a body" do
-    before { stub_get_with_auth('/json').to_return(body: {account_id: 1}.to_json) }
+    before do
+      stub_get_with_auth('/json')
+        .to_return(
+          headers: {'Content-Type' => 'application/json'},
+          body:    {account_id: 1}.to_json
+        )
+    end
 
     it "parses the body into a hash with symbols as keys" do
       expect(HelloSign.client.get('/json')).to eq({account_id: 1})

data/spec/integration/helper.rb

@@ -22,15 +22,25 @@ def stub_post(path)
 end
 
 def stub_get_with_auth(path)
-  stub_request(:get, "https://david@bowman.com:foobar@api.hellosign.com/v3#{path}")
+  stub_request(
+    :get,
+    "https://david@bowman.com:foobar@api.hellosign.com/v3#{path}"
+  )
 end
 
 def stub_post_with_auth(path)
-  stub_request(:post, "https://david@bowman.com:foobar@api.hellosign.com/v3#{path}")
+  stub_request(
+    :post,
+    "https://david@bowman.com:foobar@api.hellosign.com/v3#{path}"
+  )
 end
 
 def stub_request_with_error(error)
-  stub_request(:any, /api\.hellosign\.com/).to_return(body: {error: {error_name: error}})
+  stub_request(:any, /api\.hellosign\.com/)
+    .to_return(
+      headers: {'Content-Type' => 'application/json'},
+      body:    {error: {error_name: error}}.to_json
+    )
 end
 
 def a_get(path)
@@ -46,5 +56,8 @@ def a_get_with_auth(path)
 end
 
 def a_post_with_auth(path)
-  a_request(:post, "https://david@bowman.com:foobar@api.hellosign.com/v3#{path}")
+  a_request(
+    :post,
+    "https://david@bowman.com:foobar@api.hellosign.com/v3#{path}"
+  )
 end

data/spec/shared_examples/proxy.rb

@@ -2,46 +2,89 @@ shared_examples_for 'a proxy' do
   let(:proxy)        { double('proxy') }
 
   describe "#account" do
+    before do
+      allow(HelloSign::Proxy::Account).to(
+        receive(:new).with(client).and_return(proxy)
+      )
+    end
+
     it "returns an account proxy" do
-      HelloSign::Proxy::Account.should_receive(:new).with(client).and_return(proxy)
       expect(client.account).to eq proxy
     end
   end
 
   describe "#signature_request" do
-    it "returns a signature request proxy" do
-      HelloSign::Proxy::SignatureRequest.should_receive(:new).with(client, nil).and_return(proxy)
-      expect(client.signature_request).to eq proxy
+    before { allow(HelloSign::Proxy::SignatureRequest).to receive(:new) }
+
+    context "when called without a signature request ID" do
+      before do
+        allow(HelloSign::Proxy::SignatureRequest).to(
+          receive(:new).with(client, nil).and_return(proxy)
+        )
+      end
+
+      it "returns a signature request proxy" do
+        expect(client.signature_request).to eq proxy
+      end
     end
 
-    it "passes on an optional signature request ID" do
-      HelloSign::Proxy::SignatureRequest.should_receive(:new).with(client, 'signature_request_id')
-      client.signature_request('signature_request_id')
+    context "when called with a signature request ID" do
+      before { client.signature_request('signature_request_id') }
+
+      it "passes on the signature request ID" do
+        expect(HelloSign::Proxy::SignatureRequest).to(
+          have_received(:new).with(client, 'signature_request_id')
+        )
+      end
     end
   end
 
   describe "#reusable_form" do
-    it "returns a reusable form proxy" do
-      HelloSign::Proxy::ReusableForm.should_receive(:new).with(client, nil).and_return(proxy)
-      expect(client.reusable_form).to eq proxy
+    before { allow(HelloSign::Proxy::ReusableForm).to receive(:new) }
+
+    context "when called without a reusable form ID" do
+      before do
+        allow(HelloSign::Proxy::ReusableForm).to(
+          receive(:new).with(client, nil).and_return(proxy)
+        )
+      end
+
+      it "returns a reusable form proxy" do
+        expect(client.reusable_form).to eq proxy
+      end
     end
 
-    it "passes on an optional reusable form ID" do
-      HelloSign::Proxy::ReusableForm.should_receive(:new).with(client, 'reusable_form_id')
-      client.reusable_form('reusable_form_id')
+    context "when called with a reusable form ID" do
+      before { client.reusable_form('reusable_form_id') }
+
+      it "passes on an optional reusable form ID" do
+        expect(HelloSign::Proxy::ReusableForm).to(
+          have_received(:new).with(client, 'reusable_form_id')
+        )
+      end
     end
   end
 
   describe "#team" do
+    before do
+      allow(HelloSign::Proxy::Team).to(
+        receive(:new).with(client).and_return(proxy)
+      )
+    end
+
     it "returns a team proxy" do
-      HelloSign::Proxy::Team.should_receive(:new).with(client).and_return(proxy)
       expect(client.team).to eq proxy
     end
   end
 
   describe "#unclaimed_draft" do
+    before do
+      allow(HelloSign::Proxy::UnclaimedDraft).to(
+        receive(:new).with(client).and_return(proxy)
+      )
+    end
+
     it "returns an unclaimed draft proxy" do
-      HelloSign::Proxy::UnclaimedDraft.should_receive(:new).with(client).and_return(proxy)
       expect(client.unclaimed_draft).to eq proxy
     end
   end

data/spec/unit/client_spec.rb

@@ -3,53 +3,68 @@ require 'hello_sign/client'
 require 'shared_examples/proxy'
 
 describe HelloSign::Client do
-  let(:email_address) { double('email_address') }
-  let(:password)      { double('password') }
-  subject(:hs_client) { HelloSign::Client.new(email_address, password) }
+  let(:connection) { double('connection') }
+  let(:response)   { double('response') }
+
+  subject(:hs_client) { HelloSign::Client.new('email address', 'password') }
 
   it_behaves_like 'a proxy' do
     let(:client) { hs_client }
   end
 
-  describe "request methods" do
-    let(:path)     { double('path') }
-    let(:options)  { double('options') }
-    let(:response) { double('response') }
+  before do
+    allow(HelloSign::Connection).to receive(:new).and_return(connection)
+  end
+
+  describe "#get" do
+    before do
+      allow(connection).to receive(:get).and_return(response)
 
-    before { hs_client.stub(:request).and_return(response) }
+      @response = hs_client.get('/path', options: 'hash')
+    end
 
-    describe "#get" do
-      it "sends a request" do
-        hs_client.should_receive(:request).with(:get, path, options)
-        hs_client.get(path, options)
-      end
+    it "delegates to the connection" do
+      expect(connection).to have_received(:get).with('/path', options: 'hash')
+    end
 
-      it "returns the response" do
-        expect(hs_client.get(path, options)).to eq response
-      end
+    it "returns the response" do
+      expect(@response).to eq response
     end
+  end
 
-    describe "#post" do
-      it "sends a request" do
-        hs_client.should_receive(:request).with(:post, path, options)
-        hs_client.post(path, options)
-      end
+  describe "#post" do
+    before do
+      allow(connection).to receive(:post).and_return(response)
 
-      it "returns the response" do
-        expect(hs_client.post(path, options)).to eq response
-      end
+      @response = hs_client.post('/path', options: 'hash')
+    end
+
+    it "delegates to the connection" do
+      expect(connection).to(
+        have_received(:post).with('/path', options: 'hash')
+      )
+    end
+
+    it "returns the response" do
+      expect(@response).to eq response
     end
   end
 
   context "when a hash is passed to the constructor" do
-    subject(:hs_client) { HelloSign::Client.new(email_address: email_address, password: password) }
+    subject(:hs_client) do
+      HelloSign::Client.new(email_address: email_address, password: password)
+    end
 
     it "raises an exception if an email address is not provided" do
-      expect { HelloSign::Client.new(password: 'space') }.to raise_error ArgumentError
+      expect { HelloSign::Client.new(password: 'space') }.to(
+        raise_error ArgumentError
+      )
     end
 
     it "raises an exception if a password is not provided" do
-      expect { HelloSign::Client.new(email_address: 'david@bowman.com') }.to raise_error ArgumentError
+      expect { HelloSign::Client.new(email_address: 'david@bowman.com') }.to(
+        raise_error ArgumentError
+      )
     end
   end
 end

data/spec/unit/connection_spec.rb

@@ -0,0 +1,38 @@
+require 'helper'
+require 'hello_sign/connection'
+
+describe HelloSign::Connection do
+  let(:response)   { double('response') }
+
+  subject(:connection) { HelloSign::Connection.new }
+
+  before { allow(connection).to receive(:request).and_return(response) }
+
+  describe "#get" do
+    before { @response = connection.get('/path', options: 'hash') }
+
+    it "sends a request" do
+      expect(connection).to(
+        have_received(:request).with(:get, '/path', options: 'hash')
+      )
+    end
+
+    it "returns the response" do
+      expect(@response).to eq response
+    end
+  end
+
+  describe "#post" do
+    before { @response = connection.post('/path', options: 'hash') }
+
+    it "sends a request" do
+      expect(connection).to(
+        have_received(:request).with(:post, '/path', options: 'hash')
+      )
+    end
+
+    it "returns the response" do
+      expect(@response).to eq response
+    end
+  end
+end

data/spec/unit/error_spec.rb

@@ -2,23 +2,75 @@ require 'helper'
 require 'hello_sign/error'
 
 describe HelloSign::Error do
-  specify { expect { raise HelloSign::Error }.to raise_error StandardError }
-  specify { expect { raise HelloSign::Error::BadRequest }.to raise_error HelloSign::Error }
-  specify { expect { raise HelloSign::Error::Unauthorized }.to raise_error HelloSign::Error }
-  specify { expect { raise HelloSign::Error::Forbidden }.to raise_error HelloSign::Error }
-  specify { expect { raise HelloSign::Error::NotFound }.to raise_error HelloSign::Error }
-  specify { expect { raise HelloSign::Error::Unknown }.to raise_error HelloSign::Error }
-  specify { expect { raise HelloSign::Error::TeamInviteFailed }.to raise_error HelloSign::Error }
-  specify { expect { raise HelloSign::Error::InvalidRecipient }.to raise_error HelloSign::Error }
-  specify { expect { raise HelloSign::Error::ConvertFailed }.to raise_error HelloSign::Error }
-  specify { expect { raise HelloSign::Error::SignatureRequestCancelFailed }.to raise_error HelloSign::Error }
+  specify do
+    expect { raise HelloSign::Error }.to(
+      raise_error StandardError
+    )
+  end
+
+  specify do
+    expect { raise HelloSign::Error::BadRequest }.to(
+      raise_error HelloSign::Error
+    )
+  end
+
+  specify do
+    expect { raise HelloSign::Error::Unauthorized }.to(
+      raise_error HelloSign::Error
+    )
+  end
+
+  specify do
+    expect { raise HelloSign::Error::Forbidden }.to(
+      raise_error HelloSign::Error
+    )
+  end
+
+  specify do
+    expect { raise HelloSign::Error::NotFound }.to(
+      raise_error HelloSign::Error
+    )
+  end
+
+  specify do
+    expect { raise HelloSign::Error::Unknown }.to(
+      raise_error HelloSign::Error
+    )
+  end
+
+  specify do
+    expect { raise HelloSign::Error::TeamInviteFailed }.to(
+      raise_error HelloSign::Error
+    )
+  end
+
+  specify do
+    expect { raise HelloSign::Error::InvalidRecipient }.to(
+      raise_error HelloSign::Error
+    )
+  end
+
+  specify do
+    expect { raise HelloSign::Error::ConvertFailed }.to(
+      raise_error HelloSign::Error
+    )
+  end
+
+  specify do
+    expect { raise HelloSign::Error::SignatureRequestCancelFailed }.to(
+      raise_error HelloSign::Error
+    )
+  end
 
   describe "#to_s" do
-    let(:error)    { HelloSign::Error.new('This is why an error was received.', 401) }
-    let(:expected) { '[Status code: 401] This is why an error was received.' }
+    let(:error) {
+      HelloSign::Error.new('This is why an error was received.', 401)
+    }
 
     it "displays a helpful message" do
-      expect(error.to_s).to eq expected
+      expect(error.to_s).to(
+        eq '[Status code: 401] This is why an error was received.'
+      )
     end
   end
 end

data/spec/unit/hello_sign_spec.rb

@@ -13,18 +13,26 @@ describe HelloSign do
   describe "::client" do
     let(:client) { double('client') }
 
-    it "passes the credentials when creating the client" do
-      HelloSign::Client.should_receive(:new).with(email_address, password)
-      HelloSign.client
+    before { allow(HelloSign::Client).to receive(:new) }
+
+    context "when it has not previously been called" do
+      before { HelloSign.client }
+
+      it "passes the credentials when creating the client" do
+        expect(HelloSign::Client).to(
+          have_received(:new).with(email_address, password)
+        )
+      end
     end
 
     context "when it has previously been called" do
       let(:new_client) { double('new client') }
 
       before do
-        HelloSign::Client.stub(:new).and_return(client, new_client)
-        client.stub(:email_address).and_return(email_address)
-        client.stub(:password).and_return(password)
+        allow(HelloSign::Client).to receive(:new).and_return(client, new_client)
+        allow(client).to receive(:email_address).and_return(email_address)
+        allow(client).to receive(:password).and_return(password)
+
         HelloSign.client
       end
 
@@ -44,35 +52,70 @@ describe HelloSign do
   end
 
   context "when calling delegated methods" do
-    let(:client)        { double('client') }
+    let(:client) { double('client') }
 
-    before { HelloSign::Client.stub(:new).and_return(client) }
+    before { allow(HelloSign::Client).to receive(:new).and_return(client) }
 
     after { HelloSign.instance_variable_set(:@client, nil) }
 
-    it "delegates ::account to the client" do
-      client.should_receive(:account)
-      HelloSign.account
+    describe "::account" do
+      before do
+        allow(client).to receive(:account)
+
+        HelloSign.account
+      end
+
+      it "delegates to the client" do
+        expect(client).to have_received(:account)
+      end
     end
 
-    it "delegates ::signature_request to the client" do
-      client.should_receive(:signature_request)
-      HelloSign.signature_request
+    describe "::signature_request" do
+      before do
+        allow(client).to receive(:signature_request)
+
+        HelloSign.signature_request
+      end
+
+      it "delegates ::signature_request to the client" do
+        expect(client).to have_received(:signature_request)
+      end
     end
 
-    it "delegates ::reusable_form to the client" do
-      client.should_receive(:reusable_form)
-      HelloSign.reusable_form
+    describe "::reusable_form" do
+      before do
+        allow(client).to receive(:reusable_form)
+
+        HelloSign.reusable_form
+      end
+
+      it "delegates ::reusable_form to the client" do
+        expect(client).to have_received(:reusable_form)
+      end
     end
 
-    it "delegates ::team to the client" do
-      client.should_receive(:team)
-      HelloSign.team
+    describe "::team" do
+      before do
+        allow(client).to receive(:team)
+
+        HelloSign.team
+      end
+
+      it "delegates ::team to the client" do
+        expect(client).to have_received(:team)
+      end
     end
 
-    it "delegates ::unclaimed_draft to the client" do
-      client.should_receive(:unclaimed_draft)
-      HelloSign.unclaimed_draft
+    describe "::unclaimed_draft" do
+      before do
+        allow(client).to receive(:unclaimed_draft)
+
+        HelloSign.unclaimed_draft
+      end
+
+      it "delegates ::unclaimed_draft to the client" do
+        expect(client).to have_received(:unclaimed_draft)
+      end
     end
   end