hello_sign 1.1.0 → 1.1.1

data/spec/unit/middleware/parse_json_spec.rb

@@ -0,0 +1,38 @@
+require 'helper'
+require 'hello_sign/middleware/parse_json'
+require 'json'
+
+describe HelloSign::Middleware::ParseJson do
+  let(:middleware) do
+    HelloSign::Middleware::ParseJson.new(->(env) { Faraday::Response.new(env) })
+  end
+
+  it "does not blow up if there is not a body" do
+    expect { middleware.call({}) }.not_to raise_error
+  end
+
+  context "when the content type is application/json" do
+    let(:env) { {response_headers: {'Content-Type' => 'application/json'}} }
+
+    it "does not change a nil body" do
+      expect(middleware.call(env.merge(body: nil)).env[:body]).to eq nil
+    end
+
+    context "and the body is valid JSON" do
+      let(:body) { {first: 1, second: 2}.to_json }
+
+      it "parses the body into a hash with symbols as keys" do
+        expect(middleware.call(env.merge(body: body)).env[:body])
+          .to eq({first: 1, second: 2})
+      end
+    end
+  end
+
+  context "when the content type is not application/json" do
+    let(:env) { {response_headers: {'Content-Type' => 'application/pdf'}} }
+
+    it "does not parse the body" do
+      expect(middleware.call(env.merge(body: 'dave')).env[:body]).to eq 'dave'
+    end
+  end
+end

data/spec/unit/middleware/raise_error_spec.rb

@@ -8,34 +8,46 @@ describe HelloSign::Middleware::RaiseError do
     specify { expect { call_with_error(error) }.to raise_error exception }
   end
 
-  {
-    'unauthorized'                    => HelloSign::Error::Unauthorized,
-    'forbidden'                       => HelloSign::Error::Forbidden,
-    'not_found'                       => HelloSign::Error::NotFound,
-    'unknown'                         => HelloSign::Error::Unknown,
-    'team_invite_failed'              => HelloSign::Error::TeamInviteFailed,
-    'invalid_recipient'               => HelloSign::Error::InvalidRecipient,
-    'convert_failed'                  => HelloSign::Error::ConvertFailed,
-    'signature_request_cancel_failed' => HelloSign::Error::SignatureRequestCancelFailed,
-    'unidentified_error'              => HelloSign::Error
-  }.each { |error_pair| it_raises_the_proper_exception(*error_pair) }
-
-  it "does not blow up if there is not a body" do
-    expect { middleware.call({}) }.to_not raise_error
-  end
-
-  context "when raising an exception" do
-    let(:expected_message) { "[Status code: 418] I'm a teapot." }
+  context "when the content type is application/json" do
+    {
+      'unauthorized'                    => HelloSign::Error::Unauthorized,
+      'forbidden'                       => HelloSign::Error::Forbidden,
+      'not_found'                       => HelloSign::Error::NotFound,
+      'unknown'                         => HelloSign::Error::Unknown,
+      'team_invite_failed'              => HelloSign::Error::TeamInviteFailed,
+      'invalid_recipient'               => HelloSign::Error::InvalidRecipient,
+      'convert_failed'                  => HelloSign::Error::ConvertFailed,
+      'signature_request_cancel_failed' => HelloSign::Error::SignatureRequestCancelFailed,
+      'unidentified_error'              => HelloSign::Error
+    }.each { |error_pair| it_raises_the_proper_exception(*error_pair) }
+
+    it "does not blow up if there is not a body" do
+      expect { middleware.call({}) }.not_to raise_error
+    end
 
-    it "returns the proper message" do
-      begin
-        call_with_error('bad_request', message: "I'm a teapot.", status_code: 418)
-      rescue HelloSign::Error::BadRequest => e
-        expect("#{e}").to match /#{Regexp.escape(expected_message)}/
+    context "and an exception is raised" do
+      it "returns the proper message" do
+        begin
+          middleware.call(
+            call_with_error(
+              'bad_request',
+              message: "I'm a teapot.",
+              status_code: 418
+            ).merge(response_headers)
+          )
+        rescue HelloSign::Error::BadRequest => e
+          expect("#{e}").to match /#{Regexp.escape("[Status code: 418] I'm a teapot")}/
+        end
       end
     end
   end
 
