sms_broker 1.0.0

data/lib/sms_broker/setup.rb

@@ -0,0 +1,82 @@
+module SmsBroker
+
+  class Setup
+
+    attr_reader :options,
+                :errors
+
+    def self.service_validation_schemas
+      {
+        nexmo: Compel.hash.keys({
+          key: Compel.string.required,
+          secret: Compel.string.required,
+          sender_id: Compel.string,
+          phone_number: Compel.string.required
+        }),
+        twilio: Compel.hash.keys({
+          sender_id: Compel.string,
+          auth_token: Compel.string.required,
+          account_sid: Compel.string.required,
+          phone_number: Compel.string.required
+        })
+      }
+    end
+
+    def initialize
+      @errors = {}
+      @options = {
+        services: ['nexmo'],
+        default_service: 'nexmo',
+        services_setups: {}
+      }
+    end
+
+    def services(services)
+      @options[:services] = services
+    end
+
+    def default_service(service)
+      @options[:default_service] = service
+    end
+
+    def valid?
+      result = compel_validation_schema(@options[:services]).validate(@options)
+
+      @errors = result.errors
+
+      result.valid?
+    end
+
+    def compel_validation_schema(services_list = [])
+      not_all_services_setup = Proc.new do |services_setups|
+        services_list.all?{ |service|
+          services_setups.keys.include?(service.to_sym)
+        }
+      end
+
+      services_setups_schema = \
+        Compel.hash.required
+          .keys(Setup.service_validation_schemas)
+          .if(not_all_services_setup, message: 'all services must be setup')
+
+      Compel.hash.keys \
+        services: Compel.array.required.min_length(1),
+        default_service: Compel.string.required.in(services_list),
+        services_setups: services_setups_schema
+    end
+
+    def method_missing(method, args, &block)
+      service = "#{method}".split('_setup')[0].dup
+
+      if @options[:services].include?(service)
+        @options[:services_setups][service.to_sym] = args
+        @options[:services_setups]
+      else
+
+        super
+      end
+    end
+
+  end
+
+end

data/lib/sms_broker/version.rb

@@ -0,0 +1,5 @@
+module SmsBroker
+
+  VERSION = '1.0.0'
+
+end

data/lib/sms_broker.rb

@@ -0,0 +1,25 @@
+require 'nexmo'
+require 'compel'
+require 'twilio-ruby'
+
+require 'sms_broker/client/response/error'
+require 'sms_broker/client/response/success'
+
+require 'sms_broker/configuration'
+require 'sms_broker/service'
+
+module SmsBroker
+
+  extend Configuration
+
+  def service(name = default_service)
+    Service.get(name)
+  end
+
+  def message(body)
+    service.message(body)
+  end
+
+  extend self
+
+end

data/sms_broker.gemspec

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sms_broker/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'sms_broker'
+  gem.version       = SmsBroker::VERSION
+  gem.authors       = ['Streetbees Dev Team']
+  gem.email         = ['dev@streetbees.com']
+  gem.description   = %q{sms_broker}
+  gem.summary       = %q{Sms Broker}
+  gem.homepage      = 'https://github.com/streetbees/sms_broker'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency 'nexmo', '~> 4.2'
+  gem.add_runtime_dependency 'compel', '~> 0.5'
+  gem.add_runtime_dependency 'twilio-ruby', '~> 4.11'
+
+  gem.add_development_dependency 'webmock', '~> 2.0'
+  gem.add_development_dependency 'rspec', '~> 3.2'
+  gem.add_development_dependency 'rake', '~> 0'
+  gem.add_development_dependency 'pry', '~> 0'
+end

data/spec/sms_broker/nexmo_spec.rb

@@ -0,0 +1,92 @@
+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
+
+      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']
+          end
+
+          stub_nexmo_create_message_success(sender_id, to_phone, text_message)
+
+          response = SmsBroker.message(text_message).to(to_phone).deliver
+
+          expect(response.service).to eq(:nexmo)
+          expect(response.success?).to eq(true)
+          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
+
+            stub_nexmo_create_message_invalid_sender_id_request \
+              sender_id, to_phone, text_message
+
+            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
+
+      end
+
+      context 'invalid' do
+
+        it 'should return error for invalid credentials' do
+          SmsBroker.setup do |config|
+            config.nexmo_setup \
+              phone_number: from_phone,
+              secret: 'invalid',
+              key: 'invalid'
+          end
+
+          stub_nexmo_create_message_invalid_credentials \
+            from_phone, to_phone, text_message
+
+          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/setup_spec.rb

