seven_api 0.5.0 → 0.6.0

data/spec/seven_api/lookup_spec.rb

@@ -7,12 +7,10 @@ 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))
+  helper = Helper.new(SevenApi::Resources::Lookup)
+
+  def request(type, stub, params = { number: '+491771783130' })
+    helper.request(helper.resource.method(type), stub, params)
   end
 
   it 'misses number to lookup' do
@@ -27,14 +25,14 @@ RSpec.describe SevenApi, 'lookup' do
       network_type: nil,
       success: false
     }
-
-    res = request(SevenApi::Lookup::Type::FORMAT, stub, { number: '' })
+    path = SevenApi::Resources::Lookup.const_get('PATHS')[:format]
+    res = helper.request(helper.resource.method(:format), stub, { number: '' }, path)
 
     expect(res).to be_a(Hash)
     expect(res[:success]).to match(false)
   end
 
-  it 'returns number formatting details as json' do
+  it 'returns number formatting details' do
     stub = {
       carrier: 'Eplus',
       country_code: '49',
@@ -46,29 +44,41 @@ RSpec.describe SevenApi, 'lookup' do
       network_type: 'mobile',
       success: true
     }
+    path = SevenApi::Resources::Lookup.const_get('PATHS')[:format]
+    body = helper.request(helper.resource.method(:format), stub, { number: '+491771783130' }, path)
 
-    body = request(SevenApi::Lookup::Type::FORMAT, stub)
+    assert_format(body)
+  end
 
-    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
+  it 'returns RCS lookup capabilities' do
+    stub = {
+      carrier: "O2",
+      country_code: "49",
+      country_iso: "DE",
+      country_name: "Germany",
+      international: "+49176123456789",
+      international_formatted: "+49 179 123456789",
+      national: "0176 12345679",
+      network_type: "mobile",
+      rcs_capabilities: %w[ACTION_CREATE_CALENDAR_EVENT ACTION_DIAL ACTION_OPEN_URL ACTION_SHARE_LOCATION ACTION_VIEW_LOCATION RICHCARD_CAROUSEL RICHCARD_STANDALONE],
+      success: true
+    }
+    path = SevenApi::Resources::Lookup.const_get('PATHS')[:rcs_capabilities]
+    body = helper.request(helper.resource.method(:rcs_capabilities), stub, { number: '+491771783130' }, path)
+
+    assert_format(body)
+    expect(body[:rcs_capabilities]).to be_a(Array)
   end
 
-  it 'returns CNAM details as json' do
+  it 'returns CNAM details' do
     stub = {
       code: '100',
       name: 'GERMANY',
       number: '+491771783130',
       success: 'true'
     }
-    body = request(SevenApi::Lookup::Type::CNAM, stub)
+    path = SevenApi::Resources::Lookup.const_get('PATHS')[:cnam]
+    body = helper.request(helper.resource.method(:cnam), stub, { number: '+491771783130' }, path)
 
     expect(body).to be_a(Hash)
     expect(body[:code]).to be_a(String)
@@ -77,13 +87,7 @@ RSpec.describe SevenApi, 'lookup' do
     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
+  it 'returns MNP details' do
     stub = {
       code: 100,
       mnp: {
@@ -98,7 +102,8 @@ RSpec.describe SevenApi, 'lookup' do
       price: 0.005,
       success: true
     }
-    body = request(SevenApi::Lookup::Type::MNP, stub, { json: 1 })
+    path = SevenApi::Resources::Lookup.const_get('PATHS')[:mnp]
+    body = helper.request(helper.resource.method(:mnp), stub, { number: '+491771783130' }, path)
 
     expect(body).to be_a(Hash)
     expect(body[:code]).to be_a(Integer)
@@ -114,7 +119,7 @@ RSpec.describe SevenApi, 'lookup' do
     expect(body[:success]).to be_boolean
   end
 
-  it 'returns HLR details as json' do
+  it 'returns HLR details' do
     stub = {
       country_code: 'DE',
       country_name: 'Germany',
@@ -145,8 +150,8 @@ RSpec.describe SevenApi, 'lookup' do
       roaming: 'not_roaming',
       valid_number: 'valid'
     }
-
-    body = request(SevenApi::Lookup::Type::HLR, stub)
+    path = SevenApi::Resources::Lookup.const_get('PATHS')[:hlr]
+    body = helper.request(helper.resource.method(:hlr), stub, { number: '+491771783130' }, path)
 
     expect(body).to be_a(Hash)
     expect(body[:country_code]).to be_a(String)
@@ -176,4 +181,17 @@ RSpec.describe SevenApi, 'lookup' do
     expect(hash[:network_code]).to be_a(String)
     expect(hash[:network_type]).to be_a(String)
   end
+
+  def assert_format(body)
+    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
 end

data/spec/seven_api/numbers_spec.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'seven_api/resources/numbers'
+
+dummy_number = {
+  "country": "DE",
+  "number": "49176123456789",
+  "friendly_name": "",
+  "billing": {
+    "fees": {
+      "setup": 19.9,
+      "basic_charge": 238.8,
+      "sms_mo": 0,
+      "voice_mo": 0
+    },
+    "payment_interval": "annually"
+  },
+  "features": {
+    "sms": true,
+    "a2p_sms": false,
+    "voice": true
+  },
+  "forward_sms_mo": {
+    "sms": {
+      "number": [
+        "4917612345678"
+      ],
+      "enabled": true
+    },
+    "email": {
+      "address": %w[j.doe@acme.inc john@doe.com],
+      "enabled": true
+    }
+  },
+  "expires": nil,
+  "created": "2024-01-31 17:06:27"
+}
+
+RSpec.describe SevenApi, 'numbers' do
+  $new_number_id = nil
+
+  def assert_new(response_body)
+    code = response_body[:return]
+    $new_number_id = response_body[:id]
+
+    expect(code).to be_numeric
+    expect($new_number_id).to be_an_instance_of(Integer)
+  end
+
+  def assert_number(number)
+    expect(number[:id]).to be_numeric
+    expect(number[:name]).to be_an_instance_of(String)
+  end
+
+  it 'returns available numbers' do
+    stub = {
+      availableNumbers: [
+        dummy_number,
+        dummy_number
+      ],
+    }
+
+    helper = Helper.new(SevenApi::Resources::Numbers)
+    body = helper.request(helper.resource.method(:available), stub)
+
+    expect(body).to be_a(Hash)
+    expect(body).to have_key(:availableNumbers)
+    expect(body[:availableNumbers]).to be_a(Array)
+
+    body[:availableNumbers].each do |number|
+      assert_number(number)
+    end
+  end
+
+  it 'returns active numbers' do
+    stub = {
+      availableNumbers: [
+        dummy_number,
+        dummy_number
+      ],
+    }
+
+    helper = Helper.new(SevenApi::Resources::Numbers)
+    body = helper.request(helper.resource.method(:active), stub)
+
+    expect(body).to be_a(Array)
+
+    body.each do |number|
+      assert_number(number)
+    end
+  end
+
+  it 'order a number' do
+    stub = dummy_number
+    helper = Helper.new(SevenApi::Resources::Numbers)
+    body = helper.request(helper.resource.method(:order), stub)
+
+    expect(body).to be_a(Hash)
+
+    assert_new(body)
+  end
+
+  it 'update a number' do
+    stub = dummy_number
+    helper = Helper.new(SevenApi::Resources::Numbers)
+    body = helper.request(helper.resource.method(:update), stub)
+
+    expect(body).to be_a(Hash)
+
+    assert_new(body)
+  end
+
+  it 'get a number' do
+    stub = dummy_number
+    helper = Helper.new(SevenApi::Resources::Numbers)
+    body = helper.request(helper.resource.method(:one[:number]), stub)
+
+    expect(body).to be_a(Hash)
+
+    assert_new(body)
+  end
+
+  it 'deletes a number' do
+    helper = Helper.new(SevenApi::Resources::Numbers)
+    body = helper.request(
+      helper.resource.method(:delete),
+      nil,
+      0
+    )
+
+    expect(body).to be_a(Hash)
+    expect(body[:return]).to be_a(String)
+  end
+end

data/spec/seven_api/rcs_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'seven_api/resources/rcs'
+
+RSpec.describe SevenApi, 'rcs' do
+  $helper = Helper.new(SevenApi::Resources::Rcs)
+
+  def dispatch(stub, extra_params = {})
+    params = {
+      text: 'Your glasses are ready for pickup.',
+      to: '491716992343'
+    }.merge(extra_params)
+
+    $helper.request($helper.resource.method(:dispatch), stub, params, '/messages')
+  end
+
+  it 'sends a single rcs and returns json response' do
+    stub = {
+      success: '100',
+      total_price: 0,
+      balance: 4.52,
+      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,
+                   channel: 'RCS'}]
+    }
+
+    body = dispatch(stub)
+
+    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)
+      expect(message[:channel]).to eq('RCS')
+    end
+  end
+
+  it 'schedules a rcs message and deletes it again' do
+    rcs = dispatch({
+                     success: '100',
+                     total_price: 0,
+                     balance: 4.52,
+                     debug: 'true',
+                     sms_type: 'direct',
+                     messages: [{ id: 12345,
+                                  sender: '491771783130',
+                                  recipient: '491771783130',
+                                  text: 'Your glasses are ready for pickup.',
+                                  encoding: 'gsm',
+                                  parts: 1,
+                                  price: 0,
+                                  success: true,
+                                  error: nil,
+                                  error_text: nil,
+                                  channel: 'RCS'}]
+                   })
+    msg = rcs[:messages].first
+    id = msg[:id]
+    stub = {
+      success: true
+    }
+    params = {
+      id: id
+    }
+
+    deleted = $helper.request($helper.resource.method(:delete), stub, params, "/messages/#{id}")
+    expect(deleted[:success]).to eq(true)
+  end
+
+  it 'triggers a rcs event' do
+    stub = {
+      success: true
+    }
+    params = {
+      event: 'IS_TYPING',
+      msg_id: '',
+      to: '4915237035388'
+    }
+
+    event = $helper.request($helper.resource.method(:event), stub, params, '/events')
+    expect(event[:success]).to eq(true)
+  end
+end

data/spec/seven_api/sms_spec.rb

@@ -22,9 +22,9 @@ RSpec.describe SevenApi, 'sms' do
 
   def request(stub, extra_params = {})
     params = {
-      from: Helper::VIRTUAL_INBOUNDS[:eplus],
+      from: 'seven',
       text: $text,
-      to: Helper::VIRTUAL_INBOUNDS[:eplus]
+      to: '491716992343'
     }.merge(extra_params)
 
     helper = Helper.new(SevenApi::Resources::Sms)

data/spec/seven_api/voice_spec.rb

@@ -22,9 +22,9 @@ RSpec.describe SevenApi, 'voice' do
     TEXT
 
     params = {
-      from: Helper::VIRTUAL_INBOUNDS[:eplus],
+      from: nil,
       text: text,
-      to: Helper::VIRTUAL_INBOUNDS[:eplus]
+      to: '491716992343'
     }.merge(extra_params)
 
     helper = Helper.new(SevenApi::Resources::Voice)

data/spec/spec_helper.rb

@@ -8,25 +8,14 @@ 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
+  IS_HTTP = (ENV['SEVEN_TEST_HTTP'].nil? ? false : true).freeze
 
   # @param resource [Class<SevenApi::Resource>]
   def initialize(resource)
-    @resource = resource.new(ENV['SEVEN_API_KEY_SANDBOX'], 'ruby-test')
+    @resource = resource.new(ENV['SEVEN_API_KEY'], 'ruby-test')
 
     unless Helper::IS_HTTP
       @stubs = Faraday::Adapter::Test::Stubs.new
@@ -34,19 +23,21 @@ class Helper
     end
   end
 
-  def create_stub(fn_name, stub)
+  def create_stub(fn_name, stub, path)
     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 SevenApi::Resource::BASE_PATH + @resource.endpoint + path
+
+    @stubs.method(http_fn).call(SevenApi::Resource::BASE_PATH + @resource.endpoint + path) do
       puts "stub: " + stub.inspect
 
       [200, {}, stub]
     end
   end
 
-  def request(fn, stub, params = nil)
-    create_stub(fn.name, stub) unless Helper::IS_HTTP
+  def request(fn, stub, params = nil, path = '')
+    create_stub(fn.name, stub, path) unless Helper::IS_HTTP
 
     fn.call(*[params].compact)
   end