govdelivery-tms 0.8.2 → 0.8.3

data/lib/govdelivery/tms/version.rb

@@ -1,5 +1,5 @@
 module GovDelivery
   module TMS #:nodoc:
-    VERSION = "0.8.2"
+    VERSION = '0.8.3'
   end
 end

data/spec/client_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 describe GovDelivery::TMS::Client do
-  context "creating a new client" do
+  context 'creating a new client' do
     before do
-      response = double('response', status: 200, body: {"_links" => [{"self" => "/"}, {"horse" => "/horses/new"}, {"rabbits" => "/rabbits"}]})
+      response = double('response', status: 200, body: { '_links' => [{ 'self' => '/' }, { 'horse' => '/horses/new' }, { 'rabbits' => '/rabbits' }] })
       @raw_connection = double('raw_connection', get: response)
       @connection = allow(GovDelivery::TMS::Connection).to receive(:new).and_return(double('connection', connection: @raw_connection))
       @client = GovDelivery::TMS::Client.new('auth_token', api_root: 'null_url')
@@ -16,21 +16,21 @@ describe GovDelivery::TMS::Client do
       expect(@client.rabbits).to be_kind_of(GovDelivery::TMS::Rabbits)
     end
     it 'should handle 4xx responses' do
-      allow(@raw_connection).to receive(:get).and_return(double('response', status: 404, body: {'message' => 'hi'}))
+      allow(@raw_connection).to receive(:get).and_return(double('response', status: 404, body: { 'message' => 'hi' }))
       expect { @client.get('/blargh') }.to raise_error(GovDelivery::TMS::Request::Error)
     end
     it 'should handle 5xx responses' do
-      allow(@raw_connection).to receive(:get).and_return(double('response', status: 503, body: {'message' => 'oops'}))
+      allow(@raw_connection).to receive(:get).and_return(double('response', status: 503, body: { 'message' => 'oops' }))
       expect { @client.get('/blargh') }.to raise_error(GovDelivery::TMS::Request::Error)
     end
     it 'should handle 202 responses' do
-      allow(@raw_connection).to receive(:get).and_return(double('response', status: 202, body: {'message' => 'hi'}))
+      allow(@raw_connection).to receive(:get).and_return(double('response', status: 202, body: { 'message' => 'hi' }))
       expect { @client.get('/blargh') }.to raise_error(GovDelivery::TMS::Request::InProgress)
     end
 
     context 'creating a new client without output' do
       subject { GovDelivery::TMS::Client.new('auth_token', api_root: 'null_url', logger: false) }
-      its(:logger){ should be_falsey }
+      its(:logger) { should be_falsey }
       its(:horse) { should be_kind_of(GovDelivery::TMS::Horse) }
     end
 

data/spec/command_types_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GovDelivery::TMS::CommandTypes do
-  context "loading command types" do
+  context 'loading command types' do
     let(:client) do
       double('client')
     end
@@ -9,21 +9,21 @@ describe GovDelivery::TMS::CommandTypes do
       @command_types = GovDelivery::TMS::CommandTypes.new(client, '/command_types')
     end
     it 'should GET ok' do
-      body = [{"name"=>"dcm_unsubscribe",
-               "string_fields"=>[],
-               "array_fields"=>["dcm_account_codes"]},
-              {"name"=>"dcm_subscribe",
-               "string_fields"=>["dcm_account_code"],
-               "array_fields"=>["dcm_topic_codes"]},
-              {"name"=>"forward",
-               "string_fields"=>["http_method", "username", "password", "url"],
-               "array_fields"=>[]}] 
+      body = [{ 'name' => 'dcm_unsubscribe',
+                'string_fields' => [],
+                'array_fields' => ['dcm_account_codes'] },
+              { 'name' => 'dcm_subscribe',
+                'string_fields' => ['dcm_account_code'],
+                'array_fields' => ['dcm_topic_codes'] },
+              { 'name' => 'forward',
+                'string_fields' => %w(http_method username password url),
+                'array_fields' => [] }]
       expect(@command_types.client).to receive(:get).and_return(double('response', body: body, status: 200, headers: {}))
       @command_types.get
       expect(@command_types.collection.length).to eq(3)
-      ct = @command_types.collection.find{|c| c.name == "dcm_subscribe"}
-      expect(ct.array_fields).to eq(["dcm_topic_codes"])
-      expect(ct.string_fields).to eq(["dcm_account_code"])
+      ct = @command_types.collection.find { |c| c.name == 'dcm_subscribe' }
+      expect(ct.array_fields).to eq(['dcm_topic_codes'])
+      expect(ct.string_fields).to eq(['dcm_account_code'])
     end
   end
