telesignature 0.0.2

data/lib/telesignature/telesign_error.rb

@@ -0,0 +1,34 @@
+module Telesignature
+  class TelesignError < ::StandardError
+    # """
+    # The **exceptions** base class.
+
+    # .. list-table::
+    #    :widths: 5 30
+    #    :header-rows: 1
+
+    #    * - Attributes
+    #      -
+    #    * - `data`
+    #      - The data returned by the service, in a dictionary form.
+    #    * - `http_response`
+    #      - The full HTTP Response object, including the HTTP status code, headers, and raw returned data.
+
+    # """
+
+    attr_accessor :errors, :headers, :status, :data, :raw_data
+
+    def initialize errors, http_response
+      @errors = errors
+      @headers = http_response[:headers]
+      @status = http_response[:status_code]
+      @data = http_response[:text]
+      @raw_data = http_response[:text]
+      super()
+    end
+
+    def to_s
+      @errors.inject(''){|ret, x| ret += "%s\n" % x[:description] }
+    end
+  end
+end

data/lib/telesignature/validation_error.rb

@@ -0,0 +1,23 @@
+module Telesignature
+  class ValidationError < TelesignError
+    # """
+    # The submitted data failed the intial validation, and the service was not executed.
+
+    # .. list-table::
+    #    :widths: 5 30
+    #    :header-rows: 1
+
+    #    * - Attributes
+    #      -
+    #    * - `data`
+    #      - The data returned by the service, in a dictionary form.
+    #    * - `http_response`
+    #      - The full HTTP Response object, including the HTTP status code, headers, and raw returned data.
+
+    # """
+
+    def initialize errors, http_response
+      super
+    end
+  end
+end

data/lib/telesignature/verify.rb

@@ -0,0 +1,273 @@
+module Telesignature
+  class Verify < ServiceBase
+    include Helpers
+    # """
+    # The **Verify** class exposes two services for sending users a verification token (a three to five-digit number). You can use this mechanism to simply test whether you can reach users at the phone number they supplied, or you can have them use the token to authenticate themselves with your web application.
+
+    # This class also exposes a service that is used in conjunction with the first two services, in that it allows you to confirm the result of the authentication.
+
+    # You can use this verification factor in combination with username & password to provide two-factor authentication for higher security.
+
+    # .. list-table::
+    #    :widths: 5 30
+    #    :header-rows: 1
+
+    #    * - Attributes
+    #      -
+    #    * - `customer_id`
+    #      - A string value that identifies your TeleSign account.
+    #    * - `secret_key`
+    #      - A base64-encoded string value that validates your access to the TeleSign web services.
+    #    * - `ssl`
+    #      - Specifies whether to use a secure connection with the TeleSign server. Defaults to *true*.
+    #    * - `api_host`
+    #      - The Internet host used in the base URI for REST web services. The default is *rest.telesign.com* (and the base URI is https://rest.telesign.com/).
+    #    * - `proxy_host`
+    #      - The host and port when going through a proxy server. ex: "localhost:8080. The default to no proxy.
+
+    # .. note::
+    #    You can obtain both your Customer ID and Secret Key from the `TeleSign Customer Portal <https://portal.telesign.com/account_profile_api_auth.php>`_.
+
+    # """
+
+    def initialize opts = {}
+      super(
+          customer_id: opts[:customer_id],
+          secret_key: opts[:secret_key],
+          ssl: (opts[:ssl] || true),
+          api_host: (opts[:api_host] || 'rest.telesign.com'),
+          proxy_host: (opts[:proxy_host] || nil)
+        )
+    end
+
+    def sms opts = {}
+      phone_number = opts[:phone_number]
+      verify_code = opts[:verify_code]
+      language = opts[:language] || 'en-US'
+      template = opts[:template] || ''
+
+      # """
+      # Sends a text message containing the verification code, to the specified phone number (supported for mobile phones only).
+
+      # .. list-table::
+      #    :widths: 5 30
+      #    :header-rows: 1
+
+      #    * - Parameters
+      #      -
+      #    * - `phone_number`
+      #      - The phone number to receive the text message. You must specify the phone number in its entirety. That is, it must begin with the country code, followed by the area code, and then by the local number. For example, you would specify the phone number (310) 555-1212 as 13105551212.
+      #    * - `verify_code`
+      #      - (optional) The verification code to send to the user. If omitted, TeleSign will automatically generate a random value for you.
+      #    * - `language`
+      #      - (optional) The written language used in the message. The default is English.
+      #    * - `template`
+      #      - (optional) A standard form for the text message. It must contain the token ``$$CODE$$``, which TeleSign auto-populates with the verification code.
+
+      # **Example**::
+
+      #     from telesign.api import Verify
+      #     from telesign.exceptions import AuthorizationError, TelesignError
+
+      #     cust_id = "FFFFFFFF-EEEE-DDDD-1234-AB1234567890"
+      #     secret_key = "EXAMPLE----TE8sTgg45yusumoN6BYsBVkh+yRJ5czgsnCehZaOYldPJdmFh6NeX8kunZ2zU1YWaUw/0wV6xfw=="
+      #     phone_number = "13107409700"
+
+      #     verify = Verify(cust_id, secret_key) # Instantiate a Verify object.
+
+      #     try:
+      #         phone_info = verify.sms(phone_number)
+      #     except AuthorizationError as ex:
+      #         # API authorization failed, the API response should tell you the reason
+      #         ...
+      #     except TelesignError as ex:
+      #         # failed to execute the Verify service, check the API response for details
+      #         ...
+
+      #     # When the user inputs the validation code, you can verify that it matches the one that you sent.
+      #     if (phone_info != None):
+      #         try:
+      #             status_info = verify.status(phone_info.data["reference_id"], verify_code=phone_info.verify_code)
+      #         except AuthorizationError as ex:
+      #             ...
+      #         except TelesignError as ex:
+      #             ...
+
+      # """
+
+      if verify_code.nil?
+        verify_code = random_with_N_digits(5)
+      end
+
+      resource = '/v1/verify/sms'
+      method = 'POST'
+
+      fields = {
+          phone_number: phone_number,
+          language: language,
+          verify_code: verify_code,
+          template: template}
+
+      headers = Telesignature::Auth.generate_auth_headers(
+          customer_id: @customer_id,
+          secret_key: @secret_key,
+          resource: resource,
+          method: method,
+          fields: fields)
+
+      response = @conn.post do |req|
+          req.url resource
+          req.body = fields
+          req.headers = headers
+          # proxies=@proxy
+      end
+
+      return Telesignature::Response.new validate_response(response), response, verify_code
+    end
+
+    def call opts = {}
+      phone_number = opts[:phone_number]
+      verify_code = opts[:verify_code]
+      language = opts[:language] || 'en-US'
+
+      # """
+      # Calls the specified phone number, and using speech synthesis, speaks the verification code to the user.
+
+      # .. list-table::
+      #    :widths: 5 30
+      #    :header-rows: 1
+
+      #    * - Parameters
+      #      -
+      #    * - `phone_number`
+      #      - The phone number to receive the text message. You must specify the phone number in its entirety. That is, it must begin with the country code, followed by the area code, and then by the local number. For example, you would specify the phone number (310) 555-1212 as 13105551212.
+      #    * - `verify_code`
+      #      - (optional) The verification code to send to the user. If omitted, TeleSign will automatically generate a random value for you.
+      #    * - `language`
+      #      - (optional) The written language used in the message. The default is English.
+
+
+      # **Example**::
+
+      #     from telesign.api import Verify
+      #     from telesign.exceptions import AuthorizationError, TelesignError
+
+      #     cust_id = "FFFFFFFF-EEEE-DDDD-1234-AB1234567890"
+      #     secret_key = "EXAMPLE----TE8sTgg45yusumoN6BYsBVkh+yRJ5czgsnCehZaOYldPJdmFh6NeX8kunZ2zU1YWaUw/0wV6xfw=="
+      #     phone_number = "13107409700"
+
+      #     verify = Verify(cust_id, secret_key) # Instantiate a Verify object.
+
+      #     try:
+      #         phone_info = verify.call(phone_number)
+      #     except AuthorizationError as ex:
+      #         # API authorization failed, the API response should tell you the reason
+      #         ...
+      #     except TelesignError as ex:
+      #         # failed to execute the Verify service, check the API response for details
+      #         ...
+
+      #     # When the user inputs the validation code, you can verify that it matches the one that you sent.
+      #     if (phone_info != None):
+      #         try:
+      #             status_info = verify.status(phone_info.data["reference_id"], verify_code=phone_info.verify_code)
+      #         except AuthorizationError as ex:
+      #             ...
+      #         except TelesignError as ex:
+      #             ...
+
+      # """
+
+      if verify_code.nil?
+        verify_code = random_with_N_digits(5)
+      end
+
+      resource = '/v1/verify/call'
+      method = 'POST'
+
+      fields = {
+          phone_number: phone_number,
+          language: language,
+          verify_code: verify_code}
+
+      headers = Telesignature::Auth.generate_auth_headers(
+          customer_id: @customer_id,
+          secret_key: @secret_key,
+          resource: resource,
+          method: method,
+          fields: fields)
+
+      response = @conn.post do |req|
+          req.url resource
+          req.body = fields
+          req.headers = headers
+          # proxies=@proxy
+      end
+
+      return Telesignature::Response.new validate_response(response), response, verify_code
+    end
+
+    def status ref_id, verify_code=nil
+      # """
+      # Retrieves the verification result. You make this call in your web application after users complete the authentication transaction (using either a call or sms).
+
+      # .. list-table::
+      #    :widths: 5 30
+      #    :header-rows: 1
+
+      #    * - Parameters
+      #      -
+      #    * - `ref_id`
+      #      - The Reference ID returned in the response from the TeleSign server, after you called either **call** or **sms**.
+      #    * - `verify_code`
+      #      - The verification code received from the user.
+
+      # **Example**::
+
+      #     from telesign.api import Verify
+      #     from telesign.exceptions import AuthorizationError, TelesignError
+
+      #     cust_id = "FFFFFFFF-EEEE-DDDD-1234-AB1234567890"
+      #     secret_key = "EXAMPLE----TE8sTgg45yusumoN6BYsBVkh+yRJ5czgsnCehZaOYldPJdmFh6NeX8kunZ2zU1YWaUw/0wV6xfw=="
+      #     phone_number = "13107409700"
+
+      #     verify = Verify(cust_id, secret_key) # Instantiate a Verify object.
+
+      #     phone_info = verify.sms(phone_number) # Send a text message that contains an auto-generated validation code, to the user.
+
+      #     # When the user inputs the validation code, you can verify that it matches the one that you sent.
+      #     if (phone_info != None):
+      #         try:
+      #             status_info = verify.status(phone_info.data["reference_id"], verify_code=phone_info.verify_code)
+      #         except AuthorizationError as ex:
+      #             ...
+      #         except TelesignError as ex:
+      #             ...
+
+      # """
+
+      resource = "/v1/verify/%s" % ref_id
+      method = 'GET'
+
+      headers = Telesignature::Auth.generate_auth_headers(
+          customer_id: @customer_id,
+          secret_key: @secret_key,
+          resource: resource,
+          method: method)
+
+      fields = nil
+      if !verify_code.nil?
+        fields = {verify_code: verify_code}
+      end
+
+      response = @conn.get do |req|
+          req.url resource
+          fields.each{|k,v| req.params[k] = v} if fields
+          req.headers = headers
+          # proxies=@proxy
+      end
+
+      return Telesignature::Response.new validate_response(response), response
+    end
+  end
+end

data/lib/telesignature/version.rb

@@ -0,0 +1,3 @@
+module Telesignature
+  VERSION = '0.0.2'
+end

data/lib/telesignature.rb

@@ -0,0 +1,13 @@
+require 'telesignature/version'
+
+module Telesignature
+  autoload :TelesignError, 'telesignature/telesign_error'
+  autoload :AuthorizationError, 'telesignature/authorization_error'
+  autoload :ValidationError, 'telesignature/validation_error'
+  autoload :Auth, 'telesignature/auth'
+  autoload :Response, 'telesignature/response'
+  autoload :Helpers, 'telesignature/helpers'
+  autoload :ServiceBase, 'telesignature/service_base'
+  autoload :Verify, 'telesignature/verify'
+  autoload :PhoneId, 'telesignature/phone_id'
+end

data/telesignature.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'telesignature/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'telesignature'
+  spec.version       = Telesignature::VERSION
+  spec.authors       = ['Andy Koch']
+  spec.email         = ['akoch@practicefusion.com']
+  spec.description   = %q{Client gem for Telesign REST API}
+  spec.summary       = %q{Client gem for Telesign REST API}
+  spec.homepage      = 'https://github.com/practicefusion/telesignature'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(test)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'faraday'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-minitest'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-debugger'
+end

data/test/auth_test.rb

@@ -0,0 +1,81 @@
+require 'minitest/autorun'
+require 'pry'
+require 'telesignature'
+
+class TestAuth < Minitest::Test
+  def setup
+    @expected_cid = '99999999-1F7E-11E1-B760-000000000000'
+    @expected_secret_key = '8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M=='
+    @expected_resource = '/foo/bar/baz/'
+  end
+
+  def test_headers_are_set_on_get
+    Telesignature::Auth.generate_auth_headers(
+            customer_id: @expected_cid,
+            secret_key: @expected_secret_key,
+            resource: @expected_resource,
+            method: 'GET')
+  end
+
+  def test_nonce_is_set
+    expected_nonce = '1234'
+
+    headers = SecureRandom.stub :uuid, expected_nonce do
+      Telesignature::Auth.generate_auth_headers(
+        customer_id: @expected_cid,
+        secret_key: @expected_secret_key,
+        resource: @expected_resource,
+        method: 'GET')
+    end
+
+    assert_equal headers['x-ts-nonce'], expected_nonce
+  end
+
+  def test_date_is_set
+    headers = Telesignature::Auth.generate_auth_headers(
+                customer_id: @expected_cid,
+                secret_key: @expected_secret_key,
+                resource: @expected_resource,
+                method: 'GET')
+
+    # Can't mock datetime
+    refute_match headers['x-ts-date'], nil
+  end
+
+  def test_sha1_default_auth_method
+    expected_auth_method = 'HMAC-SHA1'
+
+    headers = Telesignature::Auth.generate_auth_headers(
+                customer_id: @expected_cid,
+                secret_key: @expected_secret_key,
+                resource: @expected_resource,
+                method: 'GET')
+
+    assert_equal headers['x-ts-auth-method'], expected_auth_method, 'Auth method did not match'
+  end
+
+  def test_sha256_auth_method
+    expected_auth_method = 'HMAC-SHA256'
+
+    headers = Telesignature::Auth.generate_auth_headers(
+                customer_id: @expected_cid,
+                secret_key: @expected_secret_key,
+                resource: @expected_resource,
+                method: 'GET',
+                auth_method: :sha256)
+
+    assert_equal headers['x-ts-auth-method'], expected_auth_method, 'Auth method did not match'
+  end
+
+  def test_customer_id_in_auth
+    expected_auth_start = "TSA %s:" % @expected_cid
+
+    headers = Telesignature::Auth.generate_auth_headers(
+                customer_id: @expected_cid,
+                secret_key: @expected_secret_key,
+                resource: @expected_resource,
+                method: 'GET')
+
+    assert_match /^#{expected_auth_start}/, headers['Authorization'], 'Authorization did not start with TSA and customer ID'
+  end
+end

data/test/exceptions_test.rb

@@ -0,0 +1,57 @@
+require 'minitest/autorun'
+require 'pry'
+require 'telesignature'
+
+class ExceptionTestTest < Minitest::Test
+  # Test for exceptions in telesign sdk
+  def setup
+    @expected_errors = [{code: 1, description: 'Error 1'},
+                        {code: 2, description: 'Error 2'}]
+    @expected_headers = {a: 'AA', b: 'BB'}
+    @expected_status = '200'
+    @expected_data = 'abcdefg'
+
+    @expected_http_response = Hash.new
+    @expected_http_response[:headers] = @expected_headers
+    @expected_http_response[:status_code] = @expected_status
+    @expected_http_response[:text] = @expected_data
+  end
+
+
+  def validate_exception_properties x
+    assert_equal x.errors, @expected_errors, 'Errors property was not set on exception'
+    assert_equal x.headers, @expected_headers, 'Headers property was not set on exception'
+    assert_equal x.status, @expected_status, 'Status property was not set on exception'
+    assert_equal x.data, @expected_data, 'Data property was not set on exception'
+    assert_equal x.raw_data, @expected_data, 'RawData property was not set on exception'
+
+    msg = x.message
+    @expected_errors.each do |err|
+      assert_match err[:description], msg
+    end
+  end
+
+  def test_properties_are_populated_in_TelesignError
+    begin
+      raise Telesignature::TelesignError.new( @expected_errors, @expected_http_response )
+    rescue Telesignature::TelesignError => x
+      validate_exception_properties x
+    end
+  end
+
+  def test_properties_are_populated_in_AuthorizationError
+    begin
+      raise Telesignature::AuthorizationError.new @expected_errors, @expected_http_response
+    rescue Telesignature::AuthorizationError => x
+      validate_exception_properties x
+    end
+  end
+
+  def test_properties_are_populated_in_ValidationError
+    begin
+      raise Telesignature::ValidationError.new @expected_errors, @expected_http_response
+    rescue Telesignature::ValidationError => x
+      validate_exception_properties(x)
+    end
+  end
+end

data/test/phone_id_test.rb

@@ -0,0 +1,159 @@
+require 'minitest/autorun'
+require 'pry'
+require 'telesignature'
+require 'webmock/minitest'
+
+
+class PhoneIdTest < Minitest::Test
+  # Test for phone id telesign sdk
+
+  def setup
+    @expected_cid = '99999999-1F7E-11E1-B760-000000000000'
+    @expected_secret_key = '8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M8M=='
+    @expected_phone_no = '12343455678'
+    @expected_data = '{ "a":"AA", "b":"BB" }'
+    @expected_resource = "https://rest.telesign.com/v1/phoneid/%s/%s"
+    @proxy = 'localhost:8080'
+    @expected_proxy = 'https://localhost:8080'
+
+    @acceptance_headers = { 'Accept' => /.*/,
+                            'Accept-Encoding' => /.*/,
+                            'Authorization' => /.*/,
+                            'User-Agent' => /.*/,
+                            'X-Ts-Auth-Method' => /.*/,
+                            'X-Ts-Date'=> /.*/,
+                            'X-Ts-Nonce' => /.*/}
+  end
+
+  def test_standard_phoneid
+    stub_request(:get, @expected_resource % ['standard', @expected_phone_no]).
+      with( headers: @acceptance_headers).
+        to_return(body: @expected_data, status: 200)
+
+    p = Telesignature::PhoneId.new customer_id: @expected_cid, secret_key: @expected_secret_key
+    p.standard @expected_phone_no
+  end
+
+  def test_standard_phoneid_unauthorized
+    response_body = '{ "a":"AA", "b":"BB", "errors": { "code":"401", "description":"Unauthorized" } }'
+
+    stub_request(:get, @expected_resource % ['standard', @expected_phone_no]).
+      with( headers: @acceptance_headers).
+        to_return(body: response_body, status: [401, 'Unauthorized'])
+
+    p = Telesignature::PhoneId.new customer_id: @expected_cid, secret_key: @expected_secret_key
+
+    assert_raises(Telesignature::AuthorizationError){
+      p.standard(@expected_phone_no)
+    }
+  end
+
+  def test_standard_phoneid_other_error
+    response_body = '{ "a":"AA", "b":"BB", "errors": { "code":"502", "description":"Bad Gateway" } }'
+
+    stub_request(:get, @expected_resource % ['standard', @expected_phone_no]).
+      with( headers: @acceptance_headers).
+        to_return(body: response_body, status: [502, 'Bad Gateway'])
+
+    p = Telesignature::PhoneId.new customer_id: @expected_cid, secret_key: @expected_secret_key
+
+    assert_raises(Telesignature::TelesignError){
+      p.standard(@expected_phone_no)
+    }
+  end
+
+  def test_score_phoneid
+    stub_request(:get, @expected_resource % ['score', @expected_phone_no]).
+      with(query: {ucid: 'OTHR'}, headers: @acceptance_headers).
+        to_return(body: @expected_data, status: 200)
+
+    p = Telesignature::PhoneId.new customer_id: @expected_cid, secret_key: @expected_secret_key
+    p.score @expected_phone_no, 'OTHR'
+  end
+
+  def test_contact_phoneid
+    stub_request(:get, @expected_resource % ['contact', @expected_phone_no]).
+      with(query: {ucid: 'OTHR'}, headers: @acceptance_headers).
+        to_return(body: @expected_data, status: 200)
+
+    p = Telesignature::PhoneId.new customer_id: @expected_cid, secret_key: @expected_secret_key
+    p.contact @expected_phone_no, 'OTHR'
+  end
+
+  def test_live_phoneid
+    stub_request(:get, @expected_resource % ['live', @expected_phone_no]).
+      with(query: {ucid: 'OTHR'}, headers: @acceptance_headers).
+        to_return(body: @expected_data, status: 200)
+
+    p = Telesignature::PhoneId.new customer_id: @expected_cid, secret_key: @expected_secret_key
+    p.live @expected_phone_no, 'OTHR'
+  end
+
+  # # @mock.patch.object(requests, "get")
+  # def test_standard_phoneid_with_proxy
+  #   response = mock.Mock()
+  #   response.reason = ""
+  #   response.status_code = 200
+  #   response.text = @expected_data
+  #   req_mock.return_value = response
+
+  #   p = PhoneId.new(@expected_cid, @expected_secret_key, @proxy)
+  #   p.standard(@expected_phone_no)
+
+  #   assert_true.called
+  #   _, kwargs = req_mock.call_args
+  #   assert_equal kwargs["url"], @expected_resource % ['standard', @expected_phone_no], "Phone ID resource name is incorrect"
+  #   assert_equal kwargs["proxies"]["https"], @expected_proxy, "Proxy did not match"
+  # end
+
+  # # @mock.patch.object(requests, "get")
+  # def test_score_phoneid_with_proxy
+  #   response = mock.Mock()
+  #   response.reason = ""
+  #   response.status_code = 200
+  #   response.text = @expected_data
+  #   req_mock.return_value = response
+
+  #   p = PhoneId.new(@expected_cid, @expected_secret_key, @proxy)
+  #   p.score(@expected_phone_no, 'OTHR')
+
+  #   assert_true.called
+  #   _, kwargs = req_mock.call_args
+  #   assert_equal kwargs["url"], @expected_resource % ['score', @expected_phone_no], "Phone ID resource name is incorrect"
+  #   assert_equal kwargs["proxies"]["https"], @expected_proxy, "Proxy did not match"
+  # end
+
+  # # @mock.patch.object(requests, "get")
+  # def test_contact_phoneid_with_proxy
+  #   response = mock.Mock()
+  #   response.reason = ""
+  #   response.status_code = 200
+  #   response.text = @expected_data
+  #   req_mock.return_value = response
+
+  #   p = PhoneId.new(@expected_cid, @expected_secret_key, @proxy)
+  #   p.contact(@expected_phone_no, 'OTHR')
+
+  #   assert_true.called
+  #   _, kwargs = req_mock.call_args
+  #   assert_equal kwargs["url"], @expected_resource % ['contact', @expected_phone_no], "Phone ID resource name is incorrect"
+  #   assert_equal kwargs["proxies"]["https"], @expected_proxy, "Proxy did not match"
+  # end
+
+  # # @mock.patch.object(requests, "get")
+  # def test_live_phoneid_with_proxy
+  #   response = mock.Mock()
+  #   response.reason = ""
+  #   response.status_code = 200
+  #   response.text = @expected_data
+  #   req_mock.return_value = response
+
+  #   p = PhoneId.new(@expected_cid, @expected_secret_key, proxy_host=@proxy)
+  #   p.live(@expected_phone_no, 'OTHR')
+
+  #   assert_true.called
+  #   _, kwargs = req_mock.call_args
+  #   assert_equal kwargs["url"], @expected_resource % ['live', @expected_phone_no], "Phone ID resource name is incorrect"
+  #   assert_equal kwargs["proxies"]["https"], @expected_proxy, "Proxy did not match"
+  # end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'minitest/autorun'
+require 'pry'
+require 'telesignature'
+
+begin
+  require 'turn/autorun'
+  Turn.config.format = :progress
+rescue LoadError
+   p 'failed to load turn'
+end