+  context "when the body is not a hash" do
+    it "does not blow up" do
+      expect { middleware.call(body: 'hal') }.not_to raise_error
+    end
+  end
+
   private
 
   def call_with_error(error, options = {})
@@ -43,6 +55,7 @@ describe HelloSign::Middleware::RaiseError do
       body:     {error: {error_name: error, error_msg: options[:message]}},
       response: {status: options[:status_code]}
     }
+
     middleware.call(env)
   end
 

data/spec/unit/parameters/reusable_form_signature_request_spec.rb

@@ -5,46 +5,83 @@ describe HelloSign::Parameters::ReusableFormSignatureRequest do
   describe "#formatted" do
     let(:request_parameters) { HelloSign::Parameters::ReusableFormSignatureRequest.new }
 
-    before do
-      request_parameters.reusable_form_id = 'form_id'
-      request_parameters.title   = 'Lease'
-      request_parameters.subject = 'Sign this'
-      request_parameters.message = 'You must sign this.'
-      request_parameters.ccs     = [
-        {email_address: 'lawyer@lawfirm.com', role: 'lawyer'},
-        {email_address: 'accountant@llc.com', role: 'accountant'}
-      ]
-      request_parameters.signers = [
-        {name: 'Jack', email_address: 'jack@hill.com', role: 'consultant'},
-        {name: 'Jill', email_address: 'jill@hill.com', role: 'client'}
-      ]
-      request_parameters.custom_fields = [
-        {name: 'cost', value: '$20,000'},
-        {name: 'time', value: 'two weeks'}
-      ]
+    context "when all parameters are provided" do
+      let(:expected) do
+        {
+          reusable_form_id: 'form_id',
+          title:            'Lease',
+          subject:          'Sign this',
+          message:          'You must sign this.',
+          ccs:              {
+            'lawyer'     => {email_address: 'lawyer@lawfirm.com'},
+            'accountant' => {email_address: 'accountant@llc.com'}
+          },
+          signers:          {
+            'consultant' => {name: 'Jack', email_address: 'jack@hill.com'}, 
+            'client'     => {name: 'Jill', email_address: 'jill@hill.com'}
+          },
+          custom_fields:    {
+            'cost' => '$20,000',
+            'time' => 'two weeks'
+          }
+        }
+      end
+
+      before do
+        request_parameters.reusable_form_id = 'form_id'
+        request_parameters.title   = 'Lease'
+        request_parameters.subject = 'Sign this'
+        request_parameters.message = 'You must sign this.'
+        request_parameters.ccs     = [
+          {email_address: 'lawyer@lawfirm.com', role: 'lawyer'},
+          {email_address: 'accountant@llc.com', role: 'accountant'}
+        ]
+        request_parameters.signers = [
+          {name: 'Jack', email_address: 'jack@hill.com', role: 'consultant'},
+          {name: 'Jill', email_address: 'jill@hill.com', role: 'client'}
+        ]
+        request_parameters.custom_fields = [
+          {name: 'cost', value: '$20,000'},
+          {name: 'time', value: 'two weeks'}
+        ]
+      end
+
+      it "returns formatted parameters" do
+        expect(request_parameters.formatted).to eq expected
+      end
     end
 
-    it "returns formatted parameters" do
-      expected = {
-        reusable_form_id: 'form_id',
-        title:            'Lease',
-        subject:          'Sign this',
-        message:          'You must sign this.',
-        ccs:              {
-          'lawyer'     => {email_address: 'lawyer@lawfirm.com'},
-          'accountant' => {email_address: 'accountant@llc.com'}
-        },
-        signers:          {
-          'consultant' => {name: 'Jack', email_address: 'jack@hill.com'}, 
-          'client'     => {name: 'Jill', email_address: 'jill@hill.com'}
-        },
-        custom_fields:    {
-          'cost' => '$20,000',
-          'time' => 'two weeks'
-        }
-      }
+    context "when the ccs parameter is not provided" do
+      before do
+        request_parameters.signers       = []
+        request_parameters.custom_fields = []
+      end
+
+      it "defaults to an empty hash" do
+        expect(request_parameters.formatted[:ccs]).to eq({})
+      end
+    end
+
+    context "when the signers parameter is not provided" do
+      before do
+        request_parameters.ccs           = []
+        request_parameters.custom_fields = []
+      end
+
+      it "defaults to an empty hash" do
+        expect(request_parameters.formatted[:custom_fields]).to eq({})
+      end
+    end
+
+    context "when the custom_fields parameter is not provided" do
+      before do
+        request_parameters.ccs     = []
+        request_parameters.signers = []
+      end
 