-end
+end

data/spec/email_message_spec.rb

@@ -1,51 +1,50 @@
 require 'spec_helper'
 
 describe GovDelivery::TMS::EmailMessage do
-  context "creating a new message" do
+  context 'creating a new message' do
     let(:client) do
       double('client')
     end
     before do
-      @message = GovDelivery::TMS::EmailMessage.new(client, '/messages/email', {
-        body:       '12345678',
-        subject:    'blah',
-        created_at: 'BAAAAAD',
-        from_email: 'eric@evotest.govdelivery.com',
-        errors_to:  'errors@evotest.govdelivery.com',
-        reply_to:   'replyto@evotest.govdelivery.com'})
+      @message = GovDelivery::TMS::EmailMessage.new(client, '/messages/email',         body:       '12345678',
+                                                                                       subject:    'blah',
+                                                                                       created_at: 'BAAAAAD',
+                                                                                       from_email: 'eric@evotest.govdelivery.com',
+                                                                                       errors_to:  'errors@evotest.govdelivery.com',
+                                                                                       reply_to:   'replyto@evotest.govdelivery.com')
     end
     it 'should not render readonly attrs in json hash' do
       expect(@message.to_json[:body]).to eq('12345678')
       expect(@message.to_json[:created_at]).to eq(nil)
     end
     it 'should initialize with attrs and collections' do
-      expect(@message.body).to             eq('12345678')
-      expect(@message.subject).to          eq('blah')
-      expect(@message.from_email).to       eq('eric@evotest.govdelivery.com')
-      expect(@message.reply_to).to         eq('replyto@evotest.govdelivery.com')
-      expect(@message.errors_to).to        eq('errors@evotest.govdelivery.com')
+      expect(@message.body).to eq('12345678')
+      expect(@message.subject).to eq('blah')
+      expect(@message.from_email).to eq('eric@evotest.govdelivery.com')
+      expect(@message.reply_to).to eq('replyto@evotest.govdelivery.com')
+      expect(@message.errors_to).to eq('errors@evotest.govdelivery.com')
       expect(@message.recipients.class).to eq(GovDelivery::TMS::EmailRecipients)
     end
     it 'should post successfully' do
       response = {
-          body:       'processed',
-          subject:    'blah',
-          from_email: 'eric@evotest.govdelivery.com',
-          errors_to:  'errors@evotest.govdelivery.com',
-          reply_to:   'replyto@evotest.govdelivery.com',
-          recipients: [{email: 'billy@evotest.govdelivery.com'}],
-          failed: [{email: 'billy@evotest.govdelivery.com'}],
-          sent: [{email: 'billy@evotest.govdelivery.com'}],
-          created_at: 'time'
+        body:       'processed',
+        subject:    'blah',
+        from_email: 'eric@evotest.govdelivery.com',
+        errors_to:  'errors@evotest.govdelivery.com',
+        reply_to:   'replyto@evotest.govdelivery.com',
+        recipients: [{ email: 'billy@evotest.govdelivery.com' }],
+        failed: [{ email: 'billy@evotest.govdelivery.com' }],
+        sent: [{ email: 'billy@evotest.govdelivery.com' }],
+        created_at: 'time'
       }
       expect(@message.client).to receive('post').with(@message).and_return(double('response', status: 201, body: response))
       @message.post
-      expect(@message.body).to                              eq('processed')
-      expect(@message.created_at).to                        eq('time')
-      expect(@message.from_email).to                        eq('eric@evotest.govdelivery.com')
-      expect(@message.reply_to).to                          eq('replyto@evotest.govdelivery.com')
-      expect(@message.errors_to).to                         eq('errors@evotest.govdelivery.com')
-      expect(@message.recipients.class).to                  eq(GovDelivery::TMS::EmailRecipients)
+      expect(@message.body).to eq('processed')
+      expect(@message.created_at).to eq('time')
+      expect(@message.from_email).to eq('eric@evotest.govdelivery.com')
+      expect(@message.reply_to).to eq('replyto@evotest.govdelivery.com')
+      expect(@message.errors_to).to eq('errors@evotest.govdelivery.com')
+      expect(@message.recipients.class).to eq(GovDelivery::TMS::EmailRecipients)
       expect(@message.recipients.collection.first.class).to eq(GovDelivery::TMS::EmailRecipient)
       expect(@message.sent.class).to eq(GovDelivery::TMS::EmailRecipients)
       expect(@message.sent.collection.first.class).to eq(GovDelivery::TMS::EmailRecipient)
