mblox 0.5.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7bab50777fd1eae487f0bf7571c076782f5a74b6
-  data.tar.gz: 9d6a053de216da6d310f4d7fe9461cbbac6fe7e5
+  metadata.gz: 7d2c1da153da2a5588a22d61cbcc07487c289863
+  data.tar.gz: b2ae4e5d1be782d8d72273dcf33c6379038b751b
 SHA512:
-  metadata.gz: fc15629b3cb4500e8af632e2b882aeb90e094c21131567dc45073d7c89dc65e73b61beb36968f3c933b7dca63823b31b43fc92d5438f57a05f54fde10cd850fe
-  data.tar.gz: ea5fd83e99d6aa3d3d62782ce62db85ea37576c68a442859e02d0382d0364cb1830d5482f8e5eac569b98788067eb53d1f85837b38ce1174ca1ad57be6e8c85c
+  metadata.gz: 8ed41e839424e5100dbb082a872dd965dd49bbfed67ad48984060616542ada987692eb6395f89ac686e24f1c7890b6caa5490b004ca30c532ee76928f1232d62
+  data.tar.gz: be52c74f37f65a1a2947481aca7bb287bf8aab149659bbd436dc6372b78d9773172895e962624055b03160f71f2578eaaff2b1572cd5551540b9511c026ba289

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+### 0.6.0 (3/11/2015)
+
+* BREAKING CHANGES:
+  * Mblox::Sms#message will now raise an exception if the message was split.  Use Mblox::Sms#messages in that case.  If the message was not split, Mblox::Sms#message returns the message as a String directly instead of warpping it in an array.
+  * `on_message_too_long`, `logger`, and `log_at` are configured in SmsValidation, a dependency of this gem.  See https://github.com/betesh/sms_validation/blob/master/README.md for details

data/README.md

@@ -29,8 +29,10 @@ Configuration
       config.partner_name = ...
       config.tariff = ...
       config.service_id = ...
+    end
 
-      # You can also configure some logging options
+    # You can also configure some logging options via SmsValidation, a dependency of this gem.  See https://github.com/betesh/sms_validation/blob/master/README.md for details
+    SmsValidation.configure do |config|
       # In a Rails environment, config.logger will default to Rails.logger and config.log_at will default to :debug
       # config.log_at means the level at which Mblox will log.
       # For instance, if config.log_at == :debug, Mblox will log only if the logger's log level is :debug

data/lib/mblox/configuration.rb

@@ -3,37 +3,14 @@ module Mblox
     def config
       @config ||= Configuration.new
     end
-  end
 
-  def self.configure
-    yield self.config
+    def configure
+      yield config
+    end
   end
 
   class Configuration
     attr_accessor :outbound_url, :profile_id, :sender_id, :password, :partner_name, :tariff, :service_id
     attr_reader :logger, :log_level, :on_message_too_long
-    def initialize
-      @logger = Rails.logger if defined?(::Rails)
-      @log_level = :debug
-      @on_message_too_long = :raise_error
-    end
-
-    def on_message_too_long= action
-      raise ArgumentError, "Mblox.config.on_message_too_long must be either :truncate, :split or :raise_error" unless [:truncate, :raise_error, :split].include?(action)
-      @on_message_too_long = action
-    end
-
-    def log_at level
-      validate @logger, level
-      @log_level = level
-    end
-    def logger= logger
-      validate logger, @log_level
-      @logger = logger
-    end
-    private
-      def validate logger, level
-	raise ArgumentError, "Mblox log level must be set to :fatal, :error, :warn, :info or :debug" if (logger && !logger.respond_to?(level))
-      end
   end
 end

data/lib/mblox/sms.rb

@@ -4,37 +4,19 @@ require 'addressable/uri'
 require 'builder'
 require "net/https"
 require 'mblox/sms_response'
+require 'sms_validation'
 
 module Mblox
-  class Sms
-    class InvalidPhoneNumberError < ::ArgumentError; end
-    class InvalidMessageError < ::ArgumentError; end
+  class Sms < SmsValidation::Sms
     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 ©"
     ILLEGAL_CHARACTERS = /([^a-zA-Z0-9#{LEGAL_CHARACTERS}\\])/
 
-    attr_reader :phone, :message
-
-    ON_MESSAGE_TOO_LONG_HANDLER = {
-      :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) }
-    }
-
     def initialize(phone, message, batch_id=nil)
