locasms 0.4.0 → 0.5.0

data/lib/locasms/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module LocaSMS
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/locasms.gemspec

@@ -1,39 +1,44 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'locasms/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "locasms"
+  spec.name          = 'locasms'
   spec.version       = LocaSMS::VERSION
-  spec.authors       = ["Adilson Carvalho", "Leonardo Saraiva", "Marco Carvalho"]
-  spec.email         = ["lc.adilson@gmail.com", "vyper@maneh.org", "marco.carvalho.swasthya@gmail.com"]
-  spec.description   = %q{Cliente para o serviço de disparo de SMS da LocaSMS e de sua
-                          versão para Short Code SMS (SMS Plataforma)}
-  spec.summary       = %q{Cliente para disparo de SMS, regular e Short Code, através da LocaSMS/SMS Plataforma}
-  spec.homepage      = "https://github.com/mcorp/locasms"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
+  spec.authors       = ['Adilson Carvalho', 'Leonardo Saraiva', 'Marco Carvalho']
+  spec.email         = ['lc.adilson@gmail.com', 'vyper@maneh.org', 'marco.carvalho.swasthya@gmail.com']
+  spec.description   = 'Cliente para o serviço de disparo de SMS da LocaSMS e de sua
+                          versão para Short Code SMS (SMS Plataforma)'
+  spec.summary       = 'Cliente para disparo de SMS, regular e Short Code, através da LocaSMS/SMS Plataforma'
+  spec.homepage      = 'https://github.com/mcorp/locasms'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.required_ruby_version = '~> 2.0'
+  spec.required_ruby_version = '~> 2.4'
 
-  spec.add_dependency 'multi_json', '~> 1.0'
+  spec.add_dependency 'multi_json', '~> 1.13'
 
-  spec.add_development_dependency 'bundler',   '~> 1.15'
-  spec.add_development_dependency 'rake',      '~> 12.1'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake',      '~> 13.0'
 
   # test stuff
-  spec.add_development_dependency 'rspec',     '~> 3.6'
+  spec.add_development_dependency 'rspec',     '~> 3.9'
   spec.add_development_dependency 'timecop',   '~> 0.9'
 
   # for documentation
+  spec.add_development_dependency 'redcarpet', '~> 3.5'
   spec.add_development_dependency 'yard',      '~> 0.9'
-  spec.add_development_dependency 'redcarpet', '~> 3.4'
 
   # for code coverage
-  spec.add_development_dependency 'simplecov', '~> 0.15'
+  spec.add_development_dependency 'simplecov', '~> 0.18'
+
+  # for code quality
+  spec.add_development_dependency 'rubocop',       '~> 0.93'
+  spec.add_development_dependency 'rubocop-rspec', '~> 1.43'
 end

data/spec/lib/locasms/client_spec.rb

@@ -1,188 +1,148 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe LocaSMS::Client do
-  let(:rest_client) { 'rest_client mock' }
-  subject { LocaSMS::Client.new :login, :password, rest_client: rest_client, callback: nil }
+describe LocaSMS::Client do # rubocop:disable RSpec/FilePath
+  subject(:client) { described_class.new :login, :password, rest_client: rest_client, callback: nil }
+
+  let(:rest_client) { instance_double 'RestClient' }
+  let(:base_args) { { msg: 'given message', numbers: '11988889991,11988889992,11988889993' } }
+  let(:default_callback_args) { base_args.merge(url_callback: 'default') }
+  let(:some_callback_args) { base_args.merge(url_callback: 'something') }
 
   describe '::ENDPOINT' do
-    let(:domain) { LocaSMS::Client::DOMAIN }
+    let(:domain) { described_class::DOMAIN }
 
-    context 'When default' do
-      it 'Should return the default URL' do
-        endpoint = LocaSMS::Client::ENDPOINT[subject.type]
+    context 'when default' do
+      it 'returns the default URL' do
+        endpoint = described_class::ENDPOINT[client.type]
         expect(endpoint).to eq("http://#{domain}/painel/api.ashx")
       end
     end
 
-    context 'When shortcode' do
-      subject { LocaSMS::Client.new :login, :password, type: :shortcode }
+    context 'when shortcode' do
+      subject(:client) { described_class.new :login, :password, type: :shortcode }
 