@@ -53,21 +52,21 @@ describe GovDelivery::TMS::EmailMessage do
       expect(@message.failed.collection.first.class).to eq(GovDelivery::TMS::EmailRecipient)
     end
     it 'should handle errors' do
-      response = {'errors' => {body: "can't be nil"}}
+      response = { 'errors' => { body: "can't be nil" } }
       expect(@message.client).to receive('post').with(@message).and_return(double('response', status: 422, body: response))
       @message.post
       expect(@message.body).to eq('12345678')
-      expect(@message.errors).to eq({body: "can't be nil"})
+      expect(@message.errors).to eq(body: "can't be nil")
     end
 
     it 'should handle 401 errors' do
       expect(@message.client).to receive('post').with(@message).and_return(double('response', status: 401))
-      expect {@message.post}.to raise_error(StandardError, "401 Not Authorized")
+      expect { @message.post }.to raise_error(StandardError, '401 Not Authorized')
     end
 
     it 'should handle 404 errors' do
       expect(@message.client).to receive('post').with(@message).and_return(double('response', status: 404))
-      expect {@message.post}.to raise_error(StandardError, "Can't POST to /messages/email")
+      expect { @message.post }.to raise_error(StandardError, "Can't POST to /messages/email")
     end
   end
 
@@ -80,23 +79,21 @@ describe GovDelivery::TMS::EmailMessage do
       @message = GovDelivery::TMS::EmailMessage.new(client, '/messages/99', {})
     end
     it 'should GET cleanly' do
-      response = {body: 'processed',
-                  subject:    'hey',
-                  from_email: 'eric@evotest.govdelivery.com',
-                  errors_to:  'errors@evotest.govdelivery.com',
-                  reply_to:   'replyto@evotest.govdelivery.com',
-                  recipients: [{email: 'billy@evotest.govdelivery.com'}],
-                  created_at: 'time'}
+      response = { body: 'processed',
+                   subject:    'hey',
+                   from_email: 'eric@evotest.govdelivery.com',
+                   errors_to:  'errors@evotest.govdelivery.com',
+                   reply_to:   'replyto@evotest.govdelivery.com',
+                   recipients: [{ email: 'billy@evotest.govdelivery.com' }],
+                   created_at: 'time' }
       expect(@message.client).to receive('get').with(@message.href).and_return(double('response', status: 200, body: response))
       @message.get
-      expect(@message.body).to       eq('processed')
-      expect(@message.subject).to    eq('hey')
+      expect(@message.body).to eq('processed')
+      expect(@message.subject).to eq('hey')
       expect(@message.from_email).to eq('eric@evotest.govdelivery.com')
-      expect(@message.reply_to).to   eq('replyto@evotest.govdelivery.com')
-      expect(@message.errors_to).to  eq('errors@evotest.govdelivery.com')
+      expect(@message.reply_to).to eq('replyto@evotest.govdelivery.com')
+      expect(@message.errors_to).to eq('errors@evotest.govdelivery.com')
       expect(@message.created_at).to eq('time')
     end
   end
-
-
 end

data/spec/email_template_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GovDelivery::TMS::EmailTemplate do
-  context "creating a list of email templates" do
+  context 'creating a list of email templates' do
     let(:client) do
       double('client')
     end
@@ -12,15 +12,15 @@ describe GovDelivery::TMS::EmailTemplate do
     it 'should be able to get a list of email templates' do
       response = [
         {
-        'id'                         => "1",
-        'body'                       => "Template 1",
-        'subject'                    => "This is the template 1 subject",
-        'link_tracking_parameters'   => "test=ok&hello=world",
-        'macros'                     => {"MACRO1" => "1"},
-        'open_tracking_enabled'      => true,
-        'click_tracking_enabled'     => true,
-        'created_at'                 => "sometime",
-        '_links'                     => {"self" => "/templates/email/1","account" => "/accounts/1","from_address" => "/from_addresses/1"}
+          'id'                         => '1',
+          'body'                       => 'Template 1',
+          'subject'                    => 'This is the template 1 subject',
+          'link_tracking_parameters'   => 'test=ok&hello=world',
+          'macros'                     => { 'MACRO1' => '1' },
+          'open_tracking_enabled'      => true,
+          'click_tracking_enabled'     => true,
+          'created_at'                 => 'sometime',
+          '_links'                     => { 'self' => '/templates/email/1', 'account' => '/accounts/1', 'from_address' => '/from_addresses/1' }
         }
       ]
 