-      phone = phone.to_s
-      raise InvalidPhoneNumberError, "Phone number must be ten digits" unless /\A[0-9]{10}\z/.match(phone)
-      raise InvalidPhoneNumberError, "Phone number cannot begin with 0 or 1" if ['0','1'].include?(phone[0].to_s)
-      raise InvalidMessageError, "Message cannot be blank" if message.empty?
+      super(phone, message)
       illegal_characters = ILLEGAL_CHARACTERS.match(message).to_a
       raise InvalidMessageError, "Message cannot contain the following special characters: #{illegal_characters.uniq.join(', ')}" unless illegal_characters.size.zero?
-      Mblox.log "WARNING: Some characters may be lost because the message must be broken into at least 1000 sections" if message.size > (999 * MAX_SECTION_LENGTH)
-      @message = (message.size > MAX_LENGTH) ? ON_MESSAGE_TOO_LONG_HANDLER[Mblox.config.on_message_too_long].call(message) : [message.dup]
-      @phone = "1#{phone}"
       raise BatchIdOutOfRangeError, "batch_id must be in the range 1 to #{MAX_BATCH_ID}.  The batch_id specified (#{batch_id}) is out of range." if !batch_id.blank? && (MAX_BATCH_ID < batch_id.to_i)
       @batch_id = batch_id.to_i unless batch_id.blank?
     end
@@ -49,15 +31,15 @@ module Mblox
     end
 
     def send
-      @message.collect { |message| commit build(message) }
+      messages.collect { |message| commit build(message) }
     end
     private
       def commit(request_body)
-        Mblox.log "Sending SMS to Mblox:\n#{request_body}"
+        SmsValidation.log "Sending SMS to Mblox:\n#{request_body}"
         request = self.class.request
         request.body = request_body
         response = self.class.http.start{ |http| http.request(request) }.body
-        Mblox.log "Mblox responds with:\n#{response}"
+        SmsValidation.log "Mblox responds with:\n#{response}"
         SmsResponse.from_xml(response)
       end
 
@@ -86,24 +68,6 @@ module Mblox
 	end
       end
 
-      def self.section_counter(size)
-        size / MAX_SECTION_LENGTH + ((size % MAX_SECTION_LENGTH).zero? ? 0 : 1)
-      end
-
-      def self.split_message(message)
-        sections = section_counter(message.size)
-        Mblox.log "Splitting message into #{sections} messages due to length."
-        split_message = []
-        (sections - 1).times do |i|
-          first_char = i * MAX_SECTION_LENGTH
-          Mblox.log "Section ##{i + 1} of ##{sections} contains characters #{first_char + 1} thru #{first_char + MAX_SECTION_LENGTH} of #{message.size}"
-          split_message << "(MSG #{i+1}/#{sections}): #{message[first_char, MAX_SECTION_LENGTH]}"
-        end
-        first_char = (sections-1)*MAX_SECTION_LENGTH
-        Mblox.log "Section ##{sections} of ##{sections} contains characters #{first_char + 1} thru #{message.size} of #{message.size}"
-        split_message << "(MSG #{sections}/#{sections}): #{message[first_char..-1]}"
-      end
-
       class << self
         def url
           @url ||= URI.parse(URI.escape(Mblox.config.outbound_url))

data/lib/mblox/sms_response.rb

@@ -1,7 +1,9 @@
+require 'active_support/callbacks'
 require 'active_model/callbacks'
 require 'active_model/validator'
 require 'active_model/naming'
 require 'active_model/translation'
+require 'active_support/concern'
 require 'active_model/validations'
 require 'active_model/errors'
 

data/lib/mblox/version.rb

@@ -1,3 +1,3 @@
 module Mblox
-  VERSION = "0.5.3"
+  VERSION = "0.6.0"
 end

data/mblox.gemspec

@@ -25,6 +25,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'activemodel'
   spec.add_runtime_dependency 'activesupport'
   spec.add_runtime_dependency 'addressable'
+  spec.add_runtime_dependency 'sms_validation'
   spec.add_runtime_dependency 'builder'
   spec.add_runtime_dependency "nokogiri", ">= 1.5.0"
 end

data/spec/sms_spec.rb

@@ -1,256 +1,321 @@
 # encoding: UTF-8
 require "spec_helper"
 
-module Mblox
-  class Sms
-    def build_for_test(message)
-      build(message)
-    end
-  end
-end
-
 describe Mblox::Sms do
-  def the_message
-    "Mblox gem test sent at #{Time.now}"
-  end
+  TEN_CHARACTERS = "ABCDEFGHIJ"
+  ONE_HUNDRED_SIXTY_CHARACTERS = TEN_CHARACTERS * 16
+  let(:phone_number) { TEST_NUMBER }
+  let(:message) { "Mblox gem test sent at #{Time.now}" }
+
+  subject { described_class.new(phone_number, message) }
+
   before(:all) do
     Mblox.reset_configuration
     set_configuration
   end
+
   describe "phone number" do
-    it "should be 10 digits" do
-      expect { Mblox::Sms.new("2"*9, the_message) }.to raise_error(Mblox::Sms::InvalidPhoneNumberError, "Phone number must be ten digits")
-      expect { Mblox::Sms.new("2"*10, the_message) }.to_not raise_error
-      expect { Mblox::Sms.new("2"*11, the_message) }.to raise_error(Mblox::Sms::InvalidPhoneNumberError, "Phone number must be ten digits")
-    end
+    describe "when 9 digits" do
+      let(:phone_number) { '2' * 9 }
 
-    it "should not start with 0 or 1" do
-      expect { Mblox::Sms.new("1"+"2"*9, the_message) }.to raise_error(Mblox::Sms::InvalidPhoneNumberError, "Phone number cannot begin with 0 or 1")
-      expect { Mblox::Sms.new("0"+"2"*9, the_message) }.to raise_error(Mblox::Sms::InvalidPhoneNumberError, "Phone number cannot begin with 0 or 1")
+      it "should raise an error" do
+        expect {subject}.to raise_error(Mblox::Sms::InvalidPhoneNumberError, "Phone number must be ten digits")
+      end
     end
 
-    it "should be safe from changing" do
-      number = TEST_NUMBER.to_s
-      mblox = Mblox::Sms.new(number,the_message)
-      number[1..3] = ''
-      expect(mblox.phone).to eq("1#{TEST_NUMBER}")
+    describe "when 11 digits" do
+      let(:phone_number) { '2' * 11 }
+
+      it "should raise an error" do
+        expect {subject}.to raise_error(Mblox::Sms::InvalidPhoneNumberError, "Phone number must be ten digits")
+      end
     end
-  end
 
-  describe "message" do
-    it "cannot be blank" do
-      expect { Mblox::Sms.new(LANDLINE, "") }.to raise_error(Mblox::Sms::InvalidMessageError, "Message cannot be blank")
+    describe "when 10 digits" do
+      let(:phone_number) { '2' * 10 }
+
+      it "should not raise an error" do
+        expect {subject}.not_to raise_error
+      end
     end
 
-    it "can be 160 characters long" do
-      expect { Mblox::Sms.new(LANDLINE, "A"*160) }.to_not raise_error
+    describe "when it starts with a 0" do
+      let(:phone_number) { '0' + '2' * 9 }
+
+      it "should raise an error" do
+        expect {subject}.to raise_error(Mblox::Sms::InvalidPhoneNumberError, "Phone number cannot begin with a \"0\"")
+      end
     end
 
-    it "will be truncated when the message is longer than 160 characters if configured to do so" do
-      message = "A"+"ABCDEFGHIJ"*16
-      Mblox.config.on_message_too_long = :truncate
-      expect { @mblox = Mblox::Sms.new(LANDLINE, message) }.to_not raise_error
-      expect(@mblox.message).to eq([message[0,160]])
+    describe "when it starts with a 1" do
+      let(:phone_number) { '1' + '2' * 9 }
+
+      it "should raise an error" do
+        expect {subject}.to raise_error(Mblox::Sms::InvalidPhoneNumberError, "Phone number cannot begin with a \"1\"")
+      end
     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::MessageTooLongError, "Message cannot be longer than 160 characters")
+    describe "when phone_number changes after instantiation" do
+      let(:phone_number) { super().to_s }
+      it "should be safe from changing" do
+        expect{phone_number[1..3] = ''}.not_to change{subject.phone}
+      end
     end
+  end
+
+  describe "message" do
+    let(:on_message_too_long) { :raise_error }
 
-    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
-      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
-      expect(response.count).to eq(4)
-      response.each { |r| expect(r).to be_unroutable }
+    before(:each) do
+      SmsValidation.configuration.on_message_too_long = on_message_too_long
     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
-      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
-      expect(response.count).to eq(3)
-      response.each { |r| expect(r).to be_unroutable }
+    describe "when message is blank" do
+      let(:message) { "" }
+
+      it "should raise an error" do
+        expect{subject}.to raise_error(Mblox::Sms::InvalidMessageError, "Message cannot be blank")
+      end
     end
 
-    it "should be safe from changing when short" do
-      msg = the_message
-      mblox = Mblox::Sms.new(TEST_NUMBER,msg)
-      msg[1..3] = ''
-      expect(mblox.message).to eq([the_message])
+    describe "when 160 characters long" do
+      let(:message) { ONE_HUNDRED_SIXTY_CHARACTERS }
+
+      it "sohuld not raise an error" do
+        expect{subject}.to_not raise_error
+      end
     end
 
-    it "should be safe from changing when long when configured to split" do
-      Mblox.config.on_message_too_long = :split
-      msg = the_message * 10
-      mblox = Mblox::Sms.new(TEST_NUMBER,msg)
-      msg[1..3] = ''
-      expect(mblox.message[0][11, 20]).to eq(the_message[0,20])
+    describe "when message is longer than 160 characters" do
+      let(:message) { "A" + ONE_HUNDRED_SIXTY_CHARACTERS }
+
+      describe "when on_message_too_long = :truncate" do
+        let(:on_message_too_long) { :truncate }
+
+        it "will be truncated when the message is longer than 160 characters" do
+          expect(subject.message).to eq(message[0,160])
+        end
+
+        it "should be safe from changing when long" do
+          expect{message[1..3] = ''}.not_to change{subject.message}
+        end
+      end
+
+      describe "when on_message_too_long = :raise_error" do
+        let(:on_message_too_long) { :raise_error }
+
+        it "cannot be longer than 160 characters" do
+          expect{subject}.to raise_error(Mblox::Sms::MessageTooLongError, "Message cannot be longer than 160 characters")
+        end
+      end
+
+      describe "when on_message_too_long = :split" do
+        let(:on_message_too_long) { :split }
+        let(:phone_number) { LANDLINE }
+
+        describe "when split is even" do
+          let(:message) { TEN_CHARACTERS * 58 }
+
+          it "should be split into multiple messages when longer than 160 characters" do
+            expect(subject.messages).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 = subject.send
+            expect(response.count).to eq(4)
+            response.each { |r| expect(r).to be_unroutable }
+          end
+        end
+
+        describe "when split is not even" do
+          let(:message) { TEN_CHARACTERS * 32 }
+
+          it "should be split into multiple messages when longer than 160 characters" do
+            expect(subject.messages).to eq(["(MSG 1/3): #{message[0,145]}", "(MSG 2/3): #{message[145,145]}", "(MSG 3/3): #{message[290..-1]}"])
+            response = subject.send
+            expect(response.count).to eq(3)
+            response.each { |r| expect(r).to be_unroutable }
+          end
+
+          it "should be safe from changing when long" do
+            expect{message[1..3] = ''}.not_to change{subject.messages}
+          end
+        end
+      end
     end
 
-    it "should be safe from changing when long when configured to truncate" do
-      Mblox.config.on_message_too_long = :truncate
-      msg = the_message * 10
-      mblox = Mblox::Sms.new(TEST_NUMBER,msg)
-      msg[1..3] = ''
-      expect(mblox.message[0][0, 20]).to eq(the_message[0,20])
+    it "should be safe from changing when long" do
+      expect{message[1..3] = ''}.not_to change{subject.message}
     end
   end
 
   describe "SMS messages" do
-    def expect_ok_response(response)
-      expect(response).to be_ok
-      expect(response).not_to be_unroutable
-    end
+    let(:response) { subject.send }
 
-    it "should be sent when the phone number is a Fixnum" do
-      response = Mblox::Sms.new(TEST_NUMBER.to_i,the_message).send
+    def should_have_ok_response
       expect(response.size).to eq(1)
-      expect_ok_response(response.first)
+      expect(response[0]).to be_ok
+      expect(response[0]).not_to be_unroutable
     end
 
-    it "should be sent when the phone number is a String" do
-      response = Mblox::Sms.new(TEST_NUMBER.to_s,the_message).send
+    def should_have_unroutable_response
       expect(response.size).to eq(1)
-      expect_ok_response(response.first)
+      expect(response[0]).not_to be_ok
+      expect(response[0]).to be_unroutable
     end
 
-    it "should allow 160-character messages" do
-      response = Mblox::Sms.new(TEST_NUMBER,"A"*160).send
-      expect(response.size).to eq(1)
-      expect_ok_response(response.first)
+    it { should_have_ok_response }
+
+    describe "when phone_number is a String" do
+      let(:phone_number) { super().to_s }
+
+      it { should_have_ok_response }
     end
 
-    it "should be unroutable when sent to a landline" do
-      response = Mblox::Sms.new(LANDLINE,the_message).send
-      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
+    describe "when message is 160 characters" do
+      let(:message) { ONE_HUNDRED_SIXTY_CHARACTERS }
+
+      it { should_have_ok_response }
     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
-        expect(response.size).to eq(1)
-        expect(response.first).not_to be_ok
-        expect(response.first).to be_unroutable
+    describe "when sent to a landline" do
+      let(:phone_number) { LANDLINE }
+
+      it { should_have_unroutable_response }
+
+      described_class::LEGAL_CHARACTERS.each_char do |i|
+        describe "when message contains legal character '#{i}'" do
+          let(:message) { "#{super()}#{i}#{super()}" }
+
+          it { should_have_unroutable_response }
+        end
       end
     end
 
-    it "can send all the legal characters" do
-      response = Mblox::Sms.new(TEST_NUMBER,Mblox::Sms::LEGAL_CHARACTERS).send
-      expect(response.size).to eq(1)
-      expect(response.first).to be_ok
+    describe "when message contains legal character '\'" do
+      let(:message) { "#{super()}\A#{super()}" }
+
+      it { should_have_ok_response }
     end
 
-    it "can send a backslash" do
-      response = Mblox::Sms.new(TEST_NUMBER,'\\').send
-      expect(response.size).to eq(1)
-      expect(response.first).to be_ok
+    describe "when all legal characters are in message" do
+      let(:message) { described_class::LEGAL_CHARACTERS }
+      it { should_have_ok_response }
     end
   end
 
   describe "batch_id" do
-    def batch_id(content)
-      content['NotificationRequest']['NotificationList']['BatchID']
+    let(:phone_number) { LANDLINE }
+
+    subject { described_class.new(phone_number, message, batch_id) }
+
+    def should_set_the_batch_id_to(expected)
+      expect(subject).to receive(:commit) do |arg|
+        expect(arg).to match(/<NotificationList BatchID=\"#{expected}\">/)
+      end
+      subject.send
     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))
-      expect(batch_id(content)).to eq("#{batch_id}")
+
+    describe "when a Fixnum" do
+      let(:batch_id) { 12345 }
+
+      it { should_set_the_batch_id_to(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))
-      expect(batch_id(content)).to eq("#{batch_id}")
+    describe "when a String" do
+      let(:batch_id) { 12345.to_s }
+
+      it { should_set_the_batch_id_to(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))
-      expect(batch_id(content)).to eq('1')
+    describe "when a Float" do
+      let(:batch_id) { 12345.0 }
+
+      it { should_set_the_batch_id_to(batch_id.to_i) }
     end
 
-    it "can be 99999999" do
-      expect{Mblox::Sms.new(LANDLINE,the_message, 99999999)}.to_not raise_error
+    describe "when default" do
+      subject { described_class.new(phone_number, message) }
+
+      it { should_set_the_batch_id_to(1) }
+    end
+
+    describe "when the maximum allowed" do
+      let(:batch_id) { 99999999 }
+
+      it { should_set_the_batch_id_to(batch_id) }
     end
 
-    it "cannot be 100000000" do
-      expect{Mblox::Sms.new(LANDLINE,the_message, 100000000)}.to raise_error(Mblox::Sms::BatchIdOutOfRangeError, 'batch_id must be in the range 1 to 99999999.  The batch_id specified (100000000) is out of range.')
+    describe "when 1 more than the maximum allowed" do
+      let(:batch_id) { 100000000 }
+
+      it "should raise an error" do
+        expect{subject}.to raise_error(Mblox::Sms::BatchIdOutOfRangeError, 'batch_id must be in the range 1 to 99999999.  The batch_id specified (100000000) is out of range.')
+      end
     end
   end
 
   describe "send from" do
-    before(:each) do
-      @sms = Mblox::Sms.new(TEST_NUMBER,'This message should come from shortcode 55555')
-    end
+    let(:message) { "This message should come from shortcode 55555" }
 
     describe "sender_id" do
       def raise_invalid_sender_id_error
         raise_error(Mblox::Sms::InvalidSenderIdError, 'You can only send from a 5-digit shortcode')
       end
+
       it "cannot be a 4-digit number" do
-        expect{@sms.send_from(1234)}.to raise_invalid_sender_id_error
+        expect{subject .send_from(1234)}.to raise_invalid_sender_id_error
       end
       it "cannot be a 6-digit number" do
-        expect{@sms.send_from(123456)}.to raise_invalid_sender_id_error
+        expect{subject .send_from(123456)}.to raise_invalid_sender_id_error
       end
       it "cannot be a blank string" do
-        expect{@sms.send_from('')}.to raise_invalid_sender_id_error
+        expect{subject .send_from('')}.to raise_invalid_sender_id_error
       end
       it "cannot be a float" do
-        expect{@sms.send_from(12345.6)}.to raise_invalid_sender_id_error
+        expect{subject .send_from(12345.6)}.to raise_invalid_sender_id_error
       end
       it "cannot be nil" do
-        expect{@sms.send_from(nil)}.to raise_invalid_sender_id_error
+        expect{subject .send_from(nil)}.to raise_invalid_sender_id_error
       end
     end
 
     describe "service_id" do
+      let(:sender_id) { Mblox.config.sender_id }
+
       def raise_invalid_service_id
         raise_error(Mblox::Sms::InvalidSenderIdError, "You can only send using a 5-digit service ID.  Leave out the 2nd argument of send_from to use the globally configured '#{Mblox.config.service_id}'")
       end
+
       it "cannot be a 4-digit number" do
-        expect{@sms.send_from(Mblox.config.sender_id, 1234)}.to raise_invalid_service_id
+        expect{subject.send_from(sender_id, 1234)}.to raise_invalid_service_id
       end
       it "cannot be a 6-digit number" do
-        expect{@sms.send_from(Mblox.config.sender_id, 123456)}.to raise_invalid_service_id
+        expect{subject.send_from(sender_id, 123456)}.to raise_invalid_service_id
       end
       it "cannot be a blank string" do
-        expect{@sms.send_from(Mblox.config.sender_id, '')}.to raise_invalid_service_id
+        expect{subject.send_from(sender_id, '')}.to raise_invalid_service_id
       end
       it "cannot be a float" do
-        expect{@sms.send_from(Mblox.config.sender_id, 12345.6)}.to raise_invalid_service_id
+        expect{subject.send_from(sender_id, 12345.6)}.to raise_invalid_service_id
       end
       it "can be nil" do
-        expect{@sms.send_from(Mblox.config.sender_id, nil)}.to_not raise_error
+        expect{subject.send_from(sender_id, nil)}.to_not raise_error
       end
     end
 
     it "should send from the specified sender_id" do
-      expect(@sms.instance_variable_get("@sender_id")).to be_nil
-      expect{@sms.send_from(55555)}.to_not raise_error
-      expect(@sms.send.first).to be_ok
-      expect(@sms.instance_variable_get("@sender_id")).to eq("55555")
+      subject.send_from(55555)
+      expect(subject).to receive(:commit) do |arg|
+        expect(arg).to match(/<SenderID Type=\"Shortcode\">55555<\/SenderID>/)
+      end
+      subject.send
     end
 
     it "should send from the specified sender_id and service_id" do
-      expect(@sms.instance_variable_get("@service_id")).to be_nil
-      expect{@sms.send_from(55555, 44444)}.to_not raise_error
-      response = @sms.send.first
-      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")
+      subject.send_from(55555, 44444)
+      expect(subject).to receive(:commit) do |arg|
+        expect(arg).to match(/<ServiceId>44444<\/ServiceId>/)
+        expect(arg).to match(/<SenderID Type=\"Shortcode\">55555<\/SenderID>/)
+      end
+      subject.send
     end
   end
 end

data/spec/spec_helper.rb

@@ -21,7 +21,7 @@ LANDLINE = 6176354500
 module Mblox
   class << self
     def reset_configuration
-      @config = Configuration.new
+      @config = nil
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mblox
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Isaac Betesh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-18 00:00:00.000000000 Z
+date: 2015-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sms_validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: builder
   requirement: !ruby/object:Gem::Requirement
@@ -131,6 +145,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -144,7 +159,6 @@ files:
 - lib/mblox/sms_response.rb
 - lib/mblox/version.rb
 - mblox.gemspec
-- spec/configuration_spec.rb
 - spec/sms_receipt_spec.rb
 - spec/sms_response_result_spec.rb
 - spec/sms_response_spec.rb
@@ -178,9 +192,11 @@ summary: '# Mblox  This gem is for subscribers to Mblox to send SMS messages.  #
   then execute:  $ bundle  Or install it yourself as:  $ gem install mblox  ## Usage  Configuration  Mblox.configure
   do |config| # Set all of these values, provided to you in your Mblox subscription
   config.outbound_url = ... config.profile_id = ... config.sender_id = ... config.password
-  = ... config.partner_name = ... config.tariff = ... config.service_id = ...  # You
-  can also configure some logging options # In a Rails environment, config.logger
-  will default to Rails.logger and config.log_at will default to :debug # config.log_at
+  = ... config.partner_name = ... config.tariff = ... config.service_id = ... end  #
+  You can also configure some logging options via SmsValidation, a dependency of this
+  gem.  See https://github.com/betesh/sms_validation/blob/master/README.md for details
+  SmsValidation.configure do |config| # In a Rails environment, config.logger will
+  default to Rails.logger and config.log_at will default to :debug # config.log_at
   means the level at which Mblox will log. # For instance, if config.log_at == :debug,
   Mblox will log only if the logger''s log level is :debug # Note that if config.log_at
   == :debug and your logger''s log level is :info, #   logging will be suppressed
@@ -198,7 +214,6 @@ summary: '# Mblox  This gem is for subscribers to Mblox to send SMS messages.  #
   your changes (`git commit -am ''Add some feature''`) 4. Push to the branch (`git
   push origin my-new-feature`) 5. Create new Pull Request'
 test_files:
-- spec/configuration_spec.rb
 - spec/sms_receipt_spec.rb
 - spec/sms_response_result_spec.rb
 - spec/sms_response_spec.rb

data/spec/configuration_spec.rb

@@ -1,59 +0,0 @@
-require "spec_helper"
-
-describe Mblox::Configuration do
-  describe "logger" do
-    before(:each) do
-      Mblox.reset_configuration
-    end
-
-    after(:all) do
-      set_configuration
-    end
-
-    [:fatal, :error, :warn, :info, :debug].each do |val|
-      it "should allow log level ':#{val}'" do
-        Mblox.config.log_at val
-        Mblox.config.logger = ::Logger.new('/dev/null')
-        expect { Mblox.log "Some info" }.to_not raise_error
-      end
-    end
-
-    it "should default to log level debug" do
-      expect(Mblox.config.log_level).to eq(:debug)
-      expect { Mblox.log "Some debug info" }.to_not raise_error
-    end
-
-    it "should not allow log level news when the logger is created after log level is set" do
-      Mblox.config.log_at :news
-      expect { Mblox.config.logger = ::Logger.new(STDOUT)}.to raise_error(ArgumentError, "Mblox log level must be set to :fatal, :error, :warn, :info or :debug")
-      expect { Mblox.log "Some news" }.to_not raise_error
-    end
-
-    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")
-      expect(Mblox.config.log_level).to eq(:debug)
-      expect { Mblox.log "Some news" }.to_not raise_error
-    end
-  end
-
-  describe "on_message_too_long" do
-    it "should default to :raise_error" do
-      Mblox.reset_configuration
-      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
-        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")
-      expect(Mblox.config.on_message_too_long).to eq(original)
-    end
-  end
-end