telnyx 0.0.1

data/test/telnyx/telnyx_response_test.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../../test_helper", __FILE__)
+
+module Telnyx
+  class TelnyxResponseTest < Test::Unit::TestCase
+    context ".from_faraday_hash" do
+      should "converts to TelnyxResponse" do
+        body = '{"foo": "bar"}'
+        headers = { "X-Request-Id" => "request-id" }
+
+        http_resp = {
+          body: body,
+          headers: headers,
+          status: 200,
+        }
+
+        resp = TelnyxResponse.from_faraday_hash(http_resp)
+
+        assert_equal JSON.parse(body, symbolize_names: true), resp.data
+        assert_equal body, resp.http_body
+        assert_equal headers, resp.http_headers
+        assert_equal 200, resp.http_status
+        assert_equal "request-id", resp.request_id
+      end
+    end
+
+    context ".from_faraday_response" do
+      should "converts to TelnyxResponse" do
+        body = '{"foo": "bar"}'
+        headers = { "X-Request-Id" => "request-id" }
+
+        env = Faraday::Env.from(
+          status: 200, body: body,
+          response_headers: headers
+        )
+        http_resp = Faraday::Response.new(env)
+
+        resp = TelnyxResponse.from_faraday_response(http_resp)
+
+        assert_equal JSON.parse(body, symbolize_names: true), resp.data
+        assert_equal body, resp.http_body
+        assert_equal headers, resp.http_headers
+        assert_equal 200, resp.http_status
+        assert_equal "request-id", resp.request_id
+      end
+    end
+  end
+end

data/test/telnyx/util_test.rb