@@ -0,0 +1,161 @@
+describe SmsBroker do
+
+  context 'Setup' do
+
+    before(:each) do
+      SmsBroker.clear_setup
+    end
+
+    it 'should set configs' do
+      setup = \
+        SmsBroker.setup do |config|
+          config.services ['nexmo', 'twilio']
+
+          config.default_service 'nexmo'
+
+          config.nexmo_setup \
+            key: 'NEXMO_API_KEY',
+            phone_number: 'phone',
+            secret: 'NEXMO_API_KEY'
+
+          config.twilio_setup \
+            phone_number: 'phone',
+            account_sid: 'TWILIO_ACCOUNT_SID',
+            auth_token: 'TWILIO_AUTH_TOKEN'
+        end
+
+      expect(setup.valid?).to eq(true)
+
+      expect(setup.options[:services]).to \
+        eq(['nexmo', 'twilio'])
+
+      expect(setup.options[:default_service]).to \
+        eq('nexmo')
+
+      expect(setup.options[:services_setups][:nexmo]).to \
+        eq \
+          key: 'NEXMO_API_KEY',
+          secret: 'NEXMO_API_KEY',
+          phone_number: 'phone'
+
+      expect(setup.options[:services_setups][:twilio]).to \
+        eq \
+          phone_number: 'phone',
+          account_sid: 'TWILIO_ACCOUNT_SID',
+          auth_token: 'TWILIO_AUTH_TOKEN'
+    end
+
+    context 'valid configs' do
+
+      before(:each) do
+        SmsBroker.setup do |config|
+          config.services ['nexmo', 'twilio']
+
+          config.default_service 'nexmo'
+
+          config.nexmo_setup \
+            key: 'NEXMO_API_KEY',
+            phone_number: 'phone',
+            secret: 'NEXMO_API_KEY'
+
+          config.twilio_setup \
+            phone_number: 'phone',
+            account_sid: 'TWILIO_ACCOUNT_SID',
+            auth_token: 'TWILIO_AUTH_TOKEN'
+        end
+      end
+
+      it 'should get default Service' do
+        service = SmsBroker.service
+
+        expect(service.client).to be_a SmsBroker::Client::Nexmo
+      end
+
+      it 'should get custom Service' do
+        service = SmsBroker.service(:twilio)
+
+        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.default_service 'nexmo'
+        end
+
+        expect(setup.valid?).to eq(false)
+        expect(setup.errors).to eq \
+          services_setups: [
+            'all services must be setup'
+          ]
+      end
+
+      it 'should return error for not having services' do
+        setup = SmsBroker.setup do |config|
+          config.services []
+        end
+
+        expect(setup.valid?).to eq(false)
+
+        expect(setup.errors[:services]).to \
+          include('cannot have length less than 1')
+      end
+
+      it 'should return error default_service' do
+        setup = SmsBroker.setup do |config|
+          config.services ['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\"]")
+      end
+
+      context 'setup!' do
+
+        it 'should raise exception for invalid setup' do
+          expect {
+            SmsBroker.setup! do |config|
+              config.services ['nexmo', 'twilio']
+              config.default_service 'nope'
+            end
+          }.to raise_error(SmsBroker::Exceptions::InvalidSetup)
+        end
+
+        it 'should return error for missing required service setup' do
+          expect {
+            SmsBroker.setup! do |config|
+              config.default_service 'nexmo'
+
+              config.nexmo_setup \
+                not_exists: 'key'
+            end
+          }.to raise_error(SmsBroker::Exceptions::InvalidSetup)
+        end
+
+      end
+
+    end
+
+  end
+
+  it 'should respond_to :message' do
+    expect(SmsBroker.respond_to?(:message)).to eq(true)
+  end
+
+  it 'should raise InvalidSetup for service not being setup' do
+    SmsBroker.clear_setup
+
+    expect{ SmsBroker::Service.get(:twilio) }.to \
+      raise_error SmsBroker::Exceptions::InvalidSetup
+  end
+
+end

data/spec/sms_broker/sms_broker_spec.rb

@@ -0,0 +1,145 @@
+describe SmsBroker do
+
+  context 'SmsBroker' do
+
+    let(:text_message) { 'Hello World' }
+
+    context 'Invalid data when trying to deliver' do
+
+      before(:all) 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']
+        end
+      end
+
+      it 'should return error for missing number' 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")
+      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")
+      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"
+
+        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")
+      end
+
+    end
+
+    context 'Invalid setup when trying to deliver' do
+
+      before(:all) do
+        SmsBroker.clear_setup
+
+        @setu = 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']
+        end
+      end
+
+      it 'should return error for missing number' do
+        expect {
+          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
+
+      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

@@ -0,0 +1,122 @@
+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'] }
+
+      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
+      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']
+          end
+
+          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)
+        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']
+            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")
+          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']
+          end
+
+          response = SmsBroker.message(text_message).deliver
+
+          expect(response.serialized[:errors][:to]).to include('is required')
+        end
+
+        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']
+          end
+
+          response = send_message(text_message, '15005550006')
+
+          expect(response.success?).to eq(false)
+          expect(response.serialized.length).to be > 0
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'pry'
+require 'yaml'
+require 'simplecov'
+require 'codeclimate-test-reporter'
+
+SimpleCov.start do
+  formatter SimpleCov::Formatter::MultiFormatter.new [
+    SimpleCov::Formatter::HTMLFormatter,
+    CodeClimate::TestReporter::Formatter
+  ]
+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