govdelivery-tms 0.8.0 → 0.8.1

data/spec/email_template_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe TMS::EmailTemplate do
+describe GovDelivery::TMS::EmailTemplate do
   context "creating a list of email templates" do
     let(:client) do
       double('client')
     end
     before do
-      @templates = TMS::EmailTemplates.new(client, '/templates/email')
+      @templates = GovDelivery::TMS::EmailTemplates.new(client, '/templates/email')
     end
 
     it 'should be able to get a list of email templates' do
@@ -24,9 +24,9 @@ describe TMS::EmailTemplate do
         }
       ]
 
-      @templates.client.should_receive('get').with('/templates/email').and_return(double('response', :status => 200, :body => response, :headers => {}))
+      expect(@templates.client).to receive('get').with('/templates/email').and_return(double('response', status: 200, body: response, headers: {}))
       @templates.get
-      @templates.collection.length.should == 1
+      expect(@templates.collection.length).to eq(1)
     end
   end
 
@@ -35,13 +35,13 @@ describe TMS::EmailTemplate do
       double('client')
     end
     before do
-      @template = 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
 
@@ -49,24 +49,24 @@ describe TMS::EmailTemplate do
       @template.links[:from_address] = "1"
       @template.links[:invalid] = "2"
       links = @template.to_json[:_links]
-      links[:from_address].should == '1'
-      links[:invalid].should be_nil
+      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.client.should_receive('post').with(@template).and_return(double('response', :status => 201, :body => {}))
+      expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 201, body: {}))
       @template.post
       links = @template.to_json[:_links]
-      links[:from_address].should be_nil
+      expect(links[:from_address]).to be_nil
     end
 
     it 'should not clear the links property after an invalid post' do
       @template.links[:from_address] = "1"
-      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 400, :body => {}))
+      expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 400, body: {}))
       @template.post
       links = @template.to_json[:_links]
-      links[:from_address].should == "1"
+      expect(links[:from_address]).to eq("1")
     end
 
     it 'should post successfully' do
@@ -81,17 +81,17 @@ describe TMS::EmailTemplate do
         'created_at'                 => "sometime",
         '_links'                     => {"self" => "/templates/email/1","account" => "/accounts/1","from_address" => "/from_addresses/1"}
       }
-      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 201, :body => response))
+      expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 201, body: response))
       @template.post
-      @template.id.should                                == '1'
-      @template.body.should                              == 'Template 1'
-      @template.subject.should                           == 'This is the template 1 subject'
-      @template.link_tracking_parameters.should          == 'test=ok&hello=world'
-      @template.macros.should                            == {"MACRO1"=>"1"}
-      @template.open_tracking_enabled.should             == true
-      @template.click_tracking_enabled.should            == true
-      @template.created_at.should                        == 'sometime'
-      @template.from_address.should                      be_a(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
 
@@ -100,23 +100,23 @@ describe TMS::EmailTemplate do
       double('client')
     end
     before do
-      @template = TMS::EmailTemplate.new(client, '/templates/email/1')
+      @template = GovDelivery::TMS::EmailTemplate.new(client, '/templates/email/1')
     end
 
     it 'should handle errors' do
-      response = {'errors' => {:body => "can't be nil"}}
-      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 422, :body => response))
+      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
-      @template.errors.should == {:body => "can't be nil"}
+      expect(@template.errors).to eq({body: "can't be nil"})
     end
 
     it 'should handle 401 errors' do
-      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 401))
+      expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 401))
       expect {@template.post}.to raise_error("401 Not Authorized")
     end
 
     it 'should handle 404 errors' do
-      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 404))
+      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")
     end
   end
@@ -126,23 +126,23 @@ describe TMS::EmailTemplate do
       double('client')
     end
     before do
-      @template = TMS::EmailTemplate.new(client, '/templates/email')
+      @template = GovDelivery::TMS::EmailTemplate.new(client, '/templates/email')
     end
 
     it 'should handle errors' do
-      response = {'errors' => {:body => "can't be nil"}}
-      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 422, :body => response))
+      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
-      @template.errors.should == {:body => "can't be nil"}
+      expect(@template.errors).to eq({body: "can't be nil"})
     end
 
     it 'should handle 401 errors' do
-      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 401))
+      expect(@template.client).to receive('post').with(@template).and_return(double('response', status: 401))
       expect {@template.post}.to raise_error("401 Not Authorized")
     end
 
     it 'should handle 404 errors' do
-      @template.client.should_receive('post').with(@template).and_return(double('response', :status => 404))
+      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")
     end
   end

data/spec/errors_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe TMS::Errors do
+describe GovDelivery::TMS::Errors 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"]})
     end
-    subject { TMS::Errors::InvalidVerb.new(object_with_errors) }
+    subject { GovDelivery::TMS::Errors::InvalidVerb.new(object_with_errors) }
     it 'should work' do
-      subject.message.should =~ /body can't be blank, subject can't be blank/
+      expect(subject.message).to match(/body can't be blank, subject can't be blank/)
     end
   end
 end

data/spec/from_address_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe TMS::FromAddress do
+describe GovDelivery::TMS::FromAddress do
   context "creating a list of from addresses" do
     let(:client) do
       double('client')
     end
     before do
-      @fromaddresses = TMS::FromAddress.new(client, '/from_addresses')
+      @fromaddresses = GovDelivery::TMS::FromAddress.new(client, '/from_addresses')
     end
 
     it 'should be able to get a list of email templates' do
@@ -19,9 +19,9 @@ describe TMS::FromAddress do
            '_links'          => {"self" => "/from_addresses/1"}
       }]
 
-      @fromaddresses.client.should_receive('get').with('/from_addresses').and_return(double('/from_addresses', :status => 200, :body => @from_addresses))
+      expect(@fromaddresses.client).to receive('get').with('/from_addresses').and_return(double('/from_addresses', status: 200, body: @from_addresses))
       @fromaddresses.get
-      @fromaddresses.should == @fromaddresses
+      expect(@fromaddresses).to eq(@fromaddresses)
     end
   end
 
@@ -31,11 +31,11 @@ describe TMS::FromAddress do
     end
 
     before do
-      @fromaddress = 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
@@ -47,14 +47,14 @@ describe TMS::FromAddress do
            'created_at'      => "sometime",
            '_links'          => {"self" => "/from_addresses/1"}
       }
-      @fromaddress.client.should_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
-      @fromaddress.from_email.should                   == "something@evotest.govdelivery.com"
-      @fromaddress.reply_to_email.should               == "something@evotest.govdelivery.com"
-      @fromaddress.bounce_email.should                 == "something@evotest.govdelivery.com"
-      @fromaddress.is_default.should                   == true
-      @fromaddress.created_at.should                   == "sometime"
-      @fromaddress.href.should                         == "/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
 
@@ -63,23 +63,23 @@ describe TMS::FromAddress do
       double('client')
     end
     before do
-      @fromaddress = TMS::FromAddress.new(client, '/from_addresses/1')
+      @fromaddress = GovDelivery::TMS::FromAddress.new(client, '/from_addresses/1')
     end
 
     it 'should handle errors' do
-      response = {'errors' => {:from_email => "can't be nil"}}
-      @fromaddress.client.should_receive('post').with(@fromaddress).and_return(double('response', :status => 422, :body => response))
+      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
-      @fromaddress.errors.should == {:from_email => "can't be nil"}
+      expect(@fromaddress.errors).to eq({from_email: "can't be nil"})
     end
 
     it 'should handle 401 errors' do
-      @fromaddress.client.should_receive('post').with(@fromaddress).and_return(double('response', :status => 401))
+      expect(@fromaddress.client).to receive('post').with(@fromaddress).and_return(double('response', status: 401))
       expect {@fromaddress.post}.to raise_error("401 Not Authorized")
     end
 
     it 'should handle 404 errors' do
-      @fromaddress.client.should_receive('post').with(@fromaddress).and_return(double('response', :status => 404))
+      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")
     end
   end

data/spec/inbound_sms_messages_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
-describe TMS::InboundSmsMessages do
+describe GovDelivery::TMS::InboundSmsMessages do
   context "creating a new inbound messages list" do
     let(:client) do
       double('client')
     end
     before do
-      @messages = TMS::InboundSmsMessages.new(client, '/inbound_messages')
+      @messages = GovDelivery::TMS::InboundSmsMessages.new(client, '/inbound_messages')
     end
     it 'should GET itself' do