@@ -0,0 +1,380 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../../test_helper", __FILE__)
+
+module Telnyx
+  class UtilTest < Test::Unit::TestCase
+    context "OPTS_COPYABLE" do
+      should "include :apibase" do
+        assert_include Telnyx::Util::OPTS_COPYABLE, :api_base
+      end
+    end
+
+    context "OPTS_PERSISTABLE" do
+      should "include :client" do
+        assert_include Telnyx::Util::OPTS_PERSISTABLE, :client
+      end
+
+      should "not include :idempotency_key" do
+        refute_includes Telnyx::Util::OPTS_PERSISTABLE, :idempotency_key
+      end
+    end
+
+    should "#encode_parameters should prepare parameters for an HTTP request" do
+      params = {
+        a: 3,
+        b: "+foo?",
+        c: "bar&baz",
+        d: { a: "a", b: "b" },
+        e: [0, 1],
+        f: "",
+
+        # note the empty hash won't even show up in the request
+        g: [],
+      }
+      assert_equal(
+        "a=3&b=%2Bfoo%3F&c=bar%26baz&d[a]=a&d[b]=b&e[0]=0&e[1]=1&f=",
+        Telnyx::Util.encode_parameters(params)
+      )
+    end
+
+    should "#url_encode should prepare strings for HTTP" do
+      assert_equal "foo",      Telnyx::Util.url_encode("foo")
+      assert_equal "foo",      Telnyx::Util.url_encode(:foo)
+      assert_equal "foo%2B",   Telnyx::Util.url_encode("foo+")
+      assert_equal "foo%26",   Telnyx::Util.url_encode("foo&")
+      assert_equal "foo[bar]", Telnyx::Util.url_encode("foo[bar]")
+    end
+
+    should "#flatten_params should encode parameters according to Rails convention" do
+      params = [
+        [:a, 3],
+        [:b, "foo?"],
+        [:c, "bar&baz"],
+        [:d, { a: "a", b: "b" }],
+        [:e, [0, 1]],
+        [:f, [
+          { foo: "1", ghi: "2" },
+          { foo: "3", bar: "4" },
+        ],],
+      ]
+      assert_equal([
+        ["a", 3],
+        ["b",        "foo?"],
+        ["c",        "bar&baz"],
+        ["d[a]",     "a"],
+        ["d[b]",     "b"],
+        ["e[0]",      0],
+        ["e[1]",      1],
+
+        # *The key here is the order*. In order to be properly interpreted as
+        # an array of hashes on the server, everything from a single hash must
+        # come in at once. A duplicate key in an array triggers a new element.
+        ["f[0][foo]", "1"],
+        ["f[0][ghi]", "2"],
+        ["f[1][foo]", "3"],
+        ["f[1][bar]", "4"],
+      ], Telnyx::Util.flatten_params(params))
+    end
+
+    should "#symbolize_names should convert names to symbols" do
+      start = {
+        "foo" => "bar",
+        "array" => [{ "foo" => "bar" }],
+        "nested" => {
+          1 => 2,
+          :symbol => 9,
+          "string" => nil,
+        },
+      }
+      finish = {
+        foo: "bar",
+        array: [{ foo: "bar" }],
+        nested: {
+          1 => 2,
+          :symbol => 9,
+          :string => nil,
+        },
+      }
+
+      symbolized = Telnyx::Util.symbolize_names(start)
+      assert_equal(finish, symbolized)
+    end
+
+    should "#normalize_opts should reject nil keys" do
+      assert_raise { Telnyx::Util.normalize_opts(nil) }
+      assert_raise { Telnyx::Util.normalize_opts(api_key: nil) }
+    end
+
+    should "#convert_to_telnyx_object should pass through unknown types" do
+      obj = Util.convert_to_telnyx_object(7, {})
+      assert_equal 7, obj
+    end
+
+    should "#convert_to_telnyx_object should turn hashes into TelnyxObjects" do
+      obj = Util.convert_to_telnyx_object({ foo: "bar" }, {})
+      assert obj.is_a?(TelnyxObject)
+      assert_equal "bar", obj.foo
+    end
+
+    should "#convert_to_telnyx_object should marshal other classes" do
+      obj = Util.convert_to_telnyx_object({ record_type: "messaging_profile" }, {})
+      assert obj.is_a?(MessagingProfile)
+    end
+
+    should "#convert_to_telnyx_object should marshal arrays" do
+      obj = Util.convert_to_telnyx_object([1, 2, 3], {})
+      assert_equal [1, 2, 3], obj
+    end
+
+    context ".log_*" do
+      setup do
+        @old_log_level = Telnyx.log_level
+        Telnyx.log_level = nil
+
+        @old_stderr = $stderr
+        $stderr = StringIO.new
+
+        @old_stdout = $stdout
+        $stdout = StringIO.new
+      end
+
+      teardown do
+        Telnyx.log_level = @old_log_level
+        $stderr = @old_stderr
+        $stdout = @old_stdout
+      end
+
+      context ".log_debug" do
+        should "not log if logging is disabled" do
+          Util.log_debug("foo")
+          assert_equal "", $stdout.string
+        end
+
+        should "log if level set to debug" do
+          Telnyx.log_level = Telnyx::LEVEL_DEBUG
+          Util.log_debug("foo")
+          assert_equal "message=foo level=debug \n", $stdout.string
+        end
+
+        should "not log if level set to error" do
+          Telnyx.log_level = Telnyx::LEVEL_ERROR
+          Util.log_debug("foo")
+          assert_equal "", $stdout.string
+        end
+
+        should "not log if level set to info" do
+          Telnyx.log_level = Telnyx::LEVEL_INFO
+          Util.log_debug("foo")
+          assert_equal "", $stdout.string
+        end
+      end
+
+      context ".log_error" do
+        should "not log if logging is disabled" do
+          Util.log_error("foo")
+          assert_equal "", $stdout.string
+        end
+
+        should "log if level set to debug" do
+          Telnyx.log_level = Telnyx::LEVEL_DEBUG
+          Util.log_error("foo")
+          assert_equal "message=foo level=error \n", $stderr.string
+        end
+
+        should "log if level set to error" do
+          Telnyx.log_level = Telnyx::LEVEL_ERROR
+          Util.log_error("foo")
+          assert_equal "message=foo level=error \n", $stderr.string
+        end
+
+        should "log if level set to info" do
+          Telnyx.log_level = Telnyx::LEVEL_INFO
+          Util.log_error("foo")
+          assert_equal "message=foo level=error \n", $stderr.string
+        end
+      end
+
+      context ".log_info" do
+        should "not log if logging is disabled" do
+          Util.log_info("foo")
+          assert_equal "", $stdout.string
+        end
+
+        should "log if level set to debug" do
+          Telnyx.log_level = Telnyx::LEVEL_DEBUG
+          Util.log_info("foo")
+          assert_equal "message=foo level=info \n", $stdout.string
+        end
+
+        should "not log if level set to error" do
+          Telnyx.log_level = Telnyx::LEVEL_ERROR
+          Util.log_debug("foo")
+          assert_equal "", $stdout.string
+        end
+
+        should "log if level set to info" do
+          Telnyx.log_level = Telnyx::LEVEL_INFO
+          Util.log_info("foo")
+          assert_equal "message=foo level=info \n", $stdout.string
+        end
+      end
+    end
+
+    context ".log_* with a logger" do
+      setup do
+        @out = StringIO.new
+        logger = ::Logger.new(@out)
+
+        # Set a really simple formatter to make matching output as easy as
+        # possible.
+        logger.formatter = proc { |_severity, _datetime, _progname, message|
+          message
+        }
+
+        Telnyx.logger = logger
+      end
+
+      context ".log_debug" do
+        should "log to the logger" do
+          Util.log_debug("foo")
+          assert_equal "message=foo ", @out.string
+        end
+      end
+
+      context ".log_error" do
+        should "log to the logger" do
+          Util.log_error("foo")
+          assert_equal "message=foo ", @out.string
+        end
+      end
+
+      context ".log_info" do
+        should "log to the logger" do
+          Util.log_info("foo")
+          assert_equal "message=foo ", @out.string
+        end
+      end
+    end
+
+    context ".normalize_headers" do
+      should "normalize the format of a header key" do
+        assert_equal({ "Request-Id" => nil },
+                     Util.normalize_headers("Request-Id" => nil))
+        assert_equal({ "Request-Id" => nil },
+                     Util.normalize_headers("request-id" => nil))
+        assert_equal({ "Request-Id" => nil },
+                     Util.normalize_headers("Request-ID" => nil))
+        assert_equal({ "Request-Id" => nil },
+                     Util.normalize_headers(request_id: nil))
+      end
+
+      should "tolerate bad formatting" do
+        assert_equal({ "Request-Id" => nil },
+                     Util.normalize_headers("-Request--Id-" => nil))
+        assert_equal({ "Request-Id" => nil },
+                     Util.normalize_headers(request__id: nil))
+      end
+    end
+
+    #
+    # private
+    #
+    # I don't feel particularly good about using #send to invoke these, but I
+    # want them hidden from the public interface, and each method is far easier
+    # to test in isolation (as opposed to going through a public method).
+    #
+
+    context ".colorize" do
+      should "colorize for a TTY" do
+        assert_equal "\033[0;32;49mfoo\033[0m",
+                     Util.send(:colorize, "foo", :green, true)
+      end
+
+      should "not colorize otherwise" do
+        assert_equal "foo", Util.send(:colorize, "foo", :green, false)
+      end
+    end
+
+    context ".level_name" do
+      should "convert levels to names" do
+        assert_equal "debug", Util.send(:level_name, LEVEL_DEBUG)
+        assert_equal "error", Util.send(:level_name, LEVEL_ERROR)
+        assert_equal "info", Util.send(:level_name, LEVEL_INFO)
+      end
+    end
+
+    context ".log_internal" do
+      should "log in a terminal friendly way" do
+        out = StringIO.new
+
+        # Sketchy as anything, but saves us from pulling in a mocking library.
+        # Open this instance of StringIO, and add a method override so that it
+        # looks like a TTY.
+        out.instance_eval do
+          def isatty
+            true
+          end
+        end
+
+        Util.send(:log_internal, "message", { foo: "bar" },
+                  color: :green, level: Telnyx::LEVEL_DEBUG, logger: nil, out: out)
+        assert_equal "\e[0;32;49mDEBU\e[0m message \e[0;32;49mfoo\e[0m=bar\n",
+                     out.string
+      end
+
+      should "log in a data friendly way" do
+        out = StringIO.new
+        Util.send(:log_internal, "message", { foo: "bar" },
+                  color: :green, level: Telnyx::LEVEL_DEBUG, logger: nil, out: out)
+        assert_equal "message=message level=debug foo=bar\n",
+                     out.string
+      end
+
+      should "log to a logger if set" do
+        out = StringIO.new
+        logger = ::Logger.new(out)
+
+        # Set a really simple formatter to make matching output as easy as
+        # possible.
+        logger.formatter = proc { |_severity, _datetime, _progname, message|
+          message
+        }
+
+        Util.send(:log_internal, "message", { foo: "bar" },
+                  color: :green, level: Telnyx::LEVEL_DEBUG, logger: logger, out: $stdout)
+        assert_equal "message=message foo=bar",
+                     out.string
+      end
+    end
+
+    context ".wrap_logfmt_value" do
+      should "pass through simple values" do
+        assert_equal "abc", Util.send(:wrap_logfmt_value, "abc")
+        assert_equal "123", Util.send(:wrap_logfmt_value, "123")
+        assert_equal "a-b_c/d", Util.send(:wrap_logfmt_value, "a-b_c/d")
+      end
+
+      should "pass through numerics" do
+        assert_equal 123, Util.send(:wrap_logfmt_value, 123)
+        assert_equal 1.23, Util.send(:wrap_logfmt_value, 1.23)
+      end
+
+      should "wrap more complex values in double quotes" do
+        assert_equal %("abc=123"), Util.send(:wrap_logfmt_value, %(abc=123))
+      end
+
+      should "escape double quotes already in the value" do
+        assert_equal %("abc=\\"123\\""), Util.send(:wrap_logfmt_value, %(abc="123"))
+      end
+
+      should "remove newlines" do
+        assert_equal %("abc"), Util.send(:wrap_logfmt_value, "a\nb\nc")
+      end
+
+      should "not error if given a non-string" do
+        assert_equal "true", Util.send(:wrap_logfmt_value, true)
+      end
+    end
+  end
+end