-      it 'Should return the short code URL' do
-        endpoint = LocaSMS::Client::ENDPOINT[subject.type]
+      it 'returns the short code URL' do
+        endpoint = described_class::ENDPOINT[client.type]
         expect(endpoint).to eq("http://#{domain}/shortcode/api.ashx")
       end
     end
   end
 
   describe '.initialize' do
-    it { expect(subject.login).to be(:login) }
-    it { expect(subject.password).to be(:password) }
+    it { expect(client.login).to be(:login) }
+    it { expect(client.password).to be(:password) }
   end
 
   describe '#deliver' do
-    it 'Should send SMS' do
-      expect(subject).to receive(:numbers)
-        .once
-        .with([:a, :b, :c])
-        .and_return('XXX')
-
-      expect(rest_client).to receive(:get)
-        .once
-        .with(:sendsms, msg: 'given message', numbers:'XXX', url_callback: nil)
-        .and_return({})
-
-      subject.deliver 'given message', :a, :b, :c
+    it 'sends SMS' do
+      allow(rest_client).to receive(:get).and_return({})
+
+      client.deliver 'given message', '11988889991', '11988889992', '11988889993'
+
+      expect(rest_client).to have_received(:get).once.with(:sendsms, base_args.merge(url_callback: nil))
     end
 
-    it 'Should not send SMS' do
-      expect(subject).to receive(:numbers)
-        .once
-        .with([:a, :b, :c])
-        .and_raise(LocaSMS::Exception)
+    context 'when receive an error' do
+      let(:wrong_deliver) { -> { client.deliver('given message', '1', '2', '3') } }
 
-      expect(rest_client).to receive(:get).never
+      it { expect(wrong_deliver).to raise_error(LocaSMS::Exception) }
 
-      expect { subject.deliver('given message', :a, :b, :c) }.to raise_error(LocaSMS::Exception)
+      it 'does not send SMS' do
+        allow(rest_client).to receive(:get)
+
+        wrong_deliver
+
+        expect(rest_client).not_to have_received(:get)
+      end
     end
 
-    context 'with callback option' do
-      context 'callback given as arg to #deliver' do
-        it 'uses specific callback' do
-          expect(subject).to receive(:numbers)
-            .once
-            .with([:a, :b, :c])
-            .and_return('XXX')
-
-          expect(rest_client).to receive(:get)
-            .once
-            .with(:sendsms, msg: 'given message', numbers:'XXX', url_callback: 'something')
-            .and_return({})
-
-          subject.deliver 'given message', :a, :b, :c, url_callback: 'something'
-        end
+    context 'when callback given as arg to #deliver' do
+      it 'uses specific callback' do
+        allow(rest_client).to receive(:get).and_return({})
+
+        client.deliver 'given message', '11988889991', '11988889992', '11988889993', url_callback: 'something'
+
+        expect(rest_client).to have_received(:get).once.with(:sendsms, some_callback_args)
       end
+    end
 
-      it 'uses default callback' do
-        client = LocaSMS::Client.new :login, :password, rest_client: rest_client, url_callback: 'default'
+    it 'uses default callback' do
+      client = described_class.new :login, :password, rest_client: rest_client, url_callback: 'default'
 
-        expect(client).to receive(:numbers)
-          .once
-          .with([:a, :b, :c])
-          .and_return('XXX')
+      allow(rest_client).to receive(:get).and_return({})
 
-        expect(rest_client).to receive(:get)
-          .once
-          .with(:sendsms, msg: 'given message', numbers:'XXX', url_callback: 'default')
-          .and_return({})
+      client.deliver 'given message', '11988889991', '11988889992', '11988889993'
 
-        client.deliver 'given message', :a, :b, :c
-      end
+      expect(rest_client).to have_received(:get).once.with(:sendsms, default_callback_args)
     end
   end
 
   describe '#deliver_at' do
-    it 'Should send SMS' do
-      expect(subject).to receive(:numbers)
-        .once
-        .with([:a, :b, :c])
-        .and_return('XXX')
-
-      expect(LocaSMS::Helpers::DateTimeHelper).to receive(:split)
-        .once
-        .with(:datetime)
-        .and_return(%w[date time])
-
-      expect(rest_client).to receive(:get)
-        .once
-        .with(:sendsms, msg: 'given message', numbers:'XXX', jobdate: 'date', jobtime: 'time', url_callback: nil)
-        .and_return({})
-
-      subject.deliver_at 'given message', :datetime, :a, :b, :c
+    let(:base_args) do
+      {
+        msg: 'given message',
+        numbers: '11988889991,11988889992,11988889993',
+        jobdate: '10/10/2020',
+        jobtime: '10:10'
+      }
     end
 
