seven_api 0.5.0

data/spec/seven_api/lookup_spec.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'seven_api/endpoint'
+require 'seven_api/lookup'
+require 'seven_api/resources/lookup'
+require 'json'
+
+RSpec.describe SevenApi, 'lookup' do
+  def request(type, stub, extra_args = {})
+    helper = Helper.new(SevenApi::Resources::Lookup)
+    helper.request(
+      helper.resource.method(type),
+      stub,
+      { number: '+491771783130' }.merge(extra_args))
+  end
+
+  it 'misses number to lookup' do
+    stub = {
+      carrier: nil,
+      country_code: false,
+      country_iso: nil,
+      country_name: nil,
+      international: '+',
+      international_formatted: '',
+      national: '',
+      network_type: nil,
+      success: false
+    }
+
+    res = request(SevenApi::Lookup::Type::FORMAT, stub, { number: '' })
+
+    expect(res).to be_a(Hash)
+    expect(res[:success]).to match(false)
+  end
+
+  it 'returns number formatting details as json' do
+    stub = {
+      carrier: 'Eplus',
+      country_code: '49',
+      country_iso: 'DE',
+      country_name: 'Germany',
+      international: '+491771783130',
+      international_formatted: '+49 177 1783130',
+      national: '0177 1783130',
+      network_type: 'mobile',
+      success: true
+    }
+
+    body = request(SevenApi::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
+    stub = {
+      code: '100',
+      name: 'GERMANY',
+      number: '+491771783130',
+      success: 'true'
+    }
+    body = request(SevenApi::Lookup::Type::CNAM, stub)
+
+    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(SevenApi::Lookup::Type::MNP, 'eplus')
+
+    expect(body).to be_a(String)
+  end
+
+  it 'returns MNP details as json' do
+    stub = {
+      code: 100,
+      mnp: {
+        country: 'DE',
+        international_formatted: '+49 177 1783130',
+        isPorted: false,
+        mccmnc: '26203',
+        national_format: '0177 1783130',
+        network: "Telef\u00f3nica Germany GmbH & Co. oHG (O2)",
+        number: '+491771783130'
+      },
+      price: 0.005,
+      success: true
+    }
+    body = request(SevenApi::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
+    stub = {
+      country_code: 'DE',
+      country_name: 'Germany',
+      country_prefix: '49',
+      current_carrier: {
+        country: 'DE',
+        name: "Telef\u00f3nica Germany GmbH & Co. oHG (O2)",
+        network_code: '26203',
+        network_type: 'mobile'
+      },
+      international_format_number: '491771783130',
+      international_formatted: '+49 177 1783130',
+      lookup_outcome: true,
+      lookup_outcome_message: 'success',
+      national_format_number: '0177 1783130',
+      original_carrier: {
+        country: 'DE',
+        name: "Telef\u00f3nica Germany GmbH & Co. oHG (O2)",
+        network_code: '26203',
+        network_type: 'mobile'
+      },
+      status: true,
+      status_message: 'success',
+      gsm_code: '0',
+      gsm_message: 'No error',
+      ported: 'assumed_not_ported',
+      reachable: 'reachable',
+      roaming: 'not_roaming',
+      valid_number: 'valid'
+    }
+
+    body = request(SevenApi::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/seven_api/pricing_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'seven_api/resources/pricing'
+
+RSpec.describe SevenApi, 'pricing' do
+  it 'returns all countries pricing as json' do
+    stub = {
+      countCountries: 1,
+      countNetworks: 4,
+      countries: [
+        {
+          countryCode: 'AT',
+          countryName: 'Austria',
+          countryPrefix: '43',
+          networks: [
+            {
+              comment: '',
+              features: [],
+              mcc: '232',
+              mncs: ['02'],
+              networkName: 'A1 Telekom Austria',
+              price: 0.075
+            },
+            {
+              comment: '',
+              features: %w[alpha Numeric dlr sc],
+              mcc: '232',
+              mncs: ['01'],
+              networkName: 'A1 Telekom Austria (A1.net)',
+              price: 0.075
+            }
+          ]
+        }
+      ]
+    }
+
+    helper = Helper.new(SevenApi::Resources::Pricing)
+    res = helper.request(helper.resource.method(:retrieve), stub)
+    countries = res[:countries]
+
+    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]
+
+      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]
+
+        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_a(String)
+        end
+        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_a(String)
+        end
+        expect(network[:comment]).to be_a(String)
+      end
+    end
+  end
+end

data/spec/seven_api/sms_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'seven_api/resources/sms'
+
+RSpec.describe SevenApi, 'sms' do
+  $text = 'Your glasses are ready for pickup.'
+
+  def assert_response(response)
+    if response.is_a?(String)
+      id, name, number = response.split("\n")
+    else
+      id = response['ID']
+      name = response['Name']
+      number = response['Number']
+    end
+
+    expect(Integer(id)).to be_an_instance_of(Integer)
+    expect(name.to_f).to be_an_instance_of(Float) if id != ''
+    expect(number.to_f).to be_an_instance_of(Float)
+  end
+
+  def request(stub, extra_params = {})
+    params = {
+      from: Helper::VIRTUAL_INBOUNDS[:eplus],
+      text: $text,
+      to: Helper::VIRTUAL_INBOUNDS[:eplus]
+    }.merge(extra_params)
+
+    helper = Helper.new(SevenApi::Resources::Sms)
+    helper.request(helper.resource.method(:retrieve), stub, params)
+  end
+
+  it 'sends a single sms and returns success code' do
+    expect(request(100)).to be_a(Integer)
+  end
+
+  it 'sends a single sms and returns detailed text response' do
+    stub = <<~TEXT
+      100
+      Verbucht: 0
+      Preis: 0.075
+      Guthaben: 4.575
+      Text: Your glasses are ready for pickup.
+      SMS-Typ: direct
+      Flash SMS: false
+      Encoding: gsm
+      GSM0338: true
+      Debug: true
+    TEXT
+
+    body = request(stub, { details: 1 })
+
+    expect(body).to be_a(String)
+
+    code, booked, cost, balance, text, type, flash, encoding, gsm0338, debug = body.split("\n")
+
+    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')
+    expect(encoding.split(':').last.strip!).to eq('gsm')
+    expect(gsm0338.split(':').last.strip!).to eq('true')
+    expect(debug.split(':').last.strip!).to eq('true')
+  end
+
+  it 'sends a single sms and returns json response' do
+    stub = {
+      success: '100',
+      total_price: 0,
+      balance: 4.5,
+      debug: 'true',
+      sms_type: 'direct',
+      messages: [{ id: nil,
+                   sender: '491771783130',
+                   recipient: '491771783130',
+                   text: 'Your glasses are ready for pickup.',
+                   encoding: 'gsm',
+                   parts: 1,
+                   price: 0,
+                   success: true,
+                   error: nil,
+                   error_text: nil }]
+    }
+
+    body = request(stub, { json: 1 })
+
+    expect(body).to be_a(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/seven_api/subaccounts_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'seven_api/resources/subaccounts'
+
+dummy_subaccount = {
+  :auto_topup => {
+    :amount => 5,
+    :threshold => 1,
+  },
+  :balance => 36.8100,
+  :company => 'Company1',
+  :contact => {
+    :email => 'sms@acme-company1.com',
+    :name => 'John Doe',
+  },
+  :id => '1234567891',
+  :total_usage => 0.3000,
+  :username => nil,
+}
+
+RSpec.describe SevenApi, 'subaccounts' do
+  HELPER = Helper.new(SevenApi::Resources::Subaccounts)
+
+  def request(key, stub, extra_params = {})
+    HELPER.request(HELPER.resource.method(key), stub, extra_params)
+  end
+
+  it 'returns all subaccounts' do
+    res = request(:read, [
+      dummy_subaccount
+    ])
+
+    expect(res).to be_a(Array)
+
+    res.each do |subaccount|
+      assert_subaccount(subaccount)
+    end
+  end
+
+  it 'creates a subaccount' do
+    res = request(:create, {
+      :error => nil,
+      :subaccount => dummy_subaccount,
+      :success => true,
+    })
+
+    expect(res).to be_a(Hash)
+    expect(res[:error]).to be_nil_or_lengthy_string
+    assert_subaccount(res[:subaccount])
+    expect(res[:success]).to be_boolean
+  end
+
+  it 'deletes a subaccount' do
+    res = request(
+      :delete,
+      {
+        :error => nil,
+        :success => true,
+      },
+      {
+        :id => -1,
+      }
+    )
+
+    expect(res).to be_a(Hash)
+    expect(res[:error]).to be_nil_or_lengthy_string
+    expect(res[:success]).to be_boolean
+  end
+
+  it 'transfers credits' do
+    res = request(
+      :transfer_credits,
+      {
+        :error => nil,
+        :success => true,
+      },
+      {
+        :amount => 0,
+        :id => -1,
+      }
+    )
+
+    expect(res).to be_a(Hash)
+    expect(res[:error]).to be_nil_or_lengthy_string
+    expect(res[:success]).to be_boolean
+  end
+
+  it 'updats automatic charging of credits' do
+    res = request(
+      :update,
+      {
+        :error => nil,
+        :success => true,
+      },
+      {
+        :amount => 0,
+        :id => -1,
+        :threshold => -1,
+      }
+    )
+
+    expect(res).to be_a(Hash)
+    expect(res[:error]).to be_nil_or_lengthy_string
+    expect(res[:success]).to be_boolean
+  end
+
+  private
+
+  def assert_subaccount(subaccount)
+    expect(subaccount).to be_a(Hash)
+    expect(subaccount).to include(:auto_topup, :balance, :company, :contact, :id, :total_usage, :username,)
+    expect(subaccount[:auto_topup]).to be_a(Object)
+    expect(subaccount[:auto_topup]).to include(:amount, :threshold,)
+    expect(subaccount[:balance]).to be_a(Float)
+    expect(subaccount[:contact]).to be_a(Object)
+    expect(subaccount[:contact]).to include(:email, :name,)
+    expect(subaccount[:id]).to be_a(String)
+    expect(subaccount[:total_usage]).to be_a(Float)
+  end
+end

data/spec/seven_api/validate_for_voice_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'seven_api/resources/validate_for_voice'
+
+RSpec.describe SevenApi, 'validate_for_voice' do
+  it 'returns caller id information' do
+    number = '491771783130'
+    callback_host = Helper::IS_HTTP ? `curl http://ipecho.net/plain` : '127.0.0.1'
+    callback = "#{callback_host}/callback.php"
+    stub = { success: true }
+
+    helper = Helper.new(SevenApi::Resources::ValidateForVoice)
+    body = helper.request(helper.resource.method(:retrieve), stub, { number: number, callback: callback })
+
+    expect(body).to be_a(Hash)
+    expect(body[:success]).to be_boolean
+  end
+end

data/spec/seven_api/voice_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'seven_api/resources/voice'
+
+RSpec.describe SevenApi, 'voice' do
+  def assert_response(response)
+    expect(response).to be_a(String)
+
+    code, id, cost = response.split("\n")
+
+    expect(Integer(code)).to be_an_instance_of(Integer)
+    expect(id.to_f).to be_an_instance_of(Float) if id != ''
+    expect(cost.to_f).to be_an_instance_of(Float)
+  end
+
+  def request(text, extra_params = {})
+    stub = <<~TEXT
+      301
+      
+      0.1
+    TEXT
+
+    params = {
+      from: Helper::VIRTUAL_INBOUNDS[:eplus],
+      text: text,
+      to: Helper::VIRTUAL_INBOUNDS[:eplus]
+    }.merge(extra_params)
+
+    helper = Helper.new(SevenApi::Resources::Voice)
+    assert_response(helper.request(helper.resource.method(:send), stub, params))
+  end
+
+  it 'calls a number with text input' do
+    request('Your glasses are ready for pickup.')
+  end
+
+  it 'calls a number with xml input' do
+    text = <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <Response>
+        <Say voice="woman" language="en-EN">
+          Your glasses are ready for pickup.
+        </Say>
+        <Record maxlength="20" />
+      </Response>
+    XML
+
+    request(text, { xml: true })
+  end
+end

data/spec/seven_api_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe SevenApi do
+  it 'has a version number' do
+    expect(SevenApi::VERSION).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'seven_api'
+require 'seven_api/resource'
+require 'seven_api/util'
+require 'matchers'
+require 'EnvKeyStore'
+
+SEVEN_TEST_HTTP = (ENV['SEVEN_TEST_HTTP'].nil? ? false : true).freeze
+
+RSpec.configure do |config|
+  SEVEN_TEST_HTTP && config.after do
+    sleep(1.125)
+  end
+end
+
+class Helper
+  attr_reader :resource
+
+  IS_HTTP = SEVEN_TEST_HTTP
+  VIRTUAL_INBOUNDS = {
+    eplus: '+491771783130',
+  }.freeze
+
+  # @param resource [Class<SevenApi::Resource>]
+  def initialize(resource)
+    @resource = resource.new(ENV['SEVEN_API_KEY_SANDBOX'], 'ruby-test')
+
+    unless Helper::IS_HTTP
+      @stubs = Faraday::Adapter::Test::Stubs.new
+      @resource.conn.builder.adapter(:test, @stubs)
+    end
+  end
+
+  def create_stub(fn_name, stub)
+    http_fn = @resource.http_methods[fn_name]
+    puts "creating stub for #{http_fn} @ #{@resource.class.name}.#{fn_name}"
+
+    @stubs.method(http_fn).call(SevenApi::Resource::BASE_PATH + @resource.endpoint) do
+      puts "stub: " + stub.inspect
+
+      [200, {}, stub]
+    end
+  end
+
+  def request(fn, stub, params = nil)
+    create_stub(fn.name, stub) unless Helper::IS_HTTP
+
+    fn.call(*[params].compact)
+  end
+end