@@ -30,31 +30,29 @@ describe GovDelivery::TMS::EmailTemplate do
     end
   end
 
-  context "creating an email template" do
+  context 'creating an email template' do
     let(:client) do
       double('client')
     end
     before do
-      @template = GovDelivery::TMS::EmailTemplate.new(client, '/templates/email', {
-        body:                       "Template 1",
-        subject:                    "This is the template 1 subject",
-        link_tracking_parameters:   "test=ok&hello=world",
-        macros:                     {"MACRO1" => "1"},
-        open_tracking_enabled:      true,
-        click_tracking_enabled:     true,
-      })
+      @template = GovDelivery::TMS::EmailTemplate.new(client, '/templates/email',         body:                       'Template 1',
+                                                                                          subject:                    'This is the template 1 subject',
+                                                                                          link_tracking_parameters:   'test=ok&hello=world',
+                                                                                          macros:                     { 'MACRO1' => '1' },
+                                                                                          open_tracking_enabled:      true,
+                                                                                          click_tracking_enabled:     true)
     end
 
     it 'should render linkable attrs in json hash' do
-      @template.links[:from_address] = "1"
-      @template.links[:invalid] = "2"
+      @template.links[:from_address] = '1'
+      @template.links[:invalid] = '2'
       links = @template.to_json[:_links]
       expect(links[:from_address]).to eq('1')
       expect(links[:invalid]).to be_nil
     end
 
     it 'should clear the links property after a successful post' do
-      @template.links[:from_address] = "1"
+      @template.links[:from_address] = '1'
       expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 201, body: {}))
       @template.post
       links = @template.to_json[:_links]
@@ -62,40 +60,40 @@ describe GovDelivery::TMS::EmailTemplate do
     end
 
     it 'should not clear the links property after an invalid post' do
-      @template.links[:from_address] = "1"
+      @template.links[:from_address] = '1'
       expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 400, body: {}))
       @template.post
       links = @template.to_json[:_links]
-      expect(links[:from_address]).to eq("1")
+      expect(links[:from_address]).to eq('1')
     end
 
     it 'should post successfully' do
       response = {
-        'id'                         => "1",
-        'body'                       => "Template 1",
-        'subject'                    => "This is the template 1 subject",
-        'link_tracking_parameters'   => "test=ok&hello=world",
-        'macros'                     => {"MACRO1" => "1"},
+        'id'                         => '1',
+        'body'                       => 'Template 1',
+        'subject'                    => 'This is the template 1 subject',
+        'link_tracking_parameters'   => 'test=ok&hello=world',
+        'macros'                     => { 'MACRO1' => '1' },
         'open_tracking_enabled'      => true,
         'click_tracking_enabled'     => true,
-        'created_at'                 => "sometime",
-        '_links'                     => {"self" => "/templates/email/1","account" => "/accounts/1","from_address" => "/from_addresses/1"}
+        'created_at'                 => 'sometime',
+        '_links'                     => { 'self' => '/templates/email/1', 'account' => '/accounts/1', 'from_address' => '/from_addresses/1' }
       }
       expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 201, body: response))
       @template.post
-      expect(@template.id).to                                eq('1')
-      expect(@template.body).to                              eq('Template 1')
-      expect(@template.subject).to                           eq('This is the template 1 subject')
-      expect(@template.link_tracking_parameters).to          eq('test=ok&hello=world')
-      expect(@template.macros).to                            eq({"MACRO1"=>"1"})
-      expect(@template.open_tracking_enabled).to             eq(true)
-      expect(@template.click_tracking_enabled).to            eq(true)
-      expect(@template.created_at).to                        eq('sometime')
-      expect(@template.from_address).to                      be_a(GovDelivery::TMS::FromAddress)
+      expect(@template.id).to eq('1')
+      expect(@template.body).to eq('Template 1')
+      expect(@template.subject).to eq('This is the template 1 subject')
+      expect(@template.link_tracking_parameters).to eq('test=ok&hello=world')
+      expect(@template.macros).to eq('MACRO1' => '1')
+      expect(@template.open_tracking_enabled).to eq(true)
+      expect(@template.click_tracking_enabled).to eq(true)
+      expect(@template.created_at).to eq('sometime')
+      expect(@template.from_address).to be_a(GovDelivery::TMS::FromAddress)
     end
   end
 
-  context "handling errors at the template level" do
+  context 'handling errors at the template level' do
     let(:client) do
       double('client')
     end
@@ -104,24 +102,24 @@ describe GovDelivery::TMS::EmailTemplate do
     end
 
     it 'should handle errors' do
-      response = {'errors' => {body: "can't be nil"}}
+      response = { 'errors' => { body: "can't be nil" } }
       expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 422, body: response))
       @template.post
-      expect(@template.errors).to eq({body: "can't be nil"})
+      expect(@template.errors).to eq(body: "can't be nil")
     end
 
     it 'should handle 401 errors' do
       expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 401))
-      expect {@template.post}.to raise_error("401 Not Authorized")
+      expect { @template.post }.to raise_error('401 Not Authorized')
     end
 
     it 'should handle 404 errors' do
       expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 404))
-      expect {@template.post}.to raise_error("Can't POST to /templates/email/1")
+      expect { @template.post }.to raise_error("Can't POST to /templates/email/1")
     end
   end
 
-  context "handling errors at the email_templates root level" do
+  context 'handling errors at the email_templates root level' do
     let(:client) do
       double('client')
     end
@@ -130,20 +128,20 @@ describe GovDelivery::TMS::EmailTemplate do
     end
 
     it 'should handle errors' do
-      response = {'errors' => {body: "can't be nil"}}
+      response = { 'errors' => { body: "can't be nil" } }
       expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 422, body: response))
       @template.post
-      expect(@template.errors).to eq({body: "can't be nil"})
+      expect(@template.errors).to eq(body: "can't be nil")
     end
 
     it 'should handle 401 errors' do
       expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 401))
-      expect {@template.post}.to raise_error("401 Not Authorized")
+      expect { @template.post }.to raise_error('401 Not Authorized')
     end
 
     it 'should handle 404 errors' do
       expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 404))
-      expect {@template.post}.to raise_error("Can't POST to /templates/email")
+      expect { @template.post }.to raise_error("Can't POST to /templates/email")
     end
   end
-end
+end

data/spec/errors_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe GovDelivery::TMS::Errors do
-  context "an errors hash" do
+  context 'an errors hash' do
     let(:object_with_errors) do
-      double('instance', href: 'href', errors: {"body" => ["can't be blank"], "subject" => ["can't be blank"]})
+      double('instance', href: 'href', errors: { 'body' => ["can't be blank"], 'subject' => ["can't be blank"] })
     end
     subject { GovDelivery::TMS::Errors::InvalidVerb.new(object_with_errors) }
     it 'should work' do
       expect(subject.message).to match(/body can't be blank, subject can't be blank/)
     end
   end
-end
+end

data/spec/from_address_spec.rb

@@ -1,64 +1,65 @@
 require 'spec_helper'
 
 describe GovDelivery::TMS::FromAddress do
-  context "creating a list of from addresses" do
+  context 'creating a list of from addresses' do
     let(:client) do
       double('client')
     end
     before do
-      @fromaddresses = GovDelivery::TMS::FromAddress.new(client, '/from_addresses')
+      @fromaddresses = GovDelivery::TMS::FromAddresses.new(client, '/from_addresses')
     end
 
     it 'should be able to get a list of email templates' do
       response = [{
-           'from_email'      => "something@evotest.govdelivery.com",
-           'reply_to_email'  => "something@evotest.govdelivery.com",
-           'bounce_email'    => "something@evotest.govdelivery.com",
-           'is_default'      => true,
-           'created_at'      => "sometime",
-           '_links'          => {"self" => "/from_addresses/1"}
+        'from_email'      => 'something@evotest.govdelivery.com',
+        'reply_to_email'  => 'something@evotest.govdelivery.com',
+        'bounce_email'    => 'something@evotest.govdelivery.com',
+        'is_default'      => true,
+        'created_at'      => 'sometime',
+        '_links'          => { 'self' => '/from_addresses/1' }
       }]
 
-      expect(@fromaddresses.client).to receive('get').with('/from_addresses').and_return(double('/from_addresses', status: 200, body: @from_addresses))
-      @fromaddresses.get
-      expect(@fromaddresses).to eq(@fromaddresses)
+      expect(@fromaddresses.client).to receive('get').with('/from_addresses').and_return(double('/from_addresses', status: 200, body: response, headers: {}))
+      addresses = @fromaddresses.get
+      expect(addresses.collection.length).to eq(1)
+      expect(addresses.collection.first.class).to eq(GovDelivery::TMS::FromAddress)
+      expect(addresses.collection.first.from_email).to eq('something@evotest.govdelivery.com')
     end
   end
 