-    it 'Should not send SMS' do
-      expect(subject).to receive(:numbers)
-        .once
-        .with([:a, :b, :c])
-        .and_raise(LocaSMS::Exception)
+    it 'sends SMS' do
+      allow(rest_client).to receive(:get).and_return({})
 
-      expect(LocaSMS::Helpers::DateTimeHelper).to receive(:split)
-        .once
-        .with(:datetime)
-        .and_return(%w[date time])
+      client.deliver_at 'given message', '2020-10-10 10:10', '11988889991', '11988889992', '11988889993'
 
-      expect(rest_client).to receive(:get).never
+      expect(rest_client).to have_received(:get).once.with(:sendsms, base_args.merge(url_callback: nil))
+    end
+
+    context 'when receive an error' do
+      let(:wrong_deliver_at) { -> { client.deliver_at('given message', '2020-10-10 10:10', '1', '2', '3') } }
+
+      it { expect(wrong_deliver_at).to raise_error(LocaSMS::Exception) }
 
-      expect { subject.deliver_at('given message', :datetime, :a, :b, :c) }.to raise_error(LocaSMS::Exception)
+      it 'does not send SMS' do
+        allow(rest_client).to receive(:get)
+
+        wrong_deliver_at
+
+        expect(rest_client).not_to have_received(:get)
+      end
     end
 
     context 'with callback option' do
-      context 'callback given as arg to #deliver' do
-        it 'uses specific callback' do
-          expect(subject).to receive(:numbers)
-            .once
-            .with([:a, :b, :c])
-            .and_return('XXX')
-
-          expect(LocaSMS::Helpers::DateTimeHelper).to receive(:split)
-            .once
-            .with(:datetime)
-            .and_return(%w[date time])
-
-          expect(rest_client).to receive(:get)
-            .once
-            .with(:sendsms, msg: 'given message', numbers:'XXX', jobdate: 'date', jobtime: 'time', url_callback: 'something')
-            .and_return({})
-
-          subject.deliver_at 'given message', :datetime, :a, :b, :c, url_callback: 'something'
-        end
+      it 'when callback given as arg to #deliver' do
+        allow(rest_client).to receive(:get).and_return({})
+
+        client.deliver_at 'given message', '2020-10-10 10:10', '11988889991', '11988889992', '11988889993', url_callback: 'something'
+
+        expect(rest_client).to have_received(:get).once.with(:sendsms, some_callback_args)
       end
 
       it 'uses default callback' do
-        client = LocaSMS::Client.new :login, :password, rest_client: rest_client, url_callback: 'default'
-
-        expect(client).to receive(:numbers)
-          .once
-          .with([:a, :b, :c])
-          .and_return('XXX')
+        client = described_class.new :login, :password, rest_client: rest_client, url_callback: 'default'
 
-        expect(LocaSMS::Helpers::DateTimeHelper).to receive(:split)
-          .once
-          .with(:datetime)
-          .and_return(%w[date time])
+        allow(rest_client).to receive(:get).and_return({})
 
-        expect(rest_client).to receive(:get)
-          .once
-          .with(:sendsms, msg: 'given message', numbers:'XXX', jobdate: 'date', jobtime: 'time', url_callback: 'default')
-          .and_return({})
+        client.deliver_at 'given message', '2020-10-10 10:10', '11988889991', '11988889992', '11988889993'
 
-        client.deliver_at 'given message', :datetime, :a, :b, :c
+        expect(rest_client).to have_received(:get).once.with(:sendsms, default_callback_args)
       end
     end
   end
 
   describe '#balance' do
-    it 'Should check param assignment' do
-      expect(rest_client).to receive(:get)
-        .once
-        .with(:getbalance)
-        .and_return({})
+    it 'checks param assignment' do
+      allow(rest_client).to receive(:get).and_return({})
 
-      subject.balance
+      client.balance
+
+      expect(rest_client).to have_received(:get).once.with(:getbalance)
     end
   end
 
-  context 'Testing all campaign based methods' do
+  context 'when receive all campaign based methods' do
     def check_for(method)
       rest_method = {
         campaign_status: :getstatus,
@@ -190,19 +150,17 @@ describe LocaSMS::Client do
         campaign_release: :releasesms
       }[method]
 