-      expect(request_parameters.formatted).to eq expected
+      it "defaults to an empty hash" do
+        expect(request_parameters.formatted[:custom_fields]).to eq({})
+      end
     end
   end
 end

data/spec/unit/parameters/signature_request_spec.rb

@@ -15,7 +15,7 @@ describe HelloSign::Parameters::SignatureRequest do
           message: 'You must sign this.',
           cc_email_addresses: ['lawyer@lawfirm.com', 'spouse@family.com'],
           signers: {
-            0 => {name: 'Jack', email_address: 'jack@hill.com', order: 0}, 
+            0 => {name: 'Jack', email_address: 'jack@hill.com', order: 0},
             1 => {name: 'Jill', email_address: 'jill@hill.com', order: 1}
           },
           file: {1 => text_file, 2 => image_file}
@@ -35,13 +35,19 @@ describe HelloSign::Parameters::SignatureRequest do
           @file_data_1 = {filename: 'test.txt', io: 'text file IO object', mime: 'text/plain'},
           @file_data_2 = {filename: 'test.jpg', io: 'image file IO object', mime: 'image/jpeg'}
         ]
+
+        allow(HelloSign::File).to(
+          receive(:new).with(@file_data_1).and_return(text_file)
+        )
+        allow(HelloSign::File).to(
+          receive(:new).with(@file_data_2).and_return(image_file)
+        )
+        [text_file, image_file].each do |file|
+          allow(file).to receive(:attachment).and_return(file)
+        end
       end
 
       it "returns formatted parameters" do
-        HelloSign::File.should_receive(:new).with(@file_data_1).and_return(text_file)
-        HelloSign::File.should_receive(:new).with(@file_data_2).and_return(image_file)
-        [text_file, image_file].each { |file| file.should_receive(:attachment).and_return(file) }
-
         expect(request_parameters.formatted).to eq expected
       end
     end

data/spec/unit/parameters/unclaimed_draft_spec.rb

@@ -12,17 +12,25 @@ describe HelloSign::Parameters::UnclaimedDraft do
 
     before do
       draft_parameters.files = [
-        @file_data_1 = {filename: 'test.txt', io: text_file,  mime: 'text/plain'},
+        @file_data_1 = {filename: 'test.txt', io: text_file, mime: 'text/html'},
         @file_data_2 = {filename: 'test.jpg', io: image, mime: 'image/jpeg'}
       ]
+
+      allow(HelloSign::File).to(
+        receive(:new).with(@file_data_1).and_return(text_file)
+      )
+      allow(HelloSign::File).to(
+        receive(:new).with(@file_data_2).and_return(image)
+      )
+      [text_file, image].each do |file|
+        allow(file).to receive(:attachment).and_return(file)
+      end
     end
 
     it "returns formatted parameters" do
-      HelloSign::File.should_receive(:new).with(@file_data_1).and_return(text_file)
-      HelloSign::File.should_receive(:new).with(@file_data_2).and_return(image)
-      [text_file, image].each { |file| file.should_receive(:attachment).and_return(file) }
-
-      expect(draft_parameters.formatted).to eq({file: {0 => text_file, 1 => image}})
+      expect(draft_parameters.formatted).to(
+        eq({file: {0 => text_file, 1 => image}})
+      )
     end
   end
 end

data/spec/unit/proxy/account_spec.rb

@@ -10,18 +10,21 @@ describe HelloSign::Proxy::Account do
     let(:email_address) { 'david@bowman.com' }
     let(:password)      { 'password' }
 
-    before { client.stub(:post).and_return(api_response) }
+    before do
+      allow(client).to receive(:post).and_return(api_response)
+
+      account_proxy.create(
+        email_address: 'david@bowman.com',
+        password:      'space'
+      )
+    end
 
     it "sends a request to create an account" do
-      client.should_receive(:post).with(
+      expect(client).to have_received(:post).with(
         '/account/create',
         body: {email_address: 'david@bowman.com', password: 'space'},
         auth_not_required: true
       )
-      account_proxy.create(
-        email_address: 'david@bowman.com',
-        password:      'space'
-      )
     end
 
     it "returns the API response" do
@@ -30,15 +33,20 @@ describe HelloSign::Proxy::Account do
           email_address: 'david@bowman.com',
           password:      'space'
         )
