hello_sign 1.1.0 → 1.1.1

data/spec/unit/proxy/signature_request_spec.rb

@@ -5,11 +5,14 @@ describe HelloSign::Proxy::SignatureRequest do
   let(:client)       { double('client') }
   let(:request_id)   { 'request_id' }
   let(:api_response) { double('API response') }
-  subject(:sr_proxy) { HelloSign::Proxy::SignatureRequest.new(client, request_id) }
+
+  subject(:sr_proxy) do
+    HelloSign::Proxy::SignatureRequest.new(client, request_id)
+  end
 
   before do
-    client.stub(:get).and_return(api_response)
-    client.stub(:post).and_return(api_response)
+    allow(client).to receive(:get).and_return(api_response)
+    allow(client).to receive(:post).and_return(api_response)
   end
 
   describe "#deliver" do
@@ -17,80 +20,103 @@ describe HelloSign::Proxy::SignatureRequest do
     let(:request_parameters)     { double('request parameters') }
 
     before do
-      request_parameters.stub(:foo=)
-      request_parameters.stub(:formatted).and_return(formatted_request_body)
-      HelloSign::Parameters::SignatureRequest.stub(:new).and_return(request_parameters)
+      allow(request_parameters).to receive(:foo=)
+      allow(request_parameters).to(
+        receive(:formatted).and_return(formatted_request_body)
+      )
+      allow(HelloSign::Parameters::SignatureRequest).to(
+        receive(:new).and_return(request_parameters)
+      )
+
+      @response = sr_proxy.deliver { |params| params.foo = 'bar' }
     end
 
     it "yields the request parameters to the block" do
-      request_parameters.should_receive(:foo=).with('bar')
-      sr_proxy.deliver { |params| params.foo = 'bar' }
+      expect(request_parameters).to have_received(:foo=).with('bar')
     end
 
     it "sends a signature request" do
-      client.should_receive(:post).with('/signature_request/send', body: formatted_request_body)
-      sr_proxy.deliver { |params| params.foo = 'bar' }
+      expect(client).to have_received(:post).with(
+        '/signature_request/send',
+        body: formatted_request_body
+      )
     end
 
     it "returns the response" do
-      expect(sr_proxy.deliver {}).to eq api_response
+      expect(@response).to eq api_response
     end
 
     context "when a reusable form is specified" do
       before do
-        request_parameters.stub(:reusable_form_id=)
-        HelloSign::Parameters::ReusableFormSignatureRequest.stub(:new).and_return(request_parameters)
+        allow(request_parameters).to receive(:reusable_form_id=)
+        allow(HelloSign::Parameters::ReusableFormSignatureRequest).to(
+          receive(:new).and_return(request_parameters)
+        )
+
+        @response = sr_proxy.deliver(form: 'form_id') { }
       end
 
       it "sets the reusable form ID in the request parameters" do
-        request_parameters.should_receive(:reusable_form_id=).with('form_id')
-        sr_proxy.deliver(form: 'form_id') {}
+        expect(request_parameters).to(
+          have_received(:reusable_form_id=).with('form_id')
+        )
       end
 
       it "sends a reusable form signature request" do
-        client.should_receive(:post).with('/signature_request/send_with_reusable_form', body: formatted_request_body)
-        sr_proxy.deliver(form: 'form_id') {}
+        expect(client).to have_received(:post).with(
+          '/signature_request/send_with_reusable_form',
+          body: formatted_request_body
+        )
       end
 
       it "returns the response" do
-        expect(sr_proxy.deliver(form: 'form_id') {}).to eq api_response
+        expect(@response).to eq api_response
       end
     end
   end
 
   describe "#status" do
+    before { @response = sr_proxy.status }
+
     it "fetches the signature request status" do
-      client.should_receive(:get).with("/signature_request/#{request_id}")
-      sr_proxy.status
+      expect(client).to have_received(:get).with(
+        "/signature_request/#{request_id}"
+      )
     end
 
     it "returns the response" do
-      expect(sr_proxy.status).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 
   describe "#list" do
     context "when called without a page number" do
+      before { @response = sr_proxy.list }
+
       it "fetches the first page of signature requests" do