-      expect(rest_client).to receive(:get)
-        .once
-        .with(rest_method, id: '12345')
-        .and_return({})
+      allow(rest_client).to receive(:get).and_return({})
+
+      client.send method, '12345'
 
-      subject.send method, '12345'
+      expect(rest_client).to have_received(:get).once.with(rest_method, id: '12345')
     end
 
-    it{ check_for :campaign_status  }
-    it{ check_for :campaign_hold    }
-    it{ check_for :campaign_release }
+    it { check_for :campaign_status  }
+    it { check_for :campaign_hold    }
+    it { check_for :campaign_release }
 
-    it 'Should have tests to cover campaign_status csv result'
+    it 'has tests to cover campaign_status csv result'
   end
-
 end

data/spec/lib/locasms/helpers/date_time_helper_spec.rb

@@ -1,50 +1,26 @@
-require 'spec_helper'
-
-describe LocaSMS::Helpers::DateTimeHelper do
-  subject { LocaSMS::Helpers::DateTimeHelper }
-
-  describe '#parse' do
-    it 'Should call the class method' do
-      expect(subject).to receive(:parse)
-        .once
-        .with(:value)
-
-      subject.new.parse(:value)
-    end
-  end
+# frozen_string_literal: true
 
-  describe '#split' do
-    it 'Should call the class method' do
-      expect(subject).to receive(:split)
-        .once
-        .with(:value)
+require 'spec_helper'
 
-      subject.new.split(:value)
-    end
-  end
+describe LocaSMS::Helpers::DateTimeHelper do # rubocop:disable RSpec/FilePath
+  subject(:helper) { described_class }
 
   describe '.parse' do
     let(:expected) { Time.parse '1977-03-14 14:12:00' }
 
     def try_for(value)
-      subject.parse(value) == expected
+      helper.parse(value) == expected
     end
 
     it { try_for DateTime.parse('1977-03-14 14:12:00') }
-    it { try_for Time.parse('1977-03-14 14:12:00')     }
-    it { try_for '1977-03-14 14:12:00'                 }
-    it { try_for 227207520                             }
+    it { try_for Time.parse('1977-03-14 14:12:00') }
+    it { try_for '1977-03-14 14:12:00' }
+    it { try_for 227_207_520 }
   end
 
   describe '.split' do
-    it 'Should break a date into date and time' do
-      expect(subject).to receive(:parse)
-        .once
-        .with(:datetime)
-        .and_return(Time.parse('1977-03-14 14:12:00'))
-
-      expect(subject.split(:datetime)).to eq(%w(14/03/1977 14:12))
+    it 'breaks a date into date and time' do
+      expect(helper.split('1977-03-14 14:12:00')).to eq(%w[14/03/1977 14:12])
     end
   end
-
-end
+end

data/spec/lib/locasms/numbers_spec.rb

@@ -1,106 +1,92 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe LocaSMS::Numbers do
-  subject { LocaSMS::Numbers.new }
-
-  describe '.initialize' do
-    subject do
-      expect_any_instance_of(LocaSMS::Numbers).
-        to receive(:evaluate).
-        once.
-        with([:numbers]).
-        and_return(good: [1, 3], bad: [2, 4])
-      LocaSMS::Numbers.new :numbers
-    end
+describe LocaSMS::Numbers do # rubocop:disable RSpec/FilePath
+  subject(:number_sanitizer) { described_class.new numbers }
 
-    it { expect(subject.good).to eq([1, 3]) }
-    it { expect(subject.bad).to eq([2, 4]) }
-  end
+  let(:numbers) { '1188889999' }
 
   describe '#normalize' do
