tms_client 0.4.1 → 0.5.1

data/lib/tms_client.rb

@@ -1,7 +1,7 @@
 module TMS #:nodoc:
 end
 
-require 'active_support'
+require 'active_support/core_ext/hash'
 require 'tms_client/version'
 require 'faraday'
 require 'faraday_middleware'
@@ -30,4 +30,12 @@ require 'tms_client/resource/command_type'
 require 'tms_client/resource/command_action'
 require 'tms_client/resource/command'
 require 'tms_client/resource/keyword'
-
+require 'tms_client/resource/ipaws_static_resource'
+require 'tms_client/resource/ipaws_category'
+require 'tms_client/resource/ipaws_event_code'
+require 'tms_client/resource/ipaws_response_type'
+require 'tms_client/resource/ipaws_acknowledgement'
+require 'tms_client/resource/ipaws_cog_profile'
+require 'tms_client/resource/ipaws_nwem_authorization'
+require 'tms_client/resource/ipaws_nwem_area'
+require 'tms_client/resource/ipaws_alert'

data/spec/client_spec.rb

@@ -27,7 +27,11 @@ describe TMS::Client do
       @raw_connection.stub(:get).and_return(double('response', :status => 202, :body => {'message' => 'hi'}))
       expect { @client.get('/blargh') }.to raise_error(TMS::Request::InProgress)
     end
-  end
-
 
+    context 'creating a new client without output' do
+      subject { TMS::Client.new('auth_token', api_root: 'null_url', logger: false) }
+      its(:logger){ should be_falsey }
+      its(:horse) { should be_kind_of(TMS::Horse) }
+    end
+  end
 end

data/spec/email_message_spec.rb

@@ -6,9 +6,9 @@ describe TMS::EmailMessage do
       double('client')
     end
     before do
-      @message = TMS::EmailMessage.new(client, nil, {
-        :body       => '12345678', 
-        :subject    => 'blah', 
+      @message = 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',
@@ -28,12 +28,14 @@ describe TMS::EmailMessage do
     end
     it 'should post successfully' do
       response = {
-          :body       => 'processed', 
-          :subject    => 'blah', 
-          :from_email => 'eric@evotest.govdelivery.com', 
+          :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'}], 
+          :recipients => [{:email => 'billy@evotest.govdelivery.com'}],
+          :failed => [{:email => 'billy@evotest.govdelivery.com'}],
+          :sent => [{:email => 'billy@evotest.govdelivery.com'}],
           :created_at => 'time'
       }
       @message.client.should_receive('post').with(@message).and_return(double('response', :status => 201, :body => response))
@@ -45,6 +47,10 @@ describe TMS::EmailMessage do
       @message.errors_to.should                         == 'errors@evotest.govdelivery.com'
       @message.recipients.class.should                  == TMS::EmailRecipients
       @message.recipients.collection.first.class.should == TMS::EmailRecipient
+      @message.sent.class.should == TMS::EmailRecipients
+      @message.sent.collection.first.class.should == TMS::EmailRecipient
+      @message.failed.class.should == TMS::EmailRecipients
+      @message.failed.collection.first.class.should == TMS::EmailRecipient
     end
     it 'should handle errors' do
       response = {'errors' => {:body => "can't be nil"}}
@@ -53,6 +59,16 @@ describe TMS::EmailMessage do
       @message.body.should == '12345678'
       @message.errors.should == {:body => "can't be nil"}
     end
+
+    it 'should handle 401 errors' do
+      @message.client.should_receive('post').with(@message).and_return(double('response', :status => 401))
+      expect {@message.post}.to raise_error(StandardError, "401 Not Authorized")
+    end
+
+    it 'should handle 404 errors' do
+      @message.client.should_receive('post').with(@message).and_return(double('response', :status => 404))
+      expect {@message.post}.to raise_error(StandardError, "Can't POST to /messages/email")
+    end
   end
 
   context 'an existing message' do
@@ -64,12 +80,12 @@ describe TMS::EmailMessage do
       @message = TMS::EmailMessage.new(client, '/messages/99', {})
     end
     it 'should GET cleanly' do
-      response = {:body => 'processed', 
+      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'}], 
+                  :recipients => [{:email => 'billy@evotest.govdelivery.com'}],
                   :created_at => 'time'}
       @message.client.should_receive('get').with(@message.href).and_return(double('response', :status => 200, :body => response))
       @message.get

data/spec/instance_resource_spec.rb

@@ -13,7 +13,7 @@ describe TMS::InstanceResource do
     end
 
     let(:client) do
-      double('client', :post => happy_response)
+      double('client', :post => happy_response, :get => happy_response)
     end
 
 
@@ -23,12 +23,29 @@ describe TMS::InstanceResource do
 
     it 'should POST' do
       @instance_resource.bar = "OMG"
-      @instance_resource.post.should be_true
+      @instance_resource.post.should 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
     end
+
+    it 'should not GET on initialization' do
+      client.should_not receive(:get)
+      Foo.new(client, 'https://example.com/foos/1')
+    end
+
+    it 'should return self on successful get' do
+      client.should receive(:get)
+      foo = Foo.new(client, 'https://example.com/foos/1')
+      foo.should_not be_new_record
+      foo.get.should == foo
+    end
+
+    it 'it exposes its attributes hash' do
+      @instance_resource.attributes.should == {}
+    end
+
   end
 end

data/spec/ipaws_acknowledgement_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 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.get.should == ipaws_acknowledgement
+    ipaws_acknowledgement.ACK.should == "PONG"
+  end
+
+end

data/spec/ipaws_alerts_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe TMS::IpawsAlert do
+
+  it 'post new IPAWS alerts to client, and capture status response from IPAWS' do
+    client = double(:client)
+
+    response_body = {
+      "identifier"=>"CAP12-TEST-1397743203",
+      "statuses"=> [
+        {
+          "CHANNELNAME"=>"CAPEXCH",
+          "STATUSITEMID"=>"200",
+          "ERROR"=>"N",
+          "STATUS"=>"Ack"
+        },
+        {
+          "CHANNELNAME"=>"CAPEXCH",
+          "STATUSITEMID"=>"202",
+          "ERROR"=>"N",
+          "STATUS"=>"alert-signature-is-valid"
+        },
+        {
+          "CHANNELNAME"=>"IPAWS",
+          "STATUSITEMID"=>"300",
+          "ERROR"=>"N",
+          "STATUS"=>"Ack"
+        },
+        {
+          "CHANNELNAME"=>"NWEM",
+          "STATUSITEMID"=>"401",
+          "ERROR"=>"N",
+          "STATUS"=>"message-not-disseminated-as-NWEM"
+        },
+        {
+          "CHANNELNAME"=>"EAS",
+          "STATUSITEMID"=>"501",
+          "ERROR"=>"N",
+          "STATUS"=>"message-not-disseminated-as-EAS"
+        },
+        {
+          "CHANNELNAME"=>"CMAS",
+          "STATUSITEMID"=>"600",
+          "ERROR"=>"N",
+          "STATUS"=>"Ack"
+        },
+        {
+          "CHANNELNAME"=>"PUBLIC",
+          "STATUSITEMID"=>"800",
+          "ERROR"=>"N",
+          "STATUS"=>"Ack"
+        }
+      ]
+    }
+
+    alert_attributes = {
+      identifier: "CAP12-TEST-123",
+      sender: 'test@open.com',
+      sent: "2014-04-18T15:02:26-05:00",
+      status: 'Actual',
+      msgType: 'Alert',
+      source: 'IPAWS-TEST',
+      scope: 'Public',
+      addresses: '999',
+      code: ['IPAWSv1.0'],
+      note: 'test',
+      incidents: 'IPAWS-9999',
+      info: [
+        {
+          language: 'en-US',
+          category: ['Safety'],
+          event: 'CIVIL EMERGENCY MESSAGE',
+          responseType: ['Shelter'],
+          urgency: 'Immediate',
+          severity: 'Extreme',
+          certainty: 'Observed',
+          audience: 'Public',
+          eventCode: [
+            { valueName: 'SAME', value: 'SVR'}
+          ],
+          effective: "2014-04-18T15:02:26-05:00",
+          expires: "2014-04-18T15:02:26-05:00",
+          senderName: 'IPAWS-Test',
+          headline: 'FLash Flood Warning',
+          description: 'Severe Weather Warning - Flooding',
+          instruction: 'Take Shelter',
+          parameter: [
+            { valueName: 'timezone', value: 'CST' }
+          ],
+          area: [
+            {
+              areaDesc: 'Fairfax County',
+              geocode: { valueName: 'SAME', value: '039035' }
+            }
+          ]
+        }
+      ]
+    }
+
+    alerts = 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 == [
+      {
+        language: 'en-US',
+        category: ['Safety'],
+        event: 'CIVIL EMERGENCY MESSAGE',
+        responseType: ['Shelter'],
+        urgency: 'Immediate',
+        severity: 'Extreme',
+        certainty: 'Observed',
+        audience: 'Public',
+        eventCode: [
+          { valueName: 'SAME', value: 'SVR'}
+        ],
+        effective: "2014-04-18T15:02:26-05:00",
+        expires: "2014-04-18T15:02:26-05:00",
+        senderName: 'IPAWS-Test',
+        headline: 'FLash Flood Warning',
+        description: 'Severe Weather Warning - Flooding',
+        instruction: 'Take Shelter',
+        parameter: [
+          { valueName: 'timezone', value: 'CST' }
+        ],
+        area: [
+          {
+            areaDesc: 'Fairfax County',
+            geocode: { valueName: 'SAME', value: '039035' }
+          }
+        ]
+      }
+    ]
+
+    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
+
+    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 == [
+      {
+        language: 'en-US',
+        category: ['Safety'],
+        event: 'CIVIL EMERGENCY MESSAGE',
+        responseType: ['Shelter'],
+        urgency: 'Immediate',
+        severity: 'Extreme',
+        certainty: 'Observed',
+        audience: 'Public',
+        eventCode: [
+          { valueName: 'SAME', value: 'SVR'}
+        ],
+        effective: "2014-04-18T15:02:26-05:00",
+        expires: "2014-04-18T15:02:26-05:00",
+        senderName: 'IPAWS-Test',
+        headline: 'FLash Flood Warning',
+        description: 'Severe Weather Warning - Flooding',
+        instruction: 'Take Shelter',
+        parameter: [
+          { valueName: 'timezone', value: 'CST' }
+        ],
+        area: [
+          {
+            areaDesc: 'Fairfax County',
+            geocode: { valueName: 'SAME', value: '039035' }
+          }
+        ]
+      }
+    ]
+  end
+
+end

data/spec/ipaws_cog_profile_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe TMS::IpawsCogProfile do
+
+  it 'gets IPAWS cog profile from client' do
+    client = double(:client)
+    response_body = {
+      "cogid"=>"120082",
+      "name"=>"GovDelivery",
+      "description"=>"GovDelivery",
+      "categoryName"=>"IPAWS-OPEN",
+      "organizationName"=>"CIV",
+      "cogEnabled"=>"Y",
+      "caeAuthorized"=>"Y",
+      "caeCmasAuthorized"=>"Y",
+      "eanAuthorized"=>"N",
+      "allEventCode"=>"N",
+      "allGeoCode"=>"N",
+      "easAuthorized"=>"Y",
+      "cmasAlertAuthorized"=>"Y",
+      "cmamTextAuthorized"=>"Y",
+      "publicAlertAuthorized"=>"Y",
+      "broadcastAuthorized"=>"N",
+      "email"=>"joe.bloom@govdelivery.com",
+      "eventCodes" => [
+        {"ALL"=>"FRW"},
+        {"ALL"=>"SVR"},
+        {"ALL"=>"SPW"},
+        {"ALL"=>"LAE"},
+        {"ALL"=>"CAE"},
+        {"ALL"=>"WSW"},
+        {"ALL"=>"CEM"}
+      ],
+      "geoCodes" => [
+        {"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.get.should == cog_profile
+    cog_profile.cogid.should == "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 == [
+      {"ALL"=>"FRW"},
+      {"ALL"=>"SVR"},
+      {"ALL"=>"SPW"},
+      {"ALL"=>"LAE"},
+      {"ALL"=>"CAE"},
+      {"ALL"=>"WSW"},
+      {"ALL"=>"CEM"}
+    ]
+    cog_profile.geoCodes.should == [
+      {"SAME"=>"039035"}
+    ]
+  end
+
+end

data/spec/ipaws_event_codes_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe TMS::IpawsEventCodes do
+  context "loading Ipaws event codes" do
+    let(:client) { double('client') }
+    let(:event_codes) { TMS::IpawsEventCodes.new(client, '/ipaws/event_codes') }
+    it 'should GET itself' do
+      body = [
+        {
+          value: 'ADR',
+          description: 'Administrative Message/Follow up Statement',
+          cap_exchange: true,
+          core_ipaws_profile: true,
+          nwem: true,
+          eas_and_public: true,
+          cmas: true
+        },
+        {
+          value: 'AVA',
+          description: 'Avalanche Watch',
+          cap_exchange: true,
+          core_ipaws_profile: true,
+          nwem: true,
+          eas_and_public: true,
+          cmas: false        }
+      ]
+      client.should_receive(:get).and_return(double('response', :body => body, :status => 200, :headers => {}))
+      event_codes.get
+      event_codes.collection.length.should == 2
+      event_codes.collection.each do |event_code|
+        event_code.should be_an_instance_of(TMS::IpawsEventCode)
+      end
+    end
+  end
+end

data/spec/ipaws_nwem_areas_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe TMS::IpawsNwemAreas do
+
+  it 'gets IPAWS NWEM areas from client' do
+    client = double(:client)
+    response_body = [
+      {
+        "countyFipsCd"=>"51013",
+        "countyName"=>"Arlington",
+        "geoType"=>"C",
+        "stateCd"=>"VA",
+        "stateFips"=>"51",
+        "stateName"=>"Virginia",
+        "zoneCd"=>"054",
+        "zoneName"=>"Arlington/Falls Church/Alexandria"
+      },
+      {
+        "countyFipsCd"=>"51510",
+        "countyName"=>"City of Alexandria",
+        "geoType"=>"C",
+        "stateCd"=>"VA",
+        "stateFips"=>"51",
+        "stateName"=>"Virginia",
+        "zoneCd"=>"054",
+        "zoneName"=>"Arlington/Falls Church/Alexandria"
+      }
+    ]
+    nwem_areas = TMS::IpawsNwemAreas.new(client, '/ipaws/nwem_areas')
+
+    nwem_areas.client.should_receive('get').with(nwem_areas.href).and_return(
+      double('response', :status => 200, :body => response_body, :headers => {})
+    )
+    nwem_areas.get.should == nwem_areas
+    nwem_areas.collection.size.should == 2
+
+    nwem_area = nwem_areas.collection[0]
+    nwem_area.countyFipsCd.should == '51013'
+    nwem_area.countyName.should == 'Arlington'
+    nwem_area.geoType.should == 'C'
+    nwem_area.stateCd.should == 'VA'
+    nwem_area.stateFips.should == '51'
+    nwem_area.stateName.should == 'Virginia'
+    nwem_area.zoneCd.should == '054'
+    nwem_area.zoneName.should == 'Arlington/Falls Church/Alexandria'
+
+    nwem_area = nwem_areas.collection[1]
+    nwem_area.countyFipsCd.should == '51510'
+    nwem_area.countyName.should == 'City of Alexandria'
+    nwem_area.geoType.should == 'C'
+    nwem_area.stateCd.should == 'VA'
+    nwem_area.stateFips.should == '51'
+    nwem_area.stateName.should == 'Virginia'
+    nwem_area.zoneCd.should == '054'
+    nwem_area.zoneName.should == 'Arlington/Falls Church/Alexandria'
+  end
+
+end

data/spec/ipaws_nwem_authorization_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe TMS::IpawsNwemAuthorization do
+
+  it 'gets IPAWS NWEM Authorization from client' do
+    client = double(:client)
+    response_body = { "cogid" => "true" }
+    nwem_authorization = TMS::IpawsNwemAuthorization.new(client, '/ipaws/nwem_authorization', {})
+    nwem_authorization.client.should_receive('get').with(nwem_authorization.href).and_return(
+      double('response', :status => 200, :body => response_body)
+    )
+    nwem_authorization.get.should == nwem_authorization
+    nwem_authorization.cogid.should == "true"
+  end
+
+end

data/spec/mail/delivery_method_spec.rb

@@ -3,7 +3,7 @@ require 'mail'
 require 'tms_client/mail/delivery_method'
 describe TMS::Mail::DeliveryMethod do
   subject { TMS::Mail::DeliveryMethod.new({}) }
-  let(:client) { stub('TMS::Client') }
+  let(:client) { double('TMS::Client') }
   let(:email_messages) { double('email_messages') }
   let(:tms_message) { double('tms_message', :recipients => double(:build => TMS::Recipient.new('href'))) }
 

data/spec/sms_message_spec.rb

@@ -17,13 +17,21 @@ describe TMS::SmsMessage do
       @message.recipients.class.should == TMS::Recipients
     end
     it 'should post successfully' do
-      response = {:body => 'processed', :recipients => [{:phone => '22345678'}], :created_at => 'time'}
+      response = { :body => 'processed',
+                   :recipients => [{:phone => '22345678'}],
+                   :failed => [{:phone => '22345678'}],
+                   :sent => [{:phone => '22345678'}],
+                    :created_at => 'time'}
       @message.client.should_receive('post').with(@message).and_return(double('response', :status => 201, :body => response))
       @message.post
       @message.body.should == 'processed'
       @message.created_at.should == 'time'
       @message.recipients.class.should == TMS::Recipients
       @message.recipients.collection.first.class.should == TMS::Recipient
+      @message.sent.class.should == TMS::Recipients
+      @message.sent.collection.first.class.should == TMS::Recipient
+      @message.failed.class.should == TMS::Recipients
+      @message.failed.collection.first.class.should == TMS::Recipient
     end
     it 'should handle errors' do
       response = {'errors' => {:body => "can't be nil"}}

data/spec/spec_helper.rb

@@ -17,6 +17,7 @@ end
 # loaded once.
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'rspec/its'
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true

data/spec/voice_message_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe TMS::VoiceMessage do
+  context "creating a new message" do
+    let(:client) do
+      double('client')
+    end
+    before do
+      @message = TMS::VoiceMessage.new(client, nil, {:play_url => 'http://what.cd'})
+    end
+    it 'should not render readonly attrs in json hash' do
+      @message.to_json[:play_url].should == 'http://what.cd'
+      @message.to_json[:created_at].should == nil
+    end
+    it 'should initialize with attrs and collections' do
+      @message.play_url.should == 'http://what.cd'
+      @message.recipients.class.should == TMS::Recipients
+    end
+    it 'should post successfully' do
+      response = { :body => 'processed',
+                   :recipients => [{:phone => '22345678'}],
+                   :failed => [{:phone => '22345678'}],
+                   :sent => [{:phone => '22345678'}],
+                   :created_at => 'time'}
+      @message.client.should_receive('post').with(@message).and_return(double('response', :status => 201, :body => response))
+      @message.post
+      # @message.body.should == 'processed'
+      @message.created_at.should == 'time'
+      @message.recipients.class.should == TMS::Recipients
+      @message.recipients.collection.first.class.should == TMS::Recipient
+      @message.sent.class.should == TMS::Recipients
+      @message.sent.collection.first.class.should == TMS::Recipient
+      @message.failed.class.should == TMS::Recipients
+      @message.failed.collection.first.class.should == TMS::Recipient
+    end
+    it 'should handle errors' do
+      response = {'errors' => {:play_url => "can't be nil"}}
+      @message.client.should_receive('post').with(@message).and_return(double('response', :status => 422, :body => response))
+      @message.post
+      # @message.body.should == '12345678'
+      @message.errors.should == {:play_url => "can't be nil"}
+    end
+  end
+
+  context 'an existing message' do
+    let(:client) do
+      double('client')
+    end
+    before do
+      # blank hash prevents the client from doing a GET in the initialize method
+      @message = TMS::VoiceMessage.new(client, '/messages/99', {})
+    end
+    it 'should GET cleanly' do
+      response = {:play_url => 'processed', :recipients => [{:phone => '22345678'}], :created_at => 'time'}
+      @message.client.should_receive('get').with(@message.href).and_return(double('response', :status => 200, :body => response))
+      @message.get
+      @message.play_url.should == 'processed'
+      @message.created_at.should == 'time'
+    end
+  end
+
+
+end