-        client.should_receive(:get).with('/signature_request/list', params: {page: 1})
-        sr_proxy.list
+        expect(client).to have_received(:get).with(
+          '/signature_request/list',
+          params: {page: 1}
+        )
       end
 
       it "returns the response" do
-        client.stub(:get).and_return(api_response)
-        expect(sr_proxy.list).to eq api_response
+        expect(@response).to eq api_response
       end
     end
 
     context "when called with a page number" do
+      before { @response = sr_proxy.list(page: 10) }
+
       it "fetches a list of signature requests from the specified page" do
-        client.should_receive(:get).with('/signature_request/list', params: {page: 10})
-        sr_proxy.list(page: 10)
+        expect(client).to have_received(:get).with(
+          '/signature_request/list',
+          params: {page: 10}
+        )
       end
 
       it "returns the response" do
-        client.stub(:get).and_return(api_response)
-        expect(sr_proxy.list(page: 10)).to eq api_response
+        expect(@response).to eq api_response
       end
     end
   end
@@ -98,35 +124,45 @@ describe HelloSign::Proxy::SignatureRequest do
   describe "#remind" do
     let(:email) { 'john@johnson.com' }
 
+    before { @response = sr_proxy.remind(email: email) }
+
     it "sends a signature request reminder" do
-      client.should_receive(:post).with("/signature_request/remind/#{request_id}", body: {email_address: email})
-      sr_proxy.remind(email: email)
+      expect(client).to have_received(:post).with(
+        "/signature_request/remind/#{request_id}",
+        body: {email_address: email}
+      )
     end
 
     it "returns the response" do
-      expect(sr_proxy.remind(email: email)).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 
   describe "#cancel" do
+    before { @response = sr_proxy.cancel }
+
     it "cancels a signature request" do
-      client.should_receive(:post).with("/signature_request/cancel/#{request_id}")
-      sr_proxy.cancel
+      expect(client).to have_received(:post).with(
+        "/signature_request/cancel/#{request_id}"
+      )
     end
 
     it "returns the response" do
-      expect(sr_proxy.cancel).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 
   describe "#final_copy" do
+    before { @response = sr_proxy.final_copy }
+
     it "fetches a final copy of the signature request" do
-      client.should_receive(:get).with("/signature_request/final_copy/#{request_id}")
-      sr_proxy.final_copy
+      expect(client).to have_received(:get).with(
+        "/signature_request/final_copy/#{request_id}"
+      )
     end
 
     it "returns the response" do
-      expect(sr_proxy.final_copy).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 end

data/spec/unit/proxy/team_spec.rb

@@ -4,84 +4,103 @@ require 'hello_sign/proxy/team'
 describe HelloSign::Proxy::Team do
   let(:client)         { double('client') }
   let(:api_response)   { double('API response') }
+
   subject(:team_proxy) { HelloSign::Proxy::Team.new(client) }
 
   before do
-    client.stub(:get).and_return(api_response)
-    client.stub(:post).and_return(api_response)
+    allow(client).to receive(:get).and_return(api_response)
+    allow(client).to receive(:post).and_return(api_response)
   end
 
   describe "#create" do
     let(:name) { 'The Browncoats' }
 
+    before { @response = team_proxy.create(name: name) }
+
     it "sends a request to create a team" do
-      client.should_receive(:post).with('/team/create', body: {name: name})
-      team_proxy.create(name: name)
+      expect(client).to have_received(:post).with(
+        '/team/create',
+        body: {name: name}
+      )
     end
 
     it "returns the API response" do
-      expect(team_proxy.create(name: name)).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 
   describe "#show" do
+    before { @response = team_proxy.show }
+
     it "sends a request to fetch the team information" do
-      client.should_receive(:get).with('/team')
-      team_proxy.show
+      expect(client).to have_received(:get).with('/team')
     end
 
     it "returns the API response" do
-      expect(team_proxy.show).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 
   describe "#update" do
     let(:new_name) { 'The Bluecoats' }
 
+    before { @response = team_proxy.update(name: new_name) }
+
     it "sends a request to update the team information" do