-  context "creating a from address" do
+  context 'creating a from address' do
     let(:client) do
       double('client')
     end
 
     before do
-      @fromaddress = GovDelivery::TMS::FromAddress.new(client, '/from_addresses', {
-           from_email:      "something@evotest.govdelivery.com",
-           reply_to_email:  "something@evotest.govdelivery.com",
-           bounce_email:    "something@evotest.govdelivery.com",
-           is_default:      true})
+      @fromaddress = GovDelivery::TMS::FromAddress.new(client, '/from_addresses',            from_email:      'something@evotest.govdelivery.com',
+                                                                                             reply_to_email:  'something@evotest.govdelivery.com',
+                                                                                             bounce_email:    'something@evotest.govdelivery.com',
+                                                                                             is_default:      true)
     end
 
     it 'should post successfully' do
       response = {
-           'from_email'      => "something@evotest.govdelivery.com",
-           'reply_to_email'  => "something@evotest.govdelivery.com",
-           'bounce_email'    => "something@evotest.govdelivery.com",
-           'is_default'      => true,
-           'created_at'      => "sometime",
-           '_links'          => {"self" => "/from_addresses/1"}
+        'from_email'      => 'something@evotest.govdelivery.com',
+        'reply_to_email'  => 'something@evotest.govdelivery.com',
+        'bounce_email'    => 'something@evotest.govdelivery.com',
+        'is_default'      => true,
+        'created_at'      => 'sometime',
+        '_links'          => { 'self' => '/from_addresses/1' }
       }
-      expect(@fromaddress.client).to receive('post').with(@fromaddress).and_return(double('response', status: 201, body: response ))
+      expect(@fromaddress.client).to receive('post').with(@fromaddress).and_return(double('response', status: 201, body: response))
       @fromaddress.post
-      expect(@fromaddress.from_email).to                   eq("something@evotest.govdelivery.com")
-      expect(@fromaddress.reply_to_email).to               eq("something@evotest.govdelivery.com")
-      expect(@fromaddress.bounce_email).to                 eq("something@evotest.govdelivery.com")
-      expect(@fromaddress.is_default).to                   eq(true)
-      expect(@fromaddress.created_at).to                   eq("sometime")
-      expect(@fromaddress.href).to                         eq("/from_addresses/1")
+      expect(@fromaddress.from_email).to eq('something@evotest.govdelivery.com')
+      expect(@fromaddress.reply_to_email).to eq('something@evotest.govdelivery.com')
+      expect(@fromaddress.bounce_email).to eq('something@evotest.govdelivery.com')
+      expect(@fromaddress.is_default).to eq(true)
+      expect(@fromaddress.created_at).to eq('sometime')
+      expect(@fromaddress.href).to eq('/from_addresses/1')
     end
   end
 
-  context "handling errors" do
+  context 'handling errors' do
     let(:client) do
       double('client')
     end
@@ -67,20 +68,20 @@ describe GovDelivery::TMS::FromAddress do
     end
 
     it 'should handle errors' do
-      response = {'errors' => {from_email: "can't be nil"}}
+      response = { 'errors' => { from_email: "can't be nil" } }
       expect(@fromaddress.client).to receive('post').with(@fromaddress).and_return(double('response', status: 422, body: response))
       @fromaddress.post
-      expect(@fromaddress.errors).to eq({from_email: "can't be nil"})
+      expect(@fromaddress.errors).to eq(from_email: "can't be nil")
     end
 
     it 'should handle 401 errors' do
       expect(@fromaddress.client).to receive('post').with(@fromaddress).and_return(double('response', status: 401))
-      expect {@fromaddress.post}.to raise_error("401 Not Authorized")
+      expect { @fromaddress.post }.to raise_error('401 Not Authorized')
     end
 
     it 'should handle 404 errors' do
       expect(@fromaddress.client).to receive('post').with(@fromaddress).and_return(double('response', status: 404))
-      expect {@fromaddress.post}.to raise_error("Can't POST to /from_addresses/1")
+      expect { @fromaddress.post }.to raise_error("Can't POST to /from_addresses/1")
     end
   end
-end
+end