-      ). to eq api_response
+      ).to eq api_response
     end
   end
 
   describe "#settings" do
-    let(:settings_proxy)        { double('settings proxy') }
+    let(:settings_proxy) { double('settings proxy') }
+
+    before do
+      allow(HelloSign::Proxy::Settings).to(
+        receive(:new).with(client).and_return(settings_proxy)
+      )
+    end
 
     it "returns a signature request proxy" do
-      HelloSign::Proxy::Settings.should_receive(:new).with(client).and_return(settings_proxy)
       expect(account_proxy.settings).to be settings_proxy
     end
   end

data/spec/unit/proxy/reusable_form_spec.rb

@@ -6,54 +6,71 @@ describe HelloSign::Proxy::ReusableForm do
   let(:api_response)  { double('API response') }
   let(:form_id)       { 'form_id' }
   let(:email_address) { 'bob@example.com' }
+
   subject(:rf_proxy)  { HelloSign::Proxy::ReusableForm.new(client, form_id) }
 
   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 "#list" do
+    before { @response = rf_proxy.list(page: 10) }
+
     it "sends a request to fetch the list of reusable forms" do
-      client.should_receive(:get).with('/reusable_form/list', params: {page: 10})
-      rf_proxy.list(page: 10)
+      expect(client).to(
+        have_received(:get).with('/reusable_form/list', params: {page: 10})
+      )
     end
 
     it "returns the API response" do
-      expect(rf_proxy.list).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 
   describe "#show" do
+    before { @response = rf_proxy.show }
+
     it "sends a request to fetch the details of a reusable form" do
-      client.should_receive(:get).with("/reusable_form/#{form_id}")
-      rf_proxy.show
+      expect(client).to have_received(:get).with("/reusable_form/#{form_id}")
     end
 
     it "returns the API response" do
-      expect(rf_proxy.show).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 
   describe "#grant_access" do
+    before { @response = rf_proxy.grant_access(email_address: email_address) }
+
     it "sends a request to grant access" do
-      client.should_receive(:post).with("/reusable_form/add_user/#{form_id}", body: {email_address: email_address})
-      rf_proxy.grant_access(email_address: email_address)
+      expect(client).to(
+        have_received(:post).with(
+          "/reusable_form/add_user/#{form_id}",
+          body: {email_address: email_address}
+        )
+      )
     end
 
     it "returns the API response" do
-      expect(rf_proxy.grant_access(:email => email_address)).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 
   describe "#revoke_access" do
+    before { @response = rf_proxy.revoke_access(email_address: email_address) }
+
     it "sends a request to revoke access" do
-      client.should_receive(:post).with("/reusable_form/remove_user/#{form_id}", body: {email_address: email_address})
-      rf_proxy.revoke_access(email_address: email_address)
+      expect(client).to(
+        have_received(:post).with(
+          "/reusable_form/remove_user/#{form_id}",
+          body: {email_address: email_address}
+        )
+      )
     end
 
     it "returns the API response" do
-      expect(rf_proxy.revoke_access(email_address: email_address)).to eq api_response
+      expect(@response).to eq api_response
     end
   end
 end

data/spec/unit/proxy/settings_spec.rb

@@ -3,6 +3,7 @@ require 'hello_sign/proxy/settings'
 
 describe HelloSign::Proxy::Settings do
   let(:client)       { double('client') }
+
   subject(:settings) { HelloSign::Proxy::Settings.new(client) }
 
   describe "#client" do
@@ -15,15 +16,21 @@ describe HelloSign::Proxy::Settings do
     let(:callback_url) { 'http://www.callmemaybe.com' }
     let(:api_response) { double('API response') }
 
-    before { client.stub(:post).and_return(api_response) }
+    before do
+      allow(client).to receive(:post).and_return(api_response)
+
+      @response = settings.update(callback_url: callback_url)
+    end
 
     it "sends a request to update the account's settings" do
-      client.should_receive(:post).with('/account', body: {callback_url: callback_url})
-      settings.update(callback_url: callback_url)
+      expect(client).to have_received(:post).with(
+        '/account',
+        body: {callback_url: callback_url}
+      )
     end
 
     it "returns the API response" do
-      expect(settings.update(callback_url: callback_url)).to be api_response
+      expect(@response).to be api_response
     end
   end
 end