sms77 0.0.1 → 0.4.0

data/spec/sms77/hooks_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'sms77/hooks'
+require 'sms77/util'
+require 'sms77/resources/hooks'
+require 'spec_helper'
+
+RSpec.describe Sms77, 'hooks' do
+  HOOK_ID = EnvKeyStore.new('HOOK_ID')
+  HELPER = Helper.new(Sms77::Resources::Hooks)
+
+  def alter_action_stub
+    {
+      :code => nil,
+      :success => true
+    }
+  end
+
+  def request(fn, stub, extra_params = {})
+    res = HELPER.request(fn, stub, 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(HELPER.resource.method(: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
+    })
+
+    expect(res).to include(:code, :hooks, :success)
+    expect(res[:code]).to eq(nil)
+    expect(res[:hooks]).to be_a(Array)
+    expect(res[:success]).to be_boolean
+
+    res[:hooks].each do |hook|
+      expect(hook).to include(:created, :event_type, :id, :request_method, :target_url)
+
+      expect(Sms77::Util::is_valid_datetime?(hook[:created])).to be
+      expect(hook[:created]).to match(/^\d\d\d\d-(0?[1-9]|1[0-2])-(0?[1-9]|[12][0-9]|3[01]) (1[0-9]|2[0-3]|0[0-9]):([0-9]|[0-5][0-9]):([0-9]|[0-5][0-9])$/)
+      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
+
+=begin
+  it 'subscribes' do
+    stub = alter_action_stub.merge({ :id => rand(1...1000000) })
+
+    res = request(HELPER.resource.method(: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(HELPER.resource.method(:unubscribe), alter_action_stub, { :id => id })
+
+    assert_alter_response(res)
+
+    expect(res[:success]).to be_boolean
+
+    puts "Unsubscribed ID #{id}: #{res[:success]}"
+
+    res[:success]
+  end
+=end
+
+  def assert_alter_response(res)
+    expect(res[:code]).to match(nil)
+    expect(res[:success]).to be_boolean
+  end
+end

data/spec/sms77/instance_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'sms77/resource'
+
+RSpec.describe Sms77, 'instance' do
+  helper = Helper.new(Sms77::Resource)
+
+  it 'checks api key' do
+    expect(helper.resource.api_key).to be_lengthy_string
+  end
+
+  it 'checks sentWith' do
+    expect(helper.resource.sent_with).to be_lengthy_string
+  end
+
+  it 'fails authentication' do
+    expect { Sms77::Resource.new('') }.to raise_error(RuntimeError)
+  end
+end

data/spec/sms77/journal_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'sms77/journal'
+require 'sms77/resources/journal'
+require 'sms77/sms'
+
+RSpec.describe Sms77, 'journal' do
+  def valid_timestamp?(str)
+    str.match(/[\d]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][\d]|3[0-1]) (2[0-3]|[01][\d]):[0-5][\d]/)
+  end
+
+  def request(type)
+    stub = [{
+              :from => "SMS",
+              :id => "123456789",
+              :price => "1.2",
+              :text => "Hey my friend!",
+              :timestamp => "2020-10-14 14:25:04",
+              :to => "49170123456789",
+            }]
+
+    helper = Helper.new(Sms77::Resources::Journal)
+    res = helper.request(helper.resource.method(:retrieve), stub, { type: type })
+
+    expect(res).to be_a(Array)
+
+    res.each do |journal|
+      expect(journal).to be_a(Hash)
+      expect(journal[:from]).to be_lengthy_string
+      expect(journal[:id]).to be_numeric
+      expect(Sms77::Util::valid_float?(journal[:price])).to be_truthy
+      expect(journal[:text]).to be_lengthy_string
+      expect(valid_timestamp?(journal[:timestamp])).to be_truthy
+      expect(journal[:to]).to be_lengthy_string
+    end
+
+    res
+  end
+
+  it 'returns all inbound messages' do
+    request(Sms77::Journal::Type::INBOUND)
+  end
+
+  it 'returns all outbound messages' do
+    request(Sms77::Journal::Type::OUTBOUND).each do |journal|
+      journal.merge!({
+                       :connection => "http",
+                       :dlr => "DELIVERED",
+                       :dlr_timestamp => "2020-10-04 09:26:10.000",
+                       :foreign_id => "MyForeignId",
+                       :label => "MyCustomLabel",
+                       :latency => "5.1060",
+                       :mccmnc => "26207",
+                       :type => "direct",
+                     })
+      expect(journal[:connection]).to be_lengthy_string
+      expect(journal[:dlr]).to be_nil_or_lengthy_string
+      expect(valid_timestamp?(journal[:dlr_timestamp])).to be_truthy
+      expect(journal[:foreign_id]).to be_nil_or_lengthy_string
+      expect(journal[:label]).to be_nil_or_lengthy_string
+      expect(journal[:latency]).to be_nil_or_lengthy_string
+      expect(journal[:mccmnc]).to be_nil_or_lengthy_string
+      expect(Sms77::Util::in_module_constants?(journal[:type], Sms77::Sms::Type)).to be_truthy
+    end
+  end
+
+  it 'returns all voice messages' do
+    request(Sms77::Journal::Type::VOICE).each do |journal|
+      journal.merge!({
+                       :duration => "2",
+                       :error => "",
+                       :status => "completed",
+                       :xml => false,
+                     })
+      expect(journal[:duration]).to be_numeric
+      expect(journal[:error]).to be_nil_or_lengthy_string
+      expect(journal[:status]).to be_lengthy_string
+      expect(journal[:xml]).to be_boolean
+    end
+  end
+
+  it 'returns all reply messages' do
+    request(Sms77::Journal::Type::REPLIES)
+  end
+end

data/spec/sms77/lookup_spec.rb

@@ -2,26 +2,17 @@
 
 require 'spec_helper'
 require 'sms77/endpoint'
-require 'sms77/lookup_type'
+require 'sms77/lookup'
+require 'sms77/resources/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 = Helper.new(Sms77::Resources::Lookup)
+    helper.request(
+      helper.resource.method(type),
+      stub,
+      { number: '+491771783130' }.merge(extra_args))
   end
 
   it 'misses number to lookup' do
@@ -37,10 +28,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 +47,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 +68,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 +98,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 +146,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

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-require 'sms77/endpoint'
-require 'json'
+require 'sms77/resources/pricing'
 
 RSpec.describe Sms77, 'pricing' do
   it 'returns all countries pricing as json' do
@@ -36,44 +35,41 @@ RSpec.describe Sms77, 'pricing' do
       ]
     }
 
-    Helper.stubs.get("/api/#{Sms77::Endpoint::PRICING}") { |_env| [200, {}, JSON.generate(stub)] } unless Helper.is_http
+    helper = Helper.new(Sms77::Resources::Pricing)
+    res = helper.request(helper.resource.method(:retrieve), 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