data/test/telnyx/webhook_test.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../../test_helper", __FILE__)
+
+module Telnyx
+  class WebhookTest < Test::Unit::TestCase
+    EVENT_PAYLOAD = <<-PAYLOAD.freeze
+      {
+        "data": {
+          "record_type": "event",
+          "id": "0ccc7b54-4df3-4bca-a65a-3da1ecc777f0",
+          "event_type": "port_request.ported",
+          "created_at": "2018-02-02T22:25:27.521992Z",
+          "payload": {
+            "id": "5ccc7b54-4df3-4bca-a65a-3da1ecc777f0"
+          }
+        }
+      }
+    PAYLOAD
+
+    # rubocop:disable Metrics/LineLength
+    PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwy/jPkkgBo7oQermYujj\nAmSqN+aHNg+D4K85lKn6T3khJ8O2t/FrgN5qSGqg+0U5hoIHZflEon28lbLdf6gZ\njPeKQ2a24w5zroR6e4MM00RyJWA6MWXdo6Tn6xqKMYuT8LffEJGnXCH4yTIkxAVD\nyK0dfewhtrlpmW5ojXcDCrZ3Oo1o588PLNwSIuQwU7wHZwOLglWxFt6LZ9Ps8zYf\nQNH/pXNczf1E4rGZ1QxrzqFbndvjCE5VDRhULhycT/X0H2EMvNgHsDQk4OhENnzo\nCal3vO5+P9MgC7NSZCR8Ubebq0tanL5dj5GGYyjWmeq3QhfDLX2mTpIv/B0e8+hg\n8QIDAQAB\n-----END PUBLIC KEY-----\n".freeze
+
+    PRIVATE_KEY = "-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEAwy/jPkkgBo7oQermYujjAmSqN+aHNg+D4K85lKn6T3khJ8O2\nt/FrgN5qSGqg+0U5hoIHZflEon28lbLdf6gZjPeKQ2a24w5zroR6e4MM00RyJWA6\nMWXdo6Tn6xqKMYuT8LffEJGnXCH4yTIkxAVDyK0dfewhtrlpmW5ojXcDCrZ3Oo1o\n588PLNwSIuQwU7wHZwOLglWxFt6LZ9Ps8zYfQNH/pXNczf1E4rGZ1QxrzqFbndvj\nCE5VDRhULhycT/X0H2EMvNgHsDQk4OhENnzoCal3vO5+P9MgC7NSZCR8Ubebq0ta\nnL5dj5GGYyjWmeq3QhfDLX2mTpIv/B0e8+hg8QIDAQABAoIBAQCNwoP6wsVdvgD1\njxNQlu/41v/Bpc5h9xbC4sChNmqzubfY144nPlHjwKXUfoz4sag8Bsg0ybuNgGCt\nIME6a+5SsZ5boYgGlIJ0J4eFmQKBll6IwsDBC8jTh3thB1+C6GrEE+cQc5jnk0zL\nY33MWD6IyyJ2SD+cJEGLy+JnjB5LckGCQXWPQXwvpIKgGmFoLQzHCKfeKHZ3olB8\nC1+YKrQzLtyuuH9obDWxRSrqI5gOI/76PWmo+weNa4OrfFtBf5O9bo5OD17ilIT/\nuNpxb/7rOkpwU9x6D00/D/S7ecCdVoL2yBB5L635TNQKXxhvdSmBg1ceLlztwsUL\nOHIlglTZAoGBAOY3wyincm8iAUxLE+Z3AeTD94pjND4g2JXFF9E7UDxgRD6E3n38\nubNRdAMkxDmDYgyIOZsebykMadQ2vNiWqTjOBr6hxyQMFutHWrIJOU+peFCepn8u\nNX3Xg44l7KcwwqX5svoqgFl1FKwNpBOSo50oGX4lAgqtjYqEeMInfjZ7AoGBANkL\nz0wBNAr9oXsc0BN2WkQXB34RU/WcrymhxHfc+ZRzRShk9LOdBTuMYnj4rtjdG849\nJDDWlMk7UlzGjI07G5aT+n8Aq69BhV0IARC9PafTncE6G3sHswAQudHiurLflP9C\noj6kTakunrq8Kgj3Q1p6Ie+Hv7E01A3D0Difr4CDAoGAXORrLuBB4G3MMEirAvdK\nIFCidYiJ7/e47NXWQmq4eWQupTtfu15aX+yh7xLKypok2gGtnNWu7NVBbouXr507\nMtyPBCSrAfSO2uizw9rM8UPkdENP00mF8/0d7CGJV/zozafve9niaDZB3Rqz9eHZ\nevRPNQMhy8Uzs4y4XT8qQjkCgYBNuLjmkpe8R86Hc23fSkZQk56POk1CanUfB1p/\nQZXt3skpCd3GY7f39vFcOFEEP0kxtRs8kdp9pMx9hGvYNw5OAXd1+xt/iorjIXag\nM+PcMR8QjmpAyCUFJPglfHc2jnGgZpAKtnNI3fThEXhL9Z8cyxdT2tx97FjzBOeP\nHz+NWQKBgQCU0bSxTp2rbOCxHosQ/GDDTY0JkQ2z5q1SkibSiEnyAZ3yCHpXZRD7\nsa5BWs4qlasSKmxdmT9xgRDAL6CJH6kJizF3UIaIPOvPjIroOa7Mk1OFNbOi6Cao\n0LcWp5w1I2r5g7sOIRM/AcS3yVT5RJO4KB8WyDOvxCfP8cFsTacZmQ==\n-----END RSA PRIVATE KEY-----\n".freeze
+    # rubocop:enable Metrics/LineLength
+
+    def generate_signature(opts = {})
+      opts[:timestamp] ||= Time.now.to_i
+      opts[:payload] ||= EVENT_PAYLOAD
+      opts[:private_key] ||= PRIVATE_KEY
+
+      private_key = OpenSSL::PKey::RSA.new(opts[:private_key])
+      signature = private_key.sign(OpenSSL::Digest::SHA256.new, "#{opts[:timestamp]}|#{opts[:payload]}")
+      Base64.encode64(signature)
+    end
+
+    def setup
+      super
+      ENV["TELNYX_PUBLIC_KEY"] = PUBLIC_KEY
+    end
+
+    context ".construct_event" do
+      should "return an Event instance from a valid JSON payload and valid signature header" do
+        timestamp = Time.now.to_i
+        signature = generate_signature(timestamp: timestamp)
+        event = Telnyx::Webhook.construct_event(EVENT_PAYLOAD, signature, timestamp)
+        assert event.is_a?(Telnyx::Event)
+      end
+
+      should "raise a JSON::ParserError from an invalid JSON payload" do
+        assert_raises JSON::ParserError do
+          payload = "this is not valid JSON"
+          timestamp = Time.now.to_i
+          signature = generate_signature(payload: payload, timestamp: timestamp)
+          Telnyx::Webhook.construct_event(payload, signature, timestamp)
+        end
+      end
+
+      should "raise a SignatureVerificationError from a valid JSON payload and an invalid signature header" do
+        signature = "bad_signature"
+        timestamp = Time.now.to_i
+        assert_raises Telnyx::SignatureVerificationError do
+          Telnyx::Webhook.construct_event(EVENT_PAYLOAD, signature, timestamp)
+        end
+      end
+    end
+
+    context ".verify" do
+      should "raise a SignatureVerificationError when the signature does not have the expected format" do
+        signature = "FAKEFAKEFAKE"
+        e = assert_raises(Telnyx::SignatureVerificationError) do
+          Telnyx::Webhook::Signature.verify(EVENT_PAYLOAD, signature, Time.now.to_i)
+        end
+        assert_match("Signature is invalid and does not match the payload", e.message)
+      end
+
+      should "raise a SignatureVerificationError when there are no valid signatures for the payload" do
+        timestamp = Time.now.to_i
+        signature = generate_signature(payload: "foo", timestamp: timestamp)
+        e = assert_raises(Telnyx::SignatureVerificationError) do
+          Telnyx::Webhook::Signature.verify(EVENT_PAYLOAD, signature, timestamp)
+        end
+        assert_match("Signature is invalid and does not match the payload", e.message)
+      end
+
+      should "raise a SignatureVerificationError when the timestamp is not within the tolerance" do
+        timestamp = Time.now.to_i - 15
+        signature = generate_signature(timestamp: Time.now.to_i - 15)
+        e = assert_raises(Telnyx::SignatureVerificationError) do
+          Telnyx::Webhook::Signature.verify(EVENT_PAYLOAD, signature, timestamp, tolerance: 10)
+        end
+        assert_match("Timestamp outside the tolerance zone", e.message)
+      end
+
+      should "return true when the signature is valid and the timestamp is within the tolerance" do
+        timestamp = Time.now.to_i
+        signature = generate_signature
+        assert(Telnyx::Webhook::Signature.verify(EVENT_PAYLOAD, signature, timestamp, tolerance: 10))
+      end
+
+      should "return true when the signature is valid and the timestamp is off but no tolerance is provided" do
+        timestamp = 12_345
+        signature = generate_signature(timestamp: timestamp)
+        assert(Telnyx::Webhook::Signature.verify(EVENT_PAYLOAD, signature, timestamp))
+      end
+    end
+  end
+end