sms77 0.0.2 → 0.1.0

data/spec/sms77/hooks_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'sms77/hooks'
+require 'sms77/util'
+require 'spec_helper'
+
+RSpec.describe Sms77, 'hooks' do
+  HOOK_ID = EnvKeyStore.new('HOOK_ID')
+
+  def alter_action_stub
+    {
+      :code => nil,
+      :success => true
+    }
+  end
+
+  def request(action, stub, extra_params = {})
+    res = Helper.method(Sms77::Hooks::Action::READ == action ? :get : :post)
+                .call(Sms77::Endpoint::HOOKS, stub, { action: action }.merge(extra_params))
+
+    expect(res).to be_a(Hash)
+
+    stub_keys = stub.keys
+    res.each do |k, v|
+      expect(stub_keys).to include(k)
+      expect(v.class).to match(stub[:"#{k}"].class)
+    end
+
+    res
+  end
+
+  it 'returns all hooks' do
+    res = request(Sms77::Hooks::Action::READ, {
+      :code => nil,
+      :hooks => [
+        {
+          :created => "2020-11-04 23:04:15",
+          :event_type => "sms_mo",
+          :id => "30",
+          :request_method => "GET",
+          :target_url => "http://my.tld/testHook"
+        }
+      ],
+      :success => true
+    })
+
+    res[:hooks].each do |hook|
+      expect(Sms77::Util::is_valid_datetime?(hook[:created])).to be
+      expect(hook[:created] =~ /^\d\d\d\d-(0?[1-9]|1[0-2])-(0?[1-9]|[12][0-9]|3[01]) (00|[0-9]|1[0-9]|2[0-3]):([0-9]|[0-5][0-9]):([0-9]|[0-5][0-9])$/).to be
+      expect(Sms77::Hooks::Validator::event_type?(hook[:event_type])).to be
+      expect(Sms77::Util::is_positive_integer?(hook[:id])).to be
+      expect(Sms77::Hooks::Validator::request_method?(hook[:request_method])).to be
+      expect(Sms77::Hooks::Validator::target_url?(hook[:target_url])).to be
+    end
+  end
+
+  it 'subscribes' do
+    stub = alter_action_stub.merge({ :id => rand(1...1000000) })
+
+    res = request(Sms77::Hooks::Action::SUBSCRIBE, stub, {
+      :event_type => Sms77::Hooks::EventType::NEW_INBOUND_SMS,
+      :request_method => Sms77::Hooks::RequestMethod::GET,
+      :target_url => "http://ruby.tld/#{SecureRandom.uuid}"
+    })
+
+    expect(Sms77::Util::is_positive_integer?(res[:id])).to be
+    expect(res[:id]).to be_a(Integer)
+    expect(stub[:id]).to match(res[:id]) unless Helper.is_http
+
+    assert_alter_response(res)
+
+    puts "Subscribed ID: #{Helper.is_http ? res[:id] : stub[:id]}"
+
+    HOOK_ID.set(res[:id])
+  end
+
+  it 'unsubscribes' do
+    id = HOOK_ID.get
+    res = request(Sms77::Hooks::Action::UNSUBSCRIBE, alter_action_stub, { :id => id })
+
+    assert_alter_response(res)
+
+    expect(res[:success]).to be_boolean
+
+    puts "Unsubscribed ID #{id}: #{res[:success]}"
+
+    res[:success]
+  end
+
+  def assert_alter_response(res)
+    expect(res[:code]).to match(nil)
+    expect(res[:success]).to be_boolean
+  end
+end

data/spec/sms77/lookup_spec.rb

@@ -2,26 +2,12 @@
 
 require 'spec_helper'
 require 'sms77/endpoint'
-require 'sms77/lookup_type'
+require 'sms77/lookup'
 require 'json'
 
 RSpec.describe Sms77, 'lookup' do
   def request(type, stub, extra_args = {})
-    Helper.stubs.get("/api/#{Sms77::Endpoint::LOOKUP}") { |_env| [200, {}, JSON.generate(stub)] } unless Helper.is_http
-
-    response = Helper.client.lookup({ type: type, number: '+491771783130' }.merge(extra_args))
-
-    expect(response.class).to eq(Faraday::Response)
-
-    body = response.body
-
-    begin
-      body = JSON.parse(body)
-    rescue StandardError
-      # Ignored
-    end
-
-    body
+    Helper.post(Sms77::Endpoint::LOOKUP, stub, { type: type, number: '+491771783130' }.merge(extra_args))
   end
 
   it 'misses number to lookup' do
@@ -37,10 +23,10 @@ RSpec.describe Sms77, 'lookup' do
       success: false
     }
 
-    body = request(Sms77::LookupType::FORMAT, stub, { number: '' })
+    res = request(Sms77::Lookup::Type::FORMAT, stub, { number: '' })
 
-    expect(body).to be_kind_of(Hash)
-    expect(body['success']).to match(false)
+    expect(res).to be_a(Hash)
+    expect(res[:success]).to match(false)
   end
 
   it 'returns number formatting details as json' do
@@ -56,18 +42,18 @@ RSpec.describe Sms77, 'lookup' do
       success: true
     }
 
-    body = request(Sms77::LookupType::FORMAT, stub)
-
-    expect(body).to be_kind_of(Hash)
-    expect(body['carrier']).to be_kind_of(String)
-    expect(body['country_code']).to be_kind_of(String)
-    expect(body['country_iso']).to be_kind_of(String)
-    expect(body['country_name']).to be_kind_of(String)
-    expect(body['international']).to be_kind_of(String)
-    expect(body['international_formatted']).to be_kind_of(String)
-    expect(body['national']).to be_kind_of(String)
-    expect(body['network_type']).to be_kind_of(String)
-    expect(body['success']).to be_boolean
+    body = request(Sms77::Lookup::Type::FORMAT, stub)
+
+    expect(body).to be_a(Hash)
+    expect(body[:carrier]).to be_a(String)
+    expect(body[:country_code]).to be_a(String)
+    expect(body[:country_iso]).to be_a(String)
+    expect(body[:country_name]).to be_a(String)
+    expect(body[:international]).to be_a(String)
+    expect(body[:international_formatted]).to be_a(String)
+    expect(body[:national]).to be_a(String)
+    expect(body[:network_type]).to be_a(String)
+    expect(body[:success]).to be_boolean
   end
 
   it 'returns CNAM details as json' do
@@ -77,19 +63,19 @@ RSpec.describe Sms77, 'lookup' do
       number: '+491771783130',
       success: 'true'
     }
-    body = request(Sms77::LookupType::CNAM, stub)
+    body = request(Sms77::Lookup::Type::CNAM, stub)
 
-    expect(body).to be_kind_of(Hash)
-    expect(body['code']).to be_kind_of(String)
-    expect(body['name']).to be_kind_of(String)
-    expect(body['number']).to be_kind_of(String)
-    expect(body['success']).to be_kind_of(String)
+    expect(body).to be_a(Hash)
+    expect(body[:code]).to be_a(String)
+    expect(body[:name]).to be_a(String)
+    expect(body[:number]).to be_a(String)
+    expect(body[:success]).to be_a(String)
   end
 
   it 'returns MNP details as text' do
-    body = request(Sms77::LookupType::MNP, 'eplus')
+    body = request(Sms77::Lookup::Type::MNP, 'eplus')
 
-    expect(body).to be_kind_of(String)
+    expect(body).to be_a(String)
   end
 
   it 'returns MNP details as json' do
@@ -107,20 +93,20 @@ RSpec.describe Sms77, 'lookup' do
       price: 0.005,
       success: true
     }
-    body = request(Sms77::LookupType::MNP, stub, { json: 1 })
-
-    expect(body).to be_kind_of(Hash)
-    expect(body['code']).to be_kind_of(Integer)
-    expect(body['price']).to be_kind_of(Float)
-    expect(body['mnp']).to be_kind_of(Hash)
-    expect(body['mnp']['country']).to be_kind_of(String)
-    expect(body['mnp']['international_formatted']).to be_kind_of(String)
-    expect(body['mnp']['isPorted']).to be_boolean
-    expect(body['mnp']['mccmnc']).to be_kind_of(String)
-    expect(body['mnp']['national_format']).to be_kind_of(String)
-    expect(body['mnp']['network']).to be_kind_of(String)
-    expect(body['mnp']['number']).to be_kind_of(String)
-    expect(body['success']).to be_boolean
+    body = request(Sms77::Lookup::Type::MNP, stub, { json: 1 })
+
+    expect(body).to be_a(Hash)
+    expect(body[:code]).to be_a(Integer)
+    expect(body[:price]).to be_a(Float)
+    expect(body[:mnp]).to be_a(Hash)
+    expect(body[:mnp][:country]).to be_a(String)
+    expect(body[:mnp][:international_formatted]).to be_a(String)
+    expect(body[:mnp][:isPorted]).to be_boolean
+    expect(body[:mnp][:mccmnc]).to be_a(String)
+    expect(body[:mnp][:national_format]).to be_a(String)
+    expect(body[:mnp][:network]).to be_a(String)
+    expect(body[:mnp][:number]).to be_a(String)
+    expect(body[:success]).to be_boolean
   end
 
   it 'returns HLR details as json' do
@@ -155,34 +141,34 @@ RSpec.describe Sms77, 'lookup' do
       valid_number: 'valid'
     }
 
-    body = request(Sms77::LookupType::HLR, stub)
-
-    expect(body).to be_kind_of(Hash)
-    expect(body['country_code']).to be_kind_of(String)
-    expect(body['country_name']).to be_kind_of(String)
-    expect(body['country_prefix']).to be_kind_of(String)
-    expect(body['current_carrier']).to be_kind_of(Hash)
-    expect(body['current_carrier']['country']).to be_kind_of(String)
-    expect(body['current_carrier']['name']).to be_kind_of(String)
-    expect(body['current_carrier']['network_code']).to be_kind_of(String)
-    expect(body['current_carrier']['network_type']).to be_kind_of(String)
-    expect(body['international_format_number']).to be_kind_of(String)
-    expect(body['international_formatted']).to be_kind_of(String)
-    expect(body['lookup_outcome']).to be_boolean
-    expect(body['lookup_outcome_message']).to be_kind_of(String)
-    expect(body['national_format_number']).to be_kind_of(String)
-    expect(body['original_carrier']).to be_kind_of(Hash)
-    expect(body['original_carrier']['country']).to be_kind_of(String)
-    expect(body['original_carrier']['name']).to be_kind_of(String)
-    expect(body['original_carrier']['network_code']).to be_kind_of(String)
-    expect(body['original_carrier']['network_type']).to be_kind_of(String)
-    expect(body['status']).to be_boolean
-    expect(body['status_message']).to be_kind_of(String)
-    expect(body['gsm_code']).to be_kind_of(String)
-    expect(body['gsm_message']).to be_kind_of(String)
-    expect(body['ported']).to be_kind_of(String)
-    expect(body['reachable']).to be_kind_of(String)
-    expect(body['roaming']).to be_kind_of(String)
-    expect(body['valid_number']).to be_kind_of(String)
+    body = request(Sms77::Lookup::Type::HLR, stub)
+
+    expect(body).to be_a(Hash)
+    expect(body[:country_code]).to be_a(String)
+    expect(body[:country_name]).to be_a(String)
+    expect(body[:country_prefix]).to be_a(String)
+    assert_carrier(body[:current_carrier])
+    expect(body[:international_format_number]).to be_a(String)
+    expect(body[:international_formatted]).to be_a(String)
+    expect(body[:lookup_outcome]).to be_boolean
+    expect(body[:lookup_outcome_message]).to be_a(String)
+    expect(body[:national_format_number]).to be_a(String)
+    assert_carrier(body[:original_carrier])
+    expect(body[:status]).to be_boolean
+    expect(body[:status_message]).to be_a(String)
+    expect(body[:gsm_code]).to be_a(String)
+    expect(body[:gsm_message]).to be_a(String)
+    expect(body[:ported]).to be_a(String)
+    expect(body[:reachable]).to be_a(String)
+    expect(body[:roaming]).to be_a(String)
+    expect(body[:valid_number]).to be_a(String)
+  end
+
+  def assert_carrier(hash)
+    expect(hash).to be_a(Hash)
+    expect(hash[:country]).to be_a(String)
+    expect(hash[:name]).to be_a(String)
+    expect(hash[:network_code]).to be_a(String)
+    expect(hash[:network_type]).to be_a(String)
   end
 end

data/spec/sms77/pricing_spec.rb

@@ -36,44 +36,40 @@ RSpec.describe Sms77, 'pricing' do
       ]
     }
 
-    Helper.stubs.get("/api/#{Sms77::Endpoint::PRICING}") { |_env| [200, {}, JSON.generate(stub)] } unless Helper.is_http
+    res = Helper.get(Sms77::Endpoint::PRICING, stub)
+    countries = res[:countries]
 
-    response = Helper.client.pricing
-    body = JSON.parse(response.body)
-    countries = body['countries']
-
-    expect(response.class).to eq(Faraday::Response)
-    expect(body).to be_kind_of(Hash)
-    expect(body['countCountries']).to be_kind_of(Integer)
-    expect(body['countNetworks']).to be_kind_of(Integer)
-    expect(countries).to be_kind_of(Array)
+    expect(res).to be_a(Hash)
+    expect(res[:countCountries]).to be_a(Integer)
+    expect(res[:countNetworks]).to be_a(Integer)
+    expect(countries).to be_a(Array)
 
     countries.each do |country|
-      networks = country['networks']
+      networks = country[:networks]
 
-      expect(country).to be_kind_of(Hash)
-      expect(country['countryCode']).to be_kind_of(String)
-      expect(country['countryName']).to be_kind_of(String)
-      expect(country['countryPrefix']).to be_kind_of(String)
-      expect(networks).to be_kind_of(Array)
+      expect(country).to be_a(Hash)
+      expect(country[:countryCode]).to be_a(String)
+      expect(country[:countryName]).to be_a(String)
+      expect(country[:countryPrefix]).to be_a(String)
+      expect(networks).to be_a(Array)
 
       networks.each do |network|
-        mncs = network['mncs']
-        features = network['features']
+        mncs = network[:mncs]
+        features = network[:features]
 
-        expect(network).to be_kind_of(Hash)
-        expect(network['mcc']).to be_kind_of(String)
-        expect(mncs).to be_kind_of(Array)
+        expect(network).to be_a(Hash)
+        expect(network[:mcc]).to be_a(String)
+        expect(mncs).to be_a(Array)
         mncs.each do |mnc|
-          expect(mnc).to be_kind_of(String)
+          expect(mnc).to be_a(String)
         end
-        expect(network['networkName']).to be_kind_of(String)
-        expect(network['price']).to be_kind_of(Float)
-        expect(features).to be_kind_of(Array)
+        expect(network[:networkName]).to be_a(String)
+        expect(network[:price]).to be_a(Float)
+        expect(features).to be_a(Array)
         features.each do |feature|
-          expect(feature).to be_kind_of(String)
+          expect(feature).to be_a(String)
         end
-        expect(network['comment']).to be_kind_of(String)
+        expect(network[:comment]).to be_a(String)
       end
     end
   end

data/spec/sms77/sms_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 require 'sms77/endpoint'
-require 'sms77/contacts_action'
+require 'sms77/contacts'
 
 RSpec.describe Sms77, 'sms' do
   $text = 'Your glasses are ready for pickup.'
@@ -28,11 +28,11 @@ RSpec.describe Sms77, 'sms' do
       to: Helper.virtual_inbound_nr_eplus
     }.merge(extra_params)
 
-    Helper.request(Sms77::Endpoint::SMS, params, stub)
+    Helper.post(Sms77::Endpoint::SMS, stub, params)
   end
 
   it 'sends a single sms and returns success code' do
-    expect(request(100)).to be_kind_of(Integer)
+    expect(request(100)).to be_a(Integer)
   end
 
   it 'sends a single sms and returns detailed text response' do
@@ -51,14 +51,14 @@ RSpec.describe Sms77, 'sms' do
 
     body = request(stub, { details: 1 })
 
-    expect(body).to be_kind_of(String)
+    expect(body).to be_a(String)
 
     code, booked, cost, balance, text, type, flash, encoding, gsm0338, debug = body.split("\n")
 
-    expect(code).to be_kind_of(String)
-    expect(booked.split(':').last.to_f).to be_kind_of(Float)
-    expect(cost.split(':').last.to_f).to be_kind_of(Float)
-    expect(balance.split(':').last.to_f).to be_kind_of(Float)
+    expect(code).to be_a(String)
+    expect(booked.split(':').last.to_f).to be_a(Float)
+    expect(cost.split(':').last.to_f).to be_a(Float)
+    expect(balance.split(':').last.to_f).to be_a(Float)
     expect(text.split(':').last.strip!).to eq($text)
     expect(type.split(':').last.strip!).to eq('direct')
     expect(flash.split(':').last.strip!).to eq('false')
@@ -88,16 +88,16 @@ RSpec.describe Sms77, 'sms' do
 
     body = request(stub, { json: 1 })
 
-    expect(body).to be_kind_of(Hash)
+    expect(body).to be_a(Hash)
 
-    expect(body['success']).to be_kind_of(String)
-    expect(body['total_price']).to be_numeric
-    expect(body['balance']).to be_kind_of(Float)
-    expect(body['debug']).to be_kind_of(String)
-    expect(body['sms_type']).to eq('direct')
-    expect(body['messages']).to be_kind_of(Array)
-    body['messages'].each do |message|
-      expect(message).to be_kind_of(Hash)
+    expect(body[:success]).to be_a(String)
+    expect(body[:total_price]).to be_numeric
+    expect(body[:balance]).to be_a(Float)
+    expect(body[:debug]).to be_a(String)
+    expect(body[:sms_type]).to eq('direct')
+    expect(body[:messages]).to be_a(Array)
+    body[:messages].each do |message|
+      expect(message).to be_a(Hash)
     end
   end
 end

data/spec/sms77/validate_for_voice_spec.rb

@@ -11,9 +11,9 @@ RSpec.describe Sms77, 'validate_for_voice' do
     callback = "#{callback_host}/callback.php"
     stub = { success: true }
 
-    body = Helper.request(Sms77::Endpoint::VALIDATE_FOR_VOICE, { number: number, callback: callback }, stub)
+    body = Helper.post(Sms77::Endpoint::VALIDATE_FOR_VOICE, stub, { number: number, callback: callback })
 
-    expect(body).to be_kind_of(Hash)
-    expect(body['success']).to be_boolean
+    expect(body).to be_a(Hash)
+    expect(body[:success]).to be_boolean
   end
 end

data/spec/sms77/voice_spec.rb

@@ -2,11 +2,11 @@
 
 require 'spec_helper'
 require 'sms77/endpoint'
-require 'sms77/contacts_action'
+require 'sms77/contacts'
 
 RSpec.describe Sms77, 'voice' do
   def assert_response(response)
-    expect(response).to be_kind_of(String)
+    expect(response).to be_a(String)
 
     code, id, cost = response.split("\n")
 
@@ -22,10 +22,13 @@ RSpec.describe Sms77, 'voice' do
       0.1
     TEXT
 
-    params = { to: Helper.virtual_inbound_nr_eplus, text: text, from: Helper.virtual_inbound_nr_eplus }
-               .merge(extra_params)
+    params = {
+      from: Helper.virtual_inbound_nr_eplus,
+      text: text,
+      to: Helper.virtual_inbound_nr_eplus
+    }.merge(extra_params)
 
-    Helper.request(Sms77::Endpoint::VOICE, params, stub)
+    Helper.post(Sms77::Endpoint::VOICE, stub, params)
   end
 
   it 'calls a number with text input' do