-      client.should_receive(:post).with('/team', body: {name: new_name})
-      team_proxy.update(name: new_name)
+      expect(client).to have_received(:post).with(
+        '/team',
+        body: {name: new_name}
+      )
     end
 
     it "returns the API response" do
-      expect(team_proxy.update(name: new_name)).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 
   describe "#destroy" do
+    before { @response = team_proxy.destroy }
+
     it "sends a request to destroy the team" do
-      client.should_receive(:post).with('/team/destroy')
-      team_proxy.destroy
+      expect(client).to have_received(:post).with('/team/destroy')
     end
 
     it "returns the API response" do
-      expect(team_proxy.destroy).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 
   describe "#add_member" do
     let(:email_address) { 'john@johnson.com' }
 
+    before { @response = team_proxy.add_member(email_address: email_address) }
+
     it "sends a request to add the member to the team" do
-      client.should_receive(:post).with('/team/add_member', body: {email_address: email_address})
-      team_proxy.add_member(email_address: email_address)
+      expect(client).to have_received(:post).with(
+        '/team/add_member',
+        body: {email_address: email_address}
+      )
     end
 
     it "returns the API response" do
-      expect(team_proxy.add_member(email_address: email_address)).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 
   describe "#remove_member" do
     let(:email_address) { 'john@johnson.com' }
 
+    before { @response = team_proxy.remove_member(email_address: email_address) }
+
     it "sends a request to remove the member from the team" do
-      client.should_receive(:post).with('/team/remove_member', body: {email_address: email_address})
-      team_proxy.remove_member(email_address: email_address)
+      expect(client).to have_received(:post).with(
+        '/team/remove_member',
+        body: {email_address: email_address}
+      )
     end
 
     it "returns the API response" do
-      expect(team_proxy.remove_member(email_address: email_address)).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 end

data/spec/unit/proxy/unclaimed_draft_spec.rb

@@ -4,21 +4,40 @@ require 'hello_sign/proxy/unclaimed_draft'
 describe HelloSign::Proxy::UnclaimedDraft do
   let(:client)       { double('client') }
   let(:api_response) { double('API response') }
+
   subject(:ud_proxy) { HelloSign::Proxy::UnclaimedDraft.new(client) }
 
+  before { allow(client).to receive(:post).and_return(api_response) }
+
   describe "#create" do
     let(:formatted_request_body) { double('formatted request body') }
     let(:draft_parameters)       { double('draft parameters') }
 
     before do
-      HelloSign::Parameters::UnclaimedDraft.stub(:new).and_return(draft_parameters)
-      draft_parameters.stub(:formatted).and_return(formatted_request_body)
-      draft_parameters.should_receive(:foo=).with('bar')
-      client.should_receive(:post).with('/unclaimed_draft/create', body: formatted_request_body).and_return(api_response)
+      allow(HelloSign::Parameters::UnclaimedDraft).to(
+        receive(:new).and_return(draft_parameters)
+      )
+      allow(draft_parameters).to(
+        receive(:formatted).and_return(formatted_request_body)
+      )
+      allow(draft_parameters).to receive(:foo=)
+
+      @response = ud_proxy.create { |params| params.foo = 'bar' }
+    end
+
+    it "yields the request parameters to the block" do
+      expect(draft_parameters).to have_received(:foo=).with('bar')
+    end
+
+    it "sends an unclaimed draft creation request" do
+      expect(client).to have_received(:post).with(
+        '/unclaimed_draft/create',
+        body: formatted_request_body
+      )
     end
 
-    it "sends a unclaimed draft creation request and returns the result" do
-      expect(ud_proxy.create { |params| params.foo = 'bar' }).to eq api_response
+    it "returns the response" do
+      expect(@response).to eq api_response
     end
   end
 end

data/spec/unit/upload_io_spec.rb

@@ -5,53 +5,95 @@ describe HelloSign::File do
   let(:attachment) { double('attachment') }
   let(:io_object)  { double('IO object') }
 
-  it "returns the attachment" do
-    Faraday::UploadIO.stub(:new).and_return(attachment)
+  context "#attachment" do
+    before { allow(Faraday::UploadIO).to receive(:new).and_return(attachment) }
 
-    expect(HelloSign::File.new(filename: 'test.txt').attachment).to eq attachment
-  end
+    it "returns the attachment" do
+      expect(HelloSign::File.new(filename: 'test.txt').attachment).to(
+        eq attachment
+      )
+    end
 
-  context "#upload" do
-    specify do
-      Faraday::UploadIO.should_receive(:new).with('test.txt', 'text/plain')
+    context "when called with a file with a .txt extension" do
+      before { HelloSign::File.new(filename: 'test.txt').attachment }
 
-      HelloSign::File.new(filename: 'test.txt').attachment
+      it "creates an attachment with a text/plain MIME type" do
+        expect(Faraday::UploadIO).to(
+          have_received(:new).with('test.txt', 'text/plain')
+        )
+      end
     end
 
-    specify do
-      Faraday::UploadIO.should_receive(:new).with('test.foo', 'text/plain')
+    context "when called with a file with an unknown extension" do
+      before { HelloSign::File.new(filename: 'test.foo').attachment }
 
-      HelloSign::File.new(filename: 'test.foo').attachment
+      it "creates an attachment with a text/plain MIME type" do
+        expect(Faraday::UploadIO).to(
+          have_received(:new).with('test.foo', 'text/plain')
+        )
+      end
     end
 
-    specify do
-      Faraday::UploadIO.should_receive(:new).with('test.baz', 'fake/mime')
+    context "when called with a specified MIME type" do
+      before do
+        HelloSign::File.new(filename: 'test.baz', mime: 'fake/mime').attachment
+      end
 
-      HelloSign::File.new(filename: 'test.baz', mime: 'fake/mime').attachment
+      it "creates an attachment with the specified MIME type" do
+        expect(Faraday::UploadIO).to(
+          have_received(:new).with('test.baz', 'fake/mime')
+        )
+      end
     end
 
-    specify do
-      Faraday::UploadIO.should_receive(:new).with(io_object, 'text/plain')
+    context "when called with an IO object" do
+      before { HelloSign::File.new(io: io_object).attachment }
 
-      HelloSign::File.new(io: io_object).attachment
+      it "creates an attachment with a text/plain MIME type" do
+        expect(Faraday::UploadIO).to(
+          have_received(:new).with(io_object, 'text/plain')
+        )
+      end
     end
 
-    specify do
-      Faraday::UploadIO.should_receive(:new).with(io_object, 'fake/mime')
+    context "when called with an IO and a specified MIME type" do
+      before do
+        HelloSign::File.new(io: io_object, mime: 'fake/mime').attachment
+      end
 
-      HelloSign::File.new(io: io_object, mime: 'fake/mime').attachment
+      it "creates an attachment with the specified MIME type" do
+        expect(Faraday::UploadIO).to(
+          have_received(:new).with(io_object, 'fake/mime')
+        )
+      end
     end
 
-    specify do
-      Faraday::UploadIO.should_receive(:new).with(io_object, 'fake/mime', 'test.foo')
-
-      HelloSign::File.new(filename: 'test.foo', io: io_object, mime: 'fake/mime').attachment
+    context "when called with a filename, IO object, and MIME type" do
+      before do
+        HelloSign::File.new(
+          filename: 'test.foo',
+          io:       io_object,
+          mime:     'fake/mime'
+        ).attachment
+      end
+
+      it "creates an attachment with the specified information" do
+        expect(Faraday::UploadIO).to(
+          have_received(:new).with(io_object, 'fake/mime', 'test.foo')
+        )
+      end
     end
 
-    specify do
-      Faraday::UploadIO.should_receive(:new).with(io_object, 'text/plain', 'test.foo')
+    context "when called with a filename and IO object" do
+      before do
+        HelloSign::File.new(filename: 'test.foo', io: io_object).attachment
+      end
 
-      HelloSign::File.new(filename: 'test.foo', io: io_object).attachment
+      it "creates an attachment with a text/plain MIME type" do
+        expect(Faraday::UploadIO).to(
+          have_received(:new).with(io_object, 'text/plain', 'test.foo')
+        )
+      end
     end
   end
 end