-    it do 
-      expect(subject.normalize('+55 (11) 8888-9999')).to(
-        eq(%w(551188889999))
+    it do
+      expect(number_sanitizer.normalize('+55 (11) 8888-9999')).to(
+        eq(%w[551188889999])
       )
     end
+
     it do
-      expect(subject.normalize('55', ['11', '22'])).to(
-        eq(%w(55 11 22))
+      expect(number_sanitizer.normalize('55', %w[11 22])).to(
+        eq(%w[55 11 22])
       )
     end
+
     it do
-      expect(subject.normalize(['55', 'ZZ', '22'])).to(
-        eq(%w(55 ZZ 22))
+      expect(number_sanitizer.normalize(%w[55 ZZ 22])).to(
+        eq(%w[55 ZZ 22])
       )
     end
+
     it do
-      expect(subject.normalize('55,44,33', ['ZZ', '22,11'])).to(
-        eq(%w(55 44 33 ZZ 22 11))
+      expect(number_sanitizer.normalize('55,44,33', ['ZZ', '22,11'])).to(
+        eq(%w[55 44 33 ZZ 22 11])
       )
     end
-    it do 
-      expect(subject.normalize(55, [11, 22])).to(
-        eq(%w(55 11 22))
+
+    it do
+      expect(number_sanitizer.normalize(55, [11, 22])).to(
+        eq(%w[55 11 22])
       )
     end
-    it { expect(subject.normalize('Z')).to eq(['Z']) }
-    it { expect(subject.normalize(nil)).to eq([]) }
+
+    it { expect(number_sanitizer.normalize('Z')).to eq(['Z']) }
+    it { expect(number_sanitizer.normalize(nil)).to eq([]) }
   end
 
   describe '#valid_number?' do
-    it { expect(subject.valid_number?('+55 (11) 8888-9999')).to be_falsey }
-    it { expect(subject.valid_number?('88889999')).to be_falsey }
-    it { expect(subject.valid_number?('988889999')).to be_falsey }
-    it { expect(subject.valid_number?('ABC')).to be_falsey }
-    it { expect(subject.valid_number?('')).to be_falsey }
-    it { expect(subject.valid_number?(nil)).to be_falsey }
-
-    it { expect(subject.valid_number?('1188889999')).to be_truthy }
-    it { expect(subject.valid_number?('11988889999')).to be_truthy }
+    it { is_expected.not_to be_valid_number('+55 (11) 8888-9999') }
+    it { is_expected.not_to be_valid_number('88889999') }
+    it { is_expected.not_to be_valid_number('988889999') }
+    it { is_expected.not_to be_valid_number('ABC') }
+    it { is_expected.not_to be_valid_number('') }
+    it { is_expected.not_to be_valid_number(nil) }
+
+    it { is_expected.to be_valid_number('1188889999') }
+    it { is_expected.to be_valid_number('11988889999') }
   end
 
   describe '#evaluate' do
-    it 'Should separate numbers in good and bad' do
-      expect(subject).to receive(:normalize).
-        once.
-        with([:numbers]).
-        and_return([:good, :bad])
-      expect(subject).to receive(:valid_number?).
-        once.
-        with(:good).
-        and_return(true)
-      expect(subject).to receive(:valid_number?).
-        once.
-        with(:bad).
-        and_return(false)
-      expect(subject.evaluate(:numbers)).to(
-        eq(good: [:good], bad: [:bad])
-      )
+    it 'separates numbers in good and bad' do
+      expect(number_sanitizer.evaluate('11988889999', 'abc')).to eq(good: ['11988889999'], bad: ['abc'])
     end
   end
 
   describe '#bad?' do
-    it do
-      expect(subject).to receive(:bad).once.and_return([ ])
-      expect(subject.bad?).to be_falsey
+    subject(:number_sanitizer) { described_class.new numbers }
+
+    context 'when bad is empty' do
+      let(:numbers) { '11988889999' }
+
+      it { expect(number_sanitizer).not_to be_bad }
     end
-    it do
-      expect(subject).to receive(:bad).once.and_return([1])
-      expect(subject.bad?).to be_truthy
+
+    context 'when bad has items' do
+      let(:numbers) { 'ABC' }
+
+      it { expect(number_sanitizer).to be_bad }
     end
   end
 
   describe '#to_s' do
-    it 'Should return and empty string' do
-      expect(subject.to_s).to eq('')
+    context 'when is empty returns empty string' do
+      let(:numbers) { '' }
+
+      it { expect(number_sanitizer.to_s).to eq('') }
     end
 
-    it 'Should return all good numbers in a string comma separated' do
-      expect(subject).to receive(:good).
-        once.
-        and_return([1, 2, 3, 4])
-      expect(subject.to_s).to eq('1,2,3,4')
+    context 'when all good numbers returns in a string comma separated' do
+      let(:numbers) { %w[11988889991 11988889992 11988889993] }
+
+      it { expect(number_sanitizer.to_s).to eq('11988889991,11988889992,11988889993') }
     end
   end
-
 end