-      body = [{:body=>"HELP", :from=>"+16125551212", :created_at=>"a while ago", :to=>"(651) 433-6258"}, {:body=>"STOP", :from=>"+16125551212", :created_at=>"a while ago", :to=>"(651) 433-6258"}]
-      @messages.client.should_receive(:get).and_return(double('response', :body => body, :status => 200, :headers => {}))
+      body = [{body:"HELP", from:"+16125551212", created_at:"a while ago", to:"(651) 433-6258"}, {body:"STOP", from:"+16125551212", created_at:"a while ago", to:"(651) 433-6258"}]
+      expect(@messages.client).to receive(:get).and_return(double('response', body: body, status: 200, headers: {}))
 
       @messages.get
-      @messages.collection.length.should == 2
+      expect(@messages.collection.length).to eq(2)
     end
   end
 end

data/spec/instance_resource_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 class Foo
-  include TMS::InstanceResource
+  include GovDelivery::TMS::InstanceResource
   writeable_attributes :bar
   collection_attribute :blah, 'EmailMessage'
   readonly_collection_attribute :shah, 'EmailMessage'
 end
 
-describe TMS::InstanceResource do
+describe GovDelivery::TMS::InstanceResource do
   context "creating a new inbound messages list" do
     let(:happy_response) do
-      double(:status => 201,  :body => {})
+      double(status: 201,  body: {})
     end
 
     let(:client) do
-      double('client', :post => happy_response, :get => happy_response)
+      double('client', post: happy_response, get: happy_response)
     end
 
 
@@ -23,38 +23,38 @@ describe TMS::InstanceResource do
 
     it 'should POST' do
       @instance_resource.bar = "OMG"
-      @instance_resource.post.should be_truthy
+      expect(@instance_resource.post).to be_truthy
     end
 
     it 'should correctly reflect on collection resources' do
-      @instance_resource.blah.class.should == TMS::EmailMessage
-      @instance_resource.shah.class.should == TMS::EmailMessage
+      expect(@instance_resource.blah.class).to eq(GovDelivery::TMS::EmailMessage)
+      expect(@instance_resource.shah.class).to eq(GovDelivery::TMS::EmailMessage)
     end
 
     it 'should not GET on initialization' do
-      client.should_not receive(:get)
+      expect(client).not_to receive(:get)
       Foo.new(client, 'https://example.com/foos/1')
     end
 
     it 'should return self on successful get' do
-      client.should receive(:get)
+      expect(client).to receive(:get)
       foo = Foo.new(client, 'https://example.com/foos/1')
-      foo.should_not be_new_record
-      foo.get.should == foo
+      expect(foo).not_to be_new_record
+      expect(foo.get).to eq(foo)
     end
 
     %w{get post put delete}.each do |verb|
       it "should blow up on invalid #{verb}!" do
-        client.should(receive(verb)).and_return(double('response', status: 404, body: "{}"))
+        expect(client).to(receive(verb)).and_return(double('response', status: 404, body: "{}"))
         foo = Foo.new(client, 'https://example.com/foos/1')
         expect do
           foo.send("#{verb}!")
-        end.to raise_error("TMS::Errors::Invalid#{verb.capitalize}".constantize)
+        end.to raise_error("GovDelivery::TMS::Errors::Invalid#{verb.capitalize}".constantize)
       end
     end
 
     it 'it exposes its attributes hash' do
-      @instance_resource.attributes.should == {}
+      expect(@instance_resource.attributes).to eq({})
     end
 
   end

data/spec/ipaws_acknowledgement_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
-describe TMS::IpawsAcknowledgement do
+describe GovDelivery::TMS::IpawsAcknowledgement do
 
   it 'gets IPAWS acknowledgement from client' do
     client = double(:client)
     response_body = { "ACK" => "PONG" }
-    ipaws_acknowledgement = TMS::IpawsAcknowledgement.new(client, '/ipaws/acknowledgement', {})
-    ipaws_acknowledgement.client.should_receive('get').with(ipaws_acknowledgement.href).and_return(
-      double('response', :status => 200, :body => response_body)
+    ipaws_acknowledgement = GovDelivery::TMS::IpawsAcknowledgement.new(client, '/ipaws/acknowledgement', {})
+    expect(ipaws_acknowledgement.client).to receive('get').with(ipaws_acknowledgement.href).and_return(
+      double('response', status: 200, body: response_body)
     )
-    ipaws_acknowledgement.get.should == ipaws_acknowledgement
-    ipaws_acknowledgement.ACK.should == "PONG"
+    expect(ipaws_acknowledgement.get).to eq(ipaws_acknowledgement)
+    expect(ipaws_acknowledgement.ACK).to eq("PONG")
   end
 
 end

data/spec/ipaws_alerts_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe TMS::IpawsAlert do
+describe GovDelivery::TMS::IpawsAlert do
 
   it 'post new IPAWS alerts to client, and capture status response from IPAWS' do
     client = double(:client)
@@ -97,21 +97,21 @@ describe TMS::IpawsAlert do
       ]
     }
 
-    alerts = TMS::IpawsAlerts.new(client, '/ipaws/alerts')
+    alerts = GovDelivery::TMS::IpawsAlerts.new(client, '/ipaws/alerts')
     alert = alerts.build(alert_attributes)
 
-    alert.identifier.should == "CAP12-TEST-123"
-    alert.sender.should == 'test@open.com'
-    alert.sent.should == "2014-04-18T15:02:26-05:00"
-    alert.status.should == 'Actual'
-    alert.msgType.should == 'Alert'
-    alert.source.should == 'IPAWS-TEST'
-    alert.scope.should == 'Public'
-    alert.addresses.should == '999'
-    alert.code.should == ['IPAWSv1.0']
-    alert.note.should == 'test'
-    alert.incidents.should == 'IPAWS-9999'
-    alert.info.should == [
+    expect(alert.identifier).to eq("CAP12-TEST-123")
+    expect(alert.sender).to eq('test@open.com')
+    expect(alert.sent).to eq("2014-04-18T15:02:26-05:00")
+    expect(alert.status).to eq('Actual')
+    expect(alert.msgType).to eq('Alert')
+    expect(alert.source).to eq('IPAWS-TEST')
+    expect(alert.scope).to eq('Public')
+    expect(alert.addresses).to eq('999')
+    expect(alert.code).to eq(['IPAWSv1.0'])
+    expect(alert.note).to eq('test')
+    expect(alert.incidents).to eq('IPAWS-9999')
+    expect(alert.info).to eq([
       {
         language: 'en-US',
         category: ['Safety'],
@@ -140,24 +140,24 @@ describe TMS::IpawsAlert do
           }
         ]
       }
-    ]
+    ])
 
-    alert.client.should_receive('post').with(alert).and_return(double('response', :status => 200, :body => response_body))
-    alert.post.should == true
-    alert.ipaws_response.should == response_body
+    expect(alert.client).to receive('post').with(alert).and_return(double('response', status: 200, body: response_body))
+    expect(alert.post).to eq(true)
+    expect(alert.ipaws_response).to eq(response_body)
 
-    alert.identifier.should == "CAP12-TEST-123"
-    alert.sender.should == 'test@open.com'
-    alert.sent.should == "2014-04-18T15:02:26-05:00"
-    alert.status.should == 'Actual'
-    alert.msgType.should == 'Alert'
-    alert.source.should == 'IPAWS-TEST'
-    alert.scope.should == 'Public'
-    alert.addresses.should == '999'
-    alert.code.should == ['IPAWSv1.0']
-    alert.note.should == 'test'
-    alert.incidents.should == 'IPAWS-9999'
-    alert.info.should == [
+    expect(alert.identifier).to eq("CAP12-TEST-123")
+    expect(alert.sender).to eq('test@open.com')
+    expect(alert.sent).to eq("2014-04-18T15:02:26-05:00")
+    expect(alert.status).to eq('Actual')
+    expect(alert.msgType).to eq('Alert')
+    expect(alert.source).to eq('IPAWS-TEST')
+    expect(alert.scope).to eq('Public')
+    expect(alert.addresses).to eq('999')
+    expect(alert.code).to eq(['IPAWSv1.0'])
+    expect(alert.note).to eq('test')
+    expect(alert.incidents).to eq('IPAWS-9999')
+    expect(alert.info).to eq([
       {
         language: 'en-US',
         category: ['Safety'],
@@ -186,7 +186,7 @@ describe TMS::IpawsAlert do
           }
         ]
       }
-    ]
+    ])
   end
 
 end

data/spec/ipaws_cog_profile_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe TMS::IpawsCogProfile do
+describe GovDelivery::TMS::IpawsCogProfile do
 
   it 'gets IPAWS cog profile from client' do
     client = double(:client)
@@ -35,30 +35,30 @@ describe TMS::IpawsCogProfile do
         {"SAME"=>"039035"}
       ]
     }
-    cog_profile = TMS::IpawsCogProfile.new(client, '/ipaws/cog_profile', {})
-    cog_profile.client.should_receive('get').with(cog_profile.href).and_return(
-      double('response', :status => 200, :body => response_body)
+    cog_profile = GovDelivery::TMS::IpawsCogProfile.new(client, '/ipaws/cog_profile', {})
+    expect(cog_profile.client).to receive('get').with(cog_profile.href).and_return(
+      double('response', status: 200, body: response_body)
     )
-    cog_profile.get.should == cog_profile
-    cog_profile.cogid.should == "120082"
+    expect(cog_profile.get).to eq(cog_profile)
+    expect(cog_profile.cogid).to eq("120082")
 
-    cog_profile.name.should == "GovDelivery"
-    cog_profile.description.should == "GovDelivery"
-    cog_profile.categoryName.should == "IPAWS-OPEN"
-    cog_profile.organizationName.should == "CIV"
-    cog_profile.cogEnabled.should == "Y"
-    cog_profile.caeAuthorized.should == "Y"
-    cog_profile.caeCmasAuthorized.should == "Y"
-    cog_profile.eanAuthorized.should == "N"
-    cog_profile.allEventCode.should == "N"
-    cog_profile.allGeoCode.should == "N"
-    cog_profile.easAuthorized.should == "Y"
-    cog_profile.cmasAlertAuthorized.should == "Y"
-    cog_profile.cmamTextAuthorized.should == "Y"
-    cog_profile.publicAlertAuthorized.should == "Y"
-    cog_profile.broadcastAuthorized.should == "N"
-    cog_profile.email.should == "joe.bloom@govdelivery.com"
-    cog_profile.eventCodes.should == [
+    expect(cog_profile.name).to eq("GovDelivery")
+    expect(cog_profile.description).to eq("GovDelivery")
+    expect(cog_profile.categoryName).to eq("IPAWS-OPEN")
+    expect(cog_profile.organizationName).to eq("CIV")
+    expect(cog_profile.cogEnabled).to eq("Y")
+    expect(cog_profile.caeAuthorized).to eq("Y")
+    expect(cog_profile.caeCmasAuthorized).to eq("Y")
+    expect(cog_profile.eanAuthorized).to eq("N")
+    expect(cog_profile.allEventCode).to eq("N")
+    expect(cog_profile.allGeoCode).to eq("N")
+    expect(cog_profile.easAuthorized).to eq("Y")
+    expect(cog_profile.cmasAlertAuthorized).to eq("Y")
+    expect(cog_profile.cmamTextAuthorized).to eq("Y")
+    expect(cog_profile.publicAlertAuthorized).to eq("Y")
+    expect(cog_profile.broadcastAuthorized).to eq("N")
+    expect(cog_profile.email).to eq("joe.bloom@govdelivery.com")
+    expect(cog_profile.eventCodes).to eq([
       {"ALL"=>"FRW"},
       {"ALL"=>"SVR"},
       {"ALL"=>"SPW"},
@@ -66,10 +66,10 @@ describe TMS::IpawsCogProfile do
       {"ALL"=>"CAE"},
       {"ALL"=>"WSW"},
       {"ALL"=>"CEM"}
-    ]
-    cog_profile.geoCodes.should == [
+    ])
+    expect(cog_profile.geoCodes).to eq([
       {"SAME"=>"039035"}
-    ]
+    ])
   end
 
 end

data/spec/ipaws_event_codes_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe TMS::IpawsEventCodes do
+describe GovDelivery::TMS::IpawsEventCodes do
   context "loading Ipaws event codes" do
     let(:client) { double('client') }
-    let(:event_codes) { TMS::IpawsEventCodes.new(client, '/ipaws/event_codes') }
+    let(:event_codes) { GovDelivery::TMS::IpawsEventCodes.new(client, '/ipaws/event_codes') }
     it 'should GET itself' do
       body = [
         {
@@ -24,11 +24,11 @@ describe TMS::IpawsEventCodes do
           eas_and_public: true,
           cmas: false        }
       ]
-      client.should_receive(:get).and_return(double('response', :body => body, :status => 200, :headers => {}))
+      expect(client).to receive(:get).and_return(double('response', body: body, status: 200, headers: {}))
       event_codes.get
-      event_codes.collection.length.should == 2
+      expect(event_codes.collection.length).to eq(2)
       event_codes.collection.each do |event_code|
-        event_code.should be_an_instance_of(TMS::IpawsEventCode)
+        expect(event_code).to be_an_instance_of(GovDelivery::TMS::IpawsEventCode)
       end
     end
   end