sms_broker 1.0.0 → 1.0.2

data/spec/sms_broker/nexmo_spec.rb

@@ -1,29 +1,25 @@
 describe SmsBroker do
-
   context 'Nexmo' do
-
-    let(:text_message) { 'Hello World' }
-    let(:from_phone) { ENV['NEXMO_PHONE_NUMBER'] }
-    let(:api_secret) { ENV['NEXMO_API_SECRET'] }
-    let(:sender_id) { ENV['NEXMO_SENDER_ID'] }
-    let(:to_phone) { '44741234567' }
-    let(:api_key) { ENV['NEXMO_API_SECRET'] }
-
     context '#send_message' do
+      let(:text_message) { 'Hello World' }
+      let(:from_phone) { '+447476543210' }
+      let(:sender_id) { 'SenderID' }
+      let(:to_phone) { '+447491234567' }
+      let(:api_secret) { 'api_secret' }
+      let(:api_key) { 'api_key' }
 
       before(:each) do
         SmsBroker.clear_setup
       end
 
       context 'valid' do
-
         it 'should send message with success' do
           SmsBroker.setup do |config|
             config.nexmo_setup \
               phone_number: from_phone,
               sender_id: sender_id,
               secret: api_secret,
-              key: ENV['NEXMO_API_KEY']
+              key: api_key
           end
 
           stub_nexmo_create_message_success(sender_id, to_phone, text_message)
@@ -35,37 +31,32 @@ describe SmsBroker do
           expect(response.message_id).not_to eq(nil)
         end
 
-        context 'with sender_id' do
-
-          it 'should return error for invalid sender_id' do
-             SmsBroker.setup do |config|
-              config.nexmo_setup \
-                phone_number: from_phone,
-                sender_id: sender_id,
-                secret: api_secret,
-                key: ENV['NEXMO_API_KEY']
-            end
-
-            stub_nexmo_create_message_success \
-              from_phone, to_phone, text_message
+        it 'should return error for invalid sender_id and fallback to ' \
+           'phone_number' do
+          SmsBroker.setup do |config|
+            config.nexmo_setup \
+              phone_number: from_phone,
+              sender_id: sender_id,
+              secret: api_secret,
+              key: api_key
+          end
 
-            stub_nexmo_create_message_invalid_sender_id_request \
-              sender_id, to_phone, text_message
+          stub_nexmo_create_message_invalid_sender_id_request \
+            sender_id, to_phone, text_message
 
-            response = SmsBroker.message(text_message).to(to_phone).deliver
+          stub_nexmo_create_message_success \
+            from_phone, to_phone, text_message
 
-            expect(response.success?).to eq(true)
-            # this means that it tried to send with sender_id and failed
-            # and then sent with from_phone
-            expect(response.from).to eq(from_phone)
-          end
+          response = SmsBroker.message(text_message).to(to_phone).deliver
 
+          expect(response.success?).to eq(true)
+          # this means that it tried to send with sender_id and failed
+          # and then sent with from_phone
+          expect(response.from).to eq(from_phone)
         end
-
       end
 
       context 'invalid' do
-
         it 'should return error for invalid credentials' do
           SmsBroker.setup do |config|
             config.nexmo_setup \
@@ -83,10 +74,23 @@ describe SmsBroker do
           expect(response.serialized.length).to be > 0
         end
 
-      end
+        it 'should return error an unknown error' do
+          SmsBroker.setup do |config|
+            config.nexmo_setup \
+              phone_number: from_phone,
+              secret: api_secret,
+              key: api_key
+          end
 
-    end
+          stub_nexmo_create_message_unknown_error \
+            from_phone, to_phone, text_message
 
-  end
+          response = SmsBroker.message(text_message).to(to_phone).deliver
 
+          expect(response.success?).to eq(false)
+          expect(response.serialized.length).to be > 0
+        end
+      end
+    end
+  end
 end

data/spec/sms_broker/real_call_spec.rb

@@ -0,0 +1,63 @@
+describe SmsBroker do
+  context 'SmsBroker' do
+    let(:text_message) { 'Hello World' }
+
+    context 'Valid real calls' do
+      before(:all) do
+        unless ENV['REAL_PHONE_NUMBER']
+          skip 'REAL_PHONE_NUMBER env var is required to run this spec'
+        end
+
+        WebMock.allow_net_connect!
+
+        SmsBroker.clear_setup
+
+        SmsBroker.setup do |config|
+          config.services %w(nexmo twilio)
+
+          config.default_service 'nexmo'
+
+          config.nexmo_setup \
+            key: ENV['NEXMO_LIVE_API_KEY'],
+            sender_id: ENV['NEXMO_LIVE_SENDER_ID'],
+            secret: ENV['NEXMO_LIVE_API_SECRET'],
+            phone_number: ENV['NEXMO_LIVE_PHONE_NUMBER']
+
+          config.twilio_setup \
+            sender_id: ENV['TWILIO_LIVE_SENDER_ID'],
+            auth_token: ENV['TWILIO_LIVE_AUTH_TOKEN'],
+            account_sid: ENV['TWILIO_LIVE_ACCOUNT_SID'],
+            phone_number: ENV['TWILIO_LIVE_PHONE_NUMBER']
+        end
+      end
+
+      after(:all) do
+        WebMock.disable_net_connect!
+      end
+
+      context 'Nexmo' do
+        it 'should successfuly send message' do
+          message = \
+            SmsBroker
+              .service(:nexmo)
+              .message(text_message)
+              .to(ENV['REAL_PHONE_NUMBER'])
+
+          expect(message.deliver.success?).to eq true
+        end
+      end
+
+      context 'Twillio' do
+        it 'should successfuly send message' do
+          message = \
+            SmsBroker
+              .service(:twilio)
+              .message(text_message)
+              .to(ENV['REAL_PHONE_NUMBER'])
+
+          expect(message.deliver.success?).to eq true
+        end
+      end
+    end
+  end
+end

data/spec/sms_broker/setup_spec.rb

@@ -1,7 +1,5 @@
 describe SmsBroker do
-
   context 'Setup' do
-
     before(:each) do
       SmsBroker.clear_setup
     end
@@ -9,7 +7,7 @@ describe SmsBroker do
     it 'should set configs' do
       setup = \
         SmsBroker.setup do |config|
-          config.services ['nexmo', 'twilio']
+          config.services %w(nexmo twilio)
 
           config.default_service 'nexmo'
 
@@ -27,7 +25,7 @@ describe SmsBroker do
       expect(setup.valid?).to eq(true)
 
       expect(setup.options[:services]).to \
-        eq(['nexmo', 'twilio'])
+        eq(%w(nexmo twilio))
 
       expect(setup.options[:default_service]).to \
         eq('nexmo')
@@ -46,13 +44,10 @@ describe SmsBroker do
     end
 
     context 'valid configs' do
-
       before(:each) do
         SmsBroker.setup do |config|
-          config.services ['nexmo', 'twilio']
-
+          config.services %w(nexmo twilio)
           config.default_service 'nexmo'
-
           config.nexmo_setup \
             key: 'NEXMO_API_KEY',
             phone_number: 'phone',
@@ -76,15 +71,12 @@ describe SmsBroker do
 
         expect(service.client).to be_a SmsBroker::Client::Twilio
       end
-
     end
 
     context 'invalid configs' do
-
       it 'should return error about available services' do
         setup = SmsBroker.setup do |config|
-          config.services ['nexmo', 'twilio']
-
+          config.services %w(nexmo twilio)
           config.default_service 'nexmo'
         end
 
@@ -108,43 +100,38 @@ describe SmsBroker do
 
       it 'should return error default_service' do
         setup = SmsBroker.setup do |config|
-          config.services ['nexmo', 'twilio']
-
+          config.services %w(nexmo twilio)
           config.default_service 'nope'
         end
 
         expect(setup.valid?).to eq(false)
 
         expect(setup.errors[:default_service]).to \
-          include("must be within [\"nexmo\", \"twilio\"]")
+          include('must be within ["nexmo", "twilio"]')
       end
 
       context 'setup!' do
-
         it 'should raise exception for invalid setup' do
-          expect {
+          expect do
             SmsBroker.setup! do |config|
-              config.services ['nexmo', 'twilio']
+              config.services %w(nexmo twilio)
               config.default_service 'nope'
             end
-          }.to raise_error(SmsBroker::Exceptions::InvalidSetup)
+          end.to raise_error(SmsBroker::Exceptions::InvalidSetup)
         end
 
         it 'should return error for missing required service setup' do
-          expect {
+          expect do
             SmsBroker.setup! do |config|
               config.default_service 'nexmo'
 
               config.nexmo_setup \
                 not_exists: 'key'
             end
-          }.to raise_error(SmsBroker::Exceptions::InvalidSetup)
+          end.to raise_error(SmsBroker::Exceptions::InvalidSetup)
         end
-
       end
-
     end
-
   end
 
   it 'should respond_to :message' do
@@ -154,8 +141,7 @@ describe SmsBroker do
   it 'should raise InvalidSetup for service not being setup' do
     SmsBroker.clear_setup
 
-    expect{ SmsBroker::Service.get(:twilio) }.to \
+    expect { SmsBroker::Service.get(:twilio) }.to \
       raise_error SmsBroker::Exceptions::InvalidSetup
   end
-
 end

data/spec/sms_broker/sms_broker_spec.rb

@@ -1,23 +1,20 @@
 describe SmsBroker do
-
   context 'SmsBroker' do
-
     let(:text_message) { 'Hello World' }
+    let(:account_sid) { 'account_sid' }
+    let(:auth_token) { 'auth_token' }
 
     context 'Invalid data when trying to deliver' do
-
-      before(:all) do
+      before(:each) do
         SmsBroker.clear_setup
 
         SmsBroker.setup do |config|
           config.services ['twilio']
-
           config.default_service 'twilio'
-
           config.twilio_setup \
             phone_number: '15005550001',
-            account_sid: ENV['TWILIO_ACCOUNT_SID'],
-            auth_token: ENV['TWILIO_AUTH_TOKEN']
+            account_sid: account_sid,
+            auth_token: auth_token
         end
       end
 
@@ -25,121 +22,50 @@ describe SmsBroker do
         response = SmsBroker.service.message(text_message).to(nil).deliver
 
         expect(response.success?).to eq(false)
-        expect(response.serialized[:errors][:to]).to include("is required")
+        expect(response.serialized[:errors][:to]).to include('is required')
       end
 
       it 'should return error for missing message' do
         response = SmsBroker.service.message(nil).to(nil).deliver
 
         expect(response.success?).to eq(false)
-        expect(response.serialized[:errors][:message]).to include("is required")
+        expect(response.serialized[:errors][:message]).to include('is required')
       end
 
       it 'should return error for invalid message' do
-        message_160 = "Lorem Ipsum is simply dummy text of the printing and " \
-                      "typesetting industry. Lorem Ipsum has been the " \
-                      "industry's standard dummy text ever since the 1500s, when an"
+        message_160 = 'Lorem Ipsum is simply dummy text of the printing and ' \
+                      'typesetting industry. Lorem Ipsum has been the ' \
+                      'industrys standard dummy text ever since the 1500s, ' \
+                      'when an'
 
         response = \
           SmsBroker.service.message(message_160).to('44123457891').deliver
 
         expect(response.success?).to eq(false)
         expect(response.serialized[:errors][:message]).to \
-          include("cannot have length greater than 140")
+          include('cannot have length greater than 140')
       end
-
     end
 
     context 'Invalid setup when trying to deliver' do
-
       before(:all) do
         SmsBroker.clear_setup
 
-        @setu = SmsBroker.setup do |config|
+        SmsBroker.setup do |config|
           config.services ['nexmo']
-
           config.default_service 'nexmo'
-
           config.nexmo_setup \
-            key: ENV['NEXMO_API_KEY'],
-            sender_id: ENV['NEXMO_SENDER_ID'],
-            phone_number: ENV['NEXMO_PHONE_NUMBER']
-            # secret: ENV['NEXMO_API_SECRET']
+            key: 'nexmo_api_key',
+            secret: 'nexmo_api_secret',
+            sender_id: 'nexmo_sender_id'
         end
       end
 
-      it 'should return error for missing number' do
-        expect {
+      it 'should return error for missing phone_number' do
+        expect do
           SmsBroker.service.message(text_message).to('44123457891').deliver
-        }.to raise_error SmsBroker::Exceptions::InvalidService
-      end
-
-    end
-
-    context 'Valid real calls' do
-
-      before(:all) do
-        SmsBroker.clear_setup
-
-        SmsBroker.setup do |config|
-          config.services ['nexmo', 'twilio']
-
-          config.default_service 'nexmo'
-
-          config.nexmo_setup \
-            key: ENV['NEXMO_API_KEY'],
-            secret: ENV['NEXMO_API_SECRET'],
-            sender_id: ENV['NEXMO_SENDER_ID'],
-            phone_number: ENV['NEXMO_PHONE_NUMBER']
-
-          config.twilio_setup \
-            sender_id: ENV['TWILIO_LIVE_SENDER_ID'],
-            auth_token: ENV['TWILIO_LIVE_AUTH_TOKEN'],
-            account_sid: ENV['TWILIO_LIVE_ACCOUNT_SID'],
-            phone_number: ENV['TWILIO_LIVE_PHONE_NUMBER']
-        end
-      end
-
-      before(:all) do
-        unless ENV['REAL_PHONE_NUMBER']
-          skip "REAL_PHONE_NUMBER env var is required to run this spec"
-        end
-
-        WebMock.allow_net_connect!
-      end
-
-      after(:all) do
-        WebMock.disable_net_connect!
-      end
-
-      context 'Nexmo' do
-
-        it "should successfuly send message" do
-          message = \
-            SmsBroker.service(:nexmo).message('test').to(ENV['REAL_PHONE_NUMBER'])
-
-          response = message.deliver
-
-          expect(response.success?).to eq true
-        end
-
+        end.to raise_error SmsBroker::Exceptions::InvalidService
       end
-
-      context 'Twillio' do
-
-        it "should successfuly send message" do
-          message = \
-            SmsBroker.service(:twilio).message('test').to(ENV['REAL_PHONE_NUMBER'])
-
-          response = message.deliver
-
-          expect(response.success?).to eq true
-        end
-
-      end
-
     end
-
   end
-
 end

data/spec/sms_broker/twilio_spec.rb

@@ -1,93 +1,76 @@
 describe SmsBroker do
-
   context 'Twilio' do
-
     context '#send_message' do
-
       let(:text_message) { 'Hello World' }
-      let(:from_phone) { ENV['TWILIO_PHONE_NUMBER'] }
-      let(:sender_id) { ENV['TWILIO_SENDER_ID'] }
+      let(:from_phone) { '15005550006' }
+      let(:account_sid) { 'account_sid' }
+      let(:auth_token) { 'auth_token' }
 
       before(:each) do
         SmsBroker.clear_setup
       end
 
-      def send_message(text, to)
-        WebMock.allow_net_connect!
-
-        response = SmsBroker.service.message(text).to(to).deliver
-
-        WebMock.disable_net_connect!
-
-        response
+      def send_message(text_message, to)
+        SmsBroker.service.message(text_message).to(to).deliver
       end
 
       context 'valid' do
-
         it 'should send message with success' do
           SmsBroker.setup do |config|
             config.services ['twilio']
-
             config.default_service 'twilio'
-
             config.twilio_setup \
               phone_number: from_phone,
-              account_sid: ENV['TWILIO_ACCOUNT_SID'],
-              auth_token: ENV['TWILIO_AUTH_TOKEN']
+              account_sid: account_sid,
+              auth_token: auth_token
           end
 
-          response = send_message(text_message, '15005550006')
+          VCR.use_cassette('twilio/create_success') do
+            response = send_message(text_message, '15005550006')
 
-          expect(response.service).to eq(:twilio)
-          expect(response.success?).to eq(true)
-          expect(response.message_id).not_to eq(nil)
+            expect(response.service).to eq(:twilio)
+            expect(response.success?).to eq(true)
+            expect(response.message_id).not_to eq(nil)
+          end
         end
 
         context 'with sender_id' do
-
           before(:each) do
             SmsBroker.setup do |config|
               config.services ['twilio']
-
               config.default_service 'twilio'
-
               config.twilio_setup \
                 phone_number: '15005550001',
-                account_sid: ENV['TWILIO_ACCOUNT_SID'],
-                auth_token: ENV['TWILIO_AUTH_TOKEN']
+                account_sid: account_sid,
+                auth_token: auth_token
             end
           end
 
           it 'should return error for invalid sender_id' do
-            response = send_message(text_message, '15005550006')
-
-            expect(response.service).to eq(:twilio)
-
-            expect(response.success?).to eq(false)
-
-            expect(response.serialized[:errors].keys).to include('21212')
-            # if the code is 21212 and message includes the phone_number,
-            # it means that it tried with sender_id and failed
-            expect(response.serialized[:errors]['21212'][0]).to \
-              include("The 'From' number 15005550001 is not a valid")
+            VCR.use_cassette('twilio/create_invalid_phone_error') do
+              response = send_message(text_message, '15005550006')
+
+              expect(response.service).to eq(:twilio)
+              expect(response.success?).to eq(false)
+              expect(response.serialized[:errors].keys).to include('21212')
+              # if the code is 21212 and message includes the phone_number,
+              # it means that it tried with sender_id and failed
+              expect(response.serialized[:errors]['21212'][0]).to \
+                include("The 'From' number +15005550001 is not a valid")
+            end
           end
-
         end
-
       end
 
       context 'invalid' do
-
         it 'should return error for missing required data' do
           SmsBroker.setup do |config|
             config.services ['twilio']
-
             config.default_service 'twilio'
-
             config.twilio_setup \
               phone_number: '15005550001',
-              account_sid: ENV['TWILIO_ACCOUNT_SID'],
-              auth_token: ENV['TWILIO_AUTH_TOKEN']
+              account_sid: account_sid,
+              auth_token: auth_token
           end
 
           response = SmsBroker.message(text_message).deliver
@@ -98,25 +81,21 @@ describe SmsBroker do
         it 'should return error for invalid from phone' do
           SmsBroker.setup do |config|
             config.services ['twilio']
-
             config.default_service 'twilio'
-
             config.twilio_setup \
               phone_number: '15005550001',
-              account_sid: ENV['TWILIO_ACCOUNT_SID'],
-              auth_token: ENV['TWILIO_AUTH_TOKEN']
+              account_sid: account_sid,
+              auth_token: auth_token
           end
 
-          response = send_message(text_message, '15005550006')
+          VCR.use_cassette('twilio/create_invalid_phone_error') do
+            response = send_message(text_message, '15005550006')
 
-          expect(response.success?).to eq(false)
-          expect(response.serialized.length).to be > 0
+            expect(response.success?).to eq(false)
+            expect(response.serialized.length).to be > 0
+          end
         end
-
       end
-
     end
-
   end
-
 end

data/spec/spec_helper.rb

@@ -1,7 +1,10 @@
 require 'pry'
-require 'yaml'
+require 'vcr'
 require 'simplecov'
 require 'codeclimate-test-reporter'
+require 'sms_broker'
+require 'webmock/rspec'
+require 'support/nexmo_helpers'
 
 SimpleCov.start do
   formatter SimpleCov::Formatter::MultiFormatter.new [
@@ -10,20 +13,11 @@ SimpleCov.start do
   ]
 end
 
-# load service_keys.yml to ENV
-yml_file = File.expand_path('../support/services_keys.yml', __FILE__)
-
-YAML.load(File.read(yml_file)).each do |key, value|
-  ENV[key] = value
-end
-
-require 'sms_broker'
-require 'webmock/rspec'
-
-require 'support/nexmo_helpers'
-
 RSpec.configure do |config|
-
   config.include NexmoHelpers
+end
 
+VCR.configure do |config|
+  config.cassette_library_dir = 'spec/support/vcr_cassettes'
+  config.hook_into :webmock
 end