mblox 0.4.2 → 0.5.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Nzk1MWJlNGZlNzNhZWU2YTQ3OTMxNDUzYmRiMTk1MDYyNGE5YmI2YQ==
+    YzUzOTg0OWI2N2UyZjBlNDM3ZjA4ZTUzNTZlNDE5NTg4YTIxMTQwMQ==
   data.tar.gz: !binary |-
-    NmVmM2U3MTdhYWE3NDdkZGMwNjgzOGE3NTkxNjE3YTM3MTE0YWZiMg==
+    NmIwYzg1ZTYzNzRlMjIzYzc2ODE4NTk3OTM0Zjc1Njk5YTY5NGVlYw==
 SHA512:
   metadata.gz: !binary |-
-    NDhlYjI3ODQwNTI0MGM3MmE4YzdkZjczMmQ3ZTY5YzY0YTA0NzZhMjkwMDA4
-    MmJmNGNiYzk2NTk1Nzc5NjdlYmM4NTQyMDExZTk4ZTE1YTMwMjg5ZWU2ODE4
-    OGE1YzFjZjliZjdjMDhmMjBmYjQyNDhiM2MwZDljZGViMmU2NDA=
+    MGFhNzJlYjJjMGNiN2Y4ZGZhNzk3YzZmZTc4OTkxY2UyZjE1OWVmMGQzMGNh
+    YmY5Yzk1MjIyMDUyYzI3Yzk3YjZkODVjNmE5NjQ2NTU4NjY3YjQzNDZiNDYw
+    ZWRjZmViNDI5NjhhNTRiMTJiNDRlZmNiMTZiY2VmMDY4ZDA0Mjk=
   data.tar.gz: !binary |-
-    YzdiNDQ0MzI1MDA3MTYyN2NlZmNjYzdiNDQ0MDY2MGM4ODU4YTQ5MzFkYTIy
-    OTg3MDIzNmQzZTczNjJkNzg2ZDUzYzRiZjUxY2M5YWRmZDZiYmUzMmRkYmZj
-    MTYzNTA2NTBiMWJkZjAyMTQ0ZmI2ZDkzNTE4NTk1YmZkNTdlNDg=
+    MDRkZTEwYzE0NDk1MGQxZTg5YWNmZWZmMjVjZjQxNGU4Y2JhNjFhYTk1NGE1
+    NjhiNTZlNzU0NDZhYzA3MzYzYzRiNjVhYjhjMGFiYmIyNWEyZDkyM2IyMjc4
+    MWVkMmQ4NmNjMzAyNzI1MTRkZDhmM2YzNzM5NzEyZjIzODBjYWE=

data/lib/mblox/sms.rb

@@ -11,6 +11,7 @@ module Mblox
     class InvalidMessageError < ::ArgumentError; end
     class BatchIdOutOfRangeError < ::ArgumentError; end
     class InvalidSenderIdError < ::ArgumentError; end
+    class MessageTooLongError < ::ArgumentError; end
     MAX_LENGTH = 160
     MAX_SECTION_LENGTH = MAX_LENGTH - "(MSG XXX/XXX): ".size
     LEGAL_CHARACTERS = "~\`!\"#\$\%&'\(\)*+,-.\/:;<=>?@_£¤¥§¿i¡ÄÅÆÇÉÑÖØÜßâáäåæèéìñòöøóùüú\n\r\tí "
@@ -19,7 +20,7 @@ module Mblox
     attr_reader :phone, :message
 
     ON_MESSAGE_TOO_LONG_HANDLER = {
-      :raise_error => Proc.new { raise InvalidMessageError, "Message cannot be longer than #{MAX_LENGTH} characters" },
+      :raise_error => Proc.new { raise MessageTooLongError, "Message cannot be longer than #{MAX_LENGTH} characters" },
       :truncate => Proc.new { |message| Mblox.log "Truncating message due to length.  Message was: \"#{message}\" but will now be \"#{message = message[0,MAX_LENGTH]}\""; [message] },
       :split => Proc.new { |message| split_message(message) }
     }

data/lib/mblox/version.rb

@@ -1,3 +1,3 @@
 module Mblox
-  VERSION = "0.4.2"
+  VERSION = "0.5.0"
 end

data/mblox.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec", "~> 3.0"
 
   spec.add_runtime_dependency 'activemodel'
   spec.add_runtime_dependency 'activesupport'

data/spec/configuration_spec.rb

@@ -19,7 +19,7 @@ describe Mblox::Configuration do
     end
 
     it "should default to log level debug" do
-      Mblox.config.log_level.should eq(:debug)
+      expect(Mblox.config.log_level).to eq(:debug)
       expect { Mblox.log "Some debug info" }.to_not raise_error
     end
 
@@ -32,7 +32,7 @@ describe Mblox::Configuration do
     it "should not allow log level news when the logger is created before log level is set and should remain in a valid state" do
       Mblox.config.logger = ::Logger.new("/dev/null")
       expect { Mblox.config.log_at :news }.to raise_error(ArgumentError, "Mblox log level must be set to :fatal, :error, :warn, :info or :debug")
-      Mblox.config.log_level.should eq(:debug)
+      expect(Mblox.config.log_level).to eq(:debug)
       expect { Mblox.log "Some news" }.to_not raise_error
     end
   end
@@ -40,20 +40,20 @@ describe Mblox::Configuration do
   describe "on_message_too_long" do
     it "should default to :raise_error" do
       Mblox.reset_configuration
-      Mblox.config.on_message_too_long.should eq(:raise_error)
+      expect(Mblox.config.on_message_too_long).to eq(:raise_error)
     end
 
     [:raise_error, :split, :truncate].each do |val|
       it "should allow the value ':#{val}'" do
         expect { Mblox.config.on_message_too_long = val }.to_not raise_error
-        Mblox.config.on_message_too_long.should eq(val)
+        expect(Mblox.config.on_message_too_long).to eq(val)
       end
     end
 
     it "should not allow other values and should remain in a valid state" do
       original = Mblox.config.on_message_too_long
       expect { Mblox.config.on_message_too_long = :do_nothing }.to raise_error(ArgumentError, "Mblox.config.on_message_too_long must be either :truncate, :split or :raise_error")
-      Mblox.config.on_message_too_long.should eq(original)
+      expect(Mblox.config.on_message_too_long).to eq(original)
     end
   end
 end

data/spec/sms_receipt_spec.rb

@@ -105,13 +105,13 @@ describe Mblox::SmsReceipt do
 
   it "should access attributes for valid data" do
     target = described_class.from_xml(valid)
-    target.batch_id.should == batch_id
-    target.subscriber_number.should == subscriber_number
-    target.timestamp.should == DateTime.new(2013,10,7,17,36)
-    target.msg_reference.should == msg_reference
-    target.status.should == status
-    target.reason.should == reason
-    target.operator.should == 10487
+    expect(target.batch_id).to eq(batch_id)
+    expect(target.subscriber_number).to eq(subscriber_number)
+    expect(target.timestamp).to eq(DateTime.new(2013,10,7,17,36))
+    expect(target.msg_reference).to eq(msg_reference)
+    expect(target.status).to eq(status)
+    expect(target.reason).to eq(reason)
+    expect(target.operator).to eq(10487)
   end
 
   it "should raise error when missing root node" do
@@ -137,21 +137,21 @@ describe Mblox::SmsReceipt do
   describe "subscriber_number" do
     it "should not drop leading character unless it is '1'" do
       target = described_class.from_xml(unexpected_nested_values)
-      target.subscriber_number.should == "2#{subscriber_number}"
+      expect(target.subscriber_number).to eq("2#{subscriber_number}")
     end
   end
 
   describe "reason" do
     it "should leave reason blank if it is nil" do
       target = described_class.from_xml(unexpected_nested_values)
-      target.reason.should be_nil
+      expect(target.reason).to be_nil
     end
   end
 
   describe "timestamp" do
     it "should fail gracefully if it can't be converted into a DateTime" do
       target = described_class.from_xml(unexpected_nested_values)
-      target.timestamp.should be_nil
+      expect(target.timestamp).to be_nil
     end
   end
   end

data/spec/sms_response_result_spec.rb

@@ -5,19 +5,19 @@ describe Mblox::SmsResponse::Result do
     it "cannot be blank" do
       result = described_class.new(nil, "123")
       result.valid?
-      result.errors[:code].should include("Code cannot be blank")
+      expect(result.errors[:code]).to include("Code cannot be blank")
     end
 
     it "must be a number" do
       result = described_class.new('abc', "123")
       result.valid?
-      result.errors[:code].should include("Code must be an integer")
+      expect(result.errors[:code]).to include("Code must be an integer")
     end
 
     it "must be an integer" do
       result = described_class.new(3.14159, "123")
       result.valid?
-      result.errors[:code].should include("Code must be an integer")
+      expect(result.errors[:code]).to include("Code must be an integer")
     end
   end
 
@@ -25,18 +25,18 @@ describe Mblox::SmsResponse::Result do
     it "cannot be blank" do
       result = described_class.new(0, '')
       result.valid?
-      result.errors[:text].should include("Text cannot be blank")
+      expect(result.errors[:text]).to include("Text cannot be blank")
     end
   end
 
   describe "ok?" do
     it "is true for code 0" do
-      described_class.new(0, "123").ok?.should be_true
+      expect(described_class.new(0, "123")).to be_ok
     end
 
     10.times do |i|
       it "is false for code #{i+1}" do
-        described_class.new(i+1, "123").ok?.should be_false
+        expect(described_class.new(i+1, "123")).not_to be_ok
       end
     end
   end
@@ -45,18 +45,18 @@ describe Mblox::SmsResponse::Result do
     it "should be true if code and text are the same" do
       lhs = described_class.new(0, 'OK')
       rhs = described_class.new(0, 'OK')
-      (lhs == rhs).should be_true
+      expect(lhs).to eq(rhs)
     end
 
     it "should be false if code does not match" do
       lhs = described_class.new(0, 'OK')
       rhs = described_class.new(4, 'OK')
-      (lhs == rhs).should be_false
+      expect(lhs).not_to eq(rhs)
     end
     it "should be false if text does not match" do
       lhs = described_class.new(0, 'OK')
       rhs = described_class.new(0, '__OK__')
-      (lhs == rhs).should be_false
+      expect(lhs).not_to eq(rhs)
     end
   end
 end

data/spec/sms_response_spec.rb

@@ -5,21 +5,21 @@ describe Mblox::SmsResponse do
     let(:args) { { :request => Mblox::SmsResponse::Result.new(9, "SomeRequest"), :result => Mblox::SmsResponse::Result.new(10, "SomeResult") , :subscriber_result => Mblox::SmsResponse::Result.new(11, "SomeSubscriberResult")  } }
 
     [:request, :result, :subscriber_result].each do |attr|
-      describe attr do
+      describe "##{attr}" do
         it "must be a Result" do
           expect{described_class.new(args.merge(:"#{attr}" => 123))}.to raise_error(Mblox::ValidationError, "#{attr} must be of type Mblox::SmsResponse::Result")
         end
       end
     end
     [:request, :result].each do |attr|
-      describe attr do
+      describe "##{attr}" do
         it "cannot be blank" do
           expect{described_class.new(args.merge(:"#{attr}" => nil))}.to raise_error(Mblox::ValidationError, "#{attr} cannot be blank")
         end
       end
     end
 
-    describe :subscriber_result do
+    describe '#subscriber_result' do
       it "cannot be blank if result is ok" do
         expect{described_class.new(args.merge(:subscriber_result => nil))}.to_not raise_error
       end
@@ -45,17 +45,17 @@ describe Mblox::SmsResponse do
     let(:args) { { :request => Mblox::SmsResponse::Result.new(0, "OKRequest"), :result => Mblox::SmsResponse::Result.new(0, "OKResult") , :subscriber_result => Mblox::SmsResponse::Result.new(0, "OKSubscriberResult")  } }
 
     it "should be ok if all attributes are ok" do
-      described_class.new(args).should be_ok
+      expect(described_class.new(args)).to be_ok
     end
 
     [:request, :result, :subscriber_result].each do |attr|
       it "should not be ok if #{attr} is not ok" do
-        described_class.new(args.merge(:"#{attr}" => Mblox::SmsResponse::Result.new(1,"NotOK"))).should_not be_ok
+        expect(described_class.new(args.merge(:"#{attr}" => Mblox::SmsResponse::Result.new(1,"NotOK")))).not_to be_ok
       end
     end
 
     it "should be unroutable if subscriber_result is unroutable and other attirbutes are ok" do
-      described_class.new(args.merge(:subscriber_result => Mblox::SmsResponse::Result::UNROUTABLE)).should be_unroutable
+      expect(described_class.new(args.merge(:subscriber_result => Mblox::SmsResponse::Result::UNROUTABLE))).to be_unroutable
     end
   end
 end

data/spec/sms_spec.rb

@@ -33,7 +33,7 @@ describe Mblox::Sms do
       number = TEST_NUMBER.to_s
       mblox = Mblox::Sms.new(number,the_message)
       number[1..3] = ''
-      mblox.phone.should eq("1#{TEST_NUMBER}")
+      expect(mblox.phone).to eq("1#{TEST_NUMBER}")
     end
   end
 
@@ -50,39 +50,39 @@ describe Mblox::Sms do
       message = "A"+"ABCDEFGHIJ"*16
       Mblox.config.on_message_too_long = :truncate
       expect { @mblox = Mblox::Sms.new(LANDLINE, message) }.to_not raise_error
-      @mblox.message.should eq([message[0,160]])
+      expect(@mblox.message).to eq([message[0,160]])
     end
 
     it "cannot be longer than 160 characters if configured to raise error" do
       Mblox.config.on_message_too_long = :raise_error
-      expect { Mblox::Sms.new(LANDLINE, "A"*161) }.to raise_error(Mblox::Sms::InvalidMessageError, "Message cannot be longer than 160 characters")
+      expect { Mblox::Sms.new(LANDLINE, "A"*161) }.to raise_error(Mblox::Sms::MessageTooLongError, "Message cannot be longer than 160 characters")
     end
 
     it "should be split into multiple messages when longer than 160 characters if configured to split and even split" do
       message = "ABCDEFGHIJ"*58
       Mblox.config.on_message_too_long = :split
       expect { @mblox = Mblox::Sms.new(LANDLINE, message) }.to_not raise_error
-      @mblox.message.should eq(["(MSG 1/4): #{message[0,145]}", "(MSG 2/4): #{message[145,145]}", "(MSG 3/4): #{message[290,145]}", "(MSG 4/4): #{message[435,145]}"])
+      expect(@mblox.message).to eq(["(MSG 1/4): #{message[0,145]}", "(MSG 2/4): #{message[145,145]}", "(MSG 3/4): #{message[290,145]}", "(MSG 4/4): #{message[435,145]}"])
       response = @mblox.send
-      response.count.should eq(4)
-      response.each { |r| r.unroutable?.should be_true }
+      expect(response.count).to eq(4)
+      response.each { |r| expect(r).to be_unroutable }
     end
 
     it "should be split into multiple messages when longer than 160 characters if configured to split and not even split" do
       message = "ABCDEFGHIJ"*32
       Mblox.config.on_message_too_long = :split
       expect { @mblox = Mblox::Sms.new(LANDLINE, message) }.to_not raise_error
-      @mblox.message.should eq(["(MSG 1/3): #{message[0,145]}", "(MSG 2/3): #{message[145,145]}", "(MSG 3/3): #{message[290..-1]}"])
+      expect(@mblox.message).to eq(["(MSG 1/3): #{message[0,145]}", "(MSG 2/3): #{message[145,145]}", "(MSG 3/3): #{message[290..-1]}"])
       response = @mblox.send
-      response.count.should eq(3)
-      response.each { |r| r.unroutable?.should be_true }
+      expect(response.count).to eq(3)
+      response.each { |r| expect(r).to be_unroutable }
     end
 
     it "should be safe from changing when short" do
       msg = the_message
       mblox = Mblox::Sms.new(TEST_NUMBER,msg)
       msg[1..3] = ''
-      mblox.message.should eq([the_message])
+      expect(mblox.message).to eq([the_message])
     end
 
     it "should be safe from changing when long when configured to split" do
@@ -90,7 +90,7 @@ describe Mblox::Sms do
       msg = the_message * 10
       mblox = Mblox::Sms.new(TEST_NUMBER,msg)
       msg[1..3] = ''
-      mblox.message[0][11, 20].should eq(the_message[0,20])
+      expect(mblox.message[0][11, 20]).to eq(the_message[0,20])
     end
 
     it "should be safe from changing when long when configured to truncate" do
@@ -98,82 +98,85 @@ describe Mblox::Sms do
       msg = the_message * 10
       mblox = Mblox::Sms.new(TEST_NUMBER,msg)
       msg[1..3] = ''
-      mblox.message[0][0, 20].should eq(the_message[0,20])
+      expect(mblox.message[0][0, 20]).to eq(the_message[0,20])
     end
   end
 
   describe "SMS messages" do
     def expect_ok_response(response)
-      response.ok?.should be_true
-      response.unroutable?.should be_false
+      expect(response).to be_ok
+      expect(response).not_to be_unroutable
     end
 
     it "should be sent when the phone number is a Fixnum" do
       response = Mblox::Sms.new(TEST_NUMBER.to_i,the_message).send
-      response.size.should eq(1)
+      expect(response.size).to eq(1)
       expect_ok_response(response.first)
     end
 
     it "should be sent when the phone number is a String" do
       response = Mblox::Sms.new(TEST_NUMBER.to_s,the_message).send
-      response.size.should eq(1)
+      expect(response.size).to eq(1)
       expect_ok_response(response.first)
     end
 
     it "should allow 160-character messages" do
       response = Mblox::Sms.new(TEST_NUMBER,"A"*160).send
-      response.size.should eq(1)
+      expect(response.size).to eq(1)
       expect_ok_response(response.first)
     end
 
     it "should be unroutable when sent to a landline" do
       response = Mblox::Sms.new(LANDLINE,the_message).send
-      response.size.should eq(1)
-      response.first.unroutable?.should be_true, "#{response.first.inspect} should have been unroutable"
-      response.first.ok?.should be_false
+      expect(response.size).to eq(1)
+      expect(response.first).to be_unroutable, "#{response.first.inspect} should have been unroutable"
+      expect(response.first).not_to be_ok
     end
 
     Mblox::Sms::LEGAL_CHARACTERS.each_char do |i|
       it "allows the special char #{i}, correctly escaping illegal XML characters where necessary" do
         response = Mblox::Sms.new(LANDLINE,"#{the_message}#{i}#{the_message}").send
-        response.size.should eq(1)
-        response.first.ok?.should be_false
-        response.first.unroutable?.should be_true
+        expect(response.size).to eq(1)
+        expect(response.first).not_to be_ok
+        expect(response.first).to be_unroutable
       end
     end
 
     it "can send all the legal characters" do
       response = Mblox::Sms.new(TEST_NUMBER,Mblox::Sms::LEGAL_CHARACTERS).send
-      response.size.should eq(1)
-      response.first.ok?.should be_true
+      expect(response.size).to eq(1)
+      expect(response.first).to be_ok
     end
 
     it "can send a backslash" do
       response = Mblox::Sms.new(TEST_NUMBER,'\\').send
-      response.size.should eq(1)
-      response.first.ok?.should be_true
+      expect(response.size).to eq(1)
+      expect(response.first).to be_ok
     end
   end
 
   describe "batch_id" do
+    def batch_id(content)
+      content['NotificationRequest']['NotificationList']['BatchID']
+    end
     it "can be specified" do
       batch_id = 12345
       sms = Mblox::Sms.new(LANDLINE,the_message, batch_id)
       content = Hash.from_xml(sms.build_for_test(the_message))
-      content['NotificationRequest']['NotificationList']['BatchID'].should eq("#{batch_id}")
+      expect(batch_id(content)).to eq("#{batch_id}")
     end
 
     it "get converted to a Fixnum" do
       batch_id = 12345
       sms = Mblox::Sms.new(LANDLINE,the_message, "#{batch_id}ab")
       content = Hash.from_xml(sms.build_for_test(the_message))
-      content['NotificationRequest']['NotificationList']['BatchID'].should eq("#{batch_id}")
+      expect(batch_id(content)).to eq("#{batch_id}")
     end
 
     it "defaults to 1" do
       sms = Mblox::Sms.new(LANDLINE,the_message)
       content = Hash.from_xml(sms.build_for_test(the_message))
-      content['NotificationRequest']['NotificationList']['BatchID'].should eq('1')
+      expect(batch_id(content)).to eq('1')
     end
 
     it "can be 99999999" do
@@ -233,21 +236,21 @@ describe Mblox::Sms do
     end
 
     it "should send from the specified sender_id" do
-      @sms.instance_variable_get("@sender_id").should be_nil
+      expect(@sms.instance_variable_get("@sender_id")).to be_nil
       expect{@sms.send_from(55555)}.to_not raise_error
-      @sms.send.first.ok?.should be_true
-      @sms.instance_variable_get("@sender_id").should == "55555"
+      expect(@sms.send.first).to be_ok
+      expect(@sms.instance_variable_get("@sender_id")).to eq("55555")
     end
 
     it "should send from the specified sender_id and service_id" do
-      @sms.instance_variable_get("@service_id").should be_nil
+      expect(@sms.instance_variable_get("@service_id")).to be_nil
       expect{@sms.send_from(55555, 44444)}.to_not raise_error
       response = @sms.send.first
-      response.should_not be_ok
-      response.request.should be_ok
-      response.result.should be_ok
-      response.subscriber_result.should == Mblox::SmsResponse::Result.new(10, "MsipRejectCode=63 Invalid ServiceId:2e Do not retry:2e")
-      @sms.instance_variable_get("@service_id").should == "44444"
+      expect(response).not_to be_ok
+      expect(response.request).to be_ok
+      expect(response.result).to be_ok
+      expect(response.subscriber_result).to eq(Mblox::SmsResponse::Result.new(10, "MsipRejectCode=63 Invalid ServiceId:2e Do not retry:2e"))
+      expect(@sms.instance_variable_get("@service_id")).to eq("44444")
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mblox
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Isaac Betesh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-05 00:00:00.000000000 Z
+date: 2014-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -42,16 +42,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement