esp_sdk 1.0.0

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |task|
+  task.libs << 'test'
+  task.test_files = FileList['test/*_test.rb', 'test/**/*_test.rb']
+end
+
+task default: [:test]

data/esp_sdk.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'esp_sdk/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'esp_sdk'
+  spec.version       = EspSdk::VERSION
+  spec.authors       = ['Evident.io']
+  spec.email         = ['support@evident.io']
+  spec.summary       = %q{SDK for interacting with the ESP API.}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.3.2'
+  spec.add_development_dependency 'rubocop', '~> 0.27.1'
+  spec.add_development_dependency 'minitest', '~> 5.4.2'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.0.7'
+  spec.add_development_dependency 'shoulda', '~> 3.5.0'
+  spec.add_development_dependency 'codeclimate-test-reporter', '~> 0.4.1'
+  spec.add_development_dependency 'mocha', '~> 1.1.0'
+  spec.add_development_dependency 'fakeweb', '~> 1.3'
+  spec.add_development_dependency 'awesome_print', '~> 1.2.0'
+
+  spec.add_runtime_dependency 'activesupport', '~> 4.1.6'
+  spec.add_runtime_dependency 'rest_client', '~> 1.7.3'
+end

data/lib/esp_sdk/api.rb

@@ -0,0 +1,29 @@
+module EspSdk
+  class Api
+    attr_reader :end_points, :config
+
+    def initialize(options = {})
+      fail MissingAttribute, 'Missing required email'    if options[:email].blank?
+      fail MissingAttribute, 'Missing required password or token' if options[:password].blank? && options[:token].blank?
+      @config     = Configure.new(options)
+      @end_points = []
+      define_methods
+    end
+
+    private
+
+    def define_methods
+      end_points = EspSdk::EndPoints.constants - [:Base]
+
+      end_points.each do |end_point|
+        name = end_point.to_s.underscore
+        define_singleton_method name do
+          return instance_variable_get(:"@#{name}") if instance_variable_get(:"@#{name}").present?
+          instance_variable_set(:"@#{name}", EspSdk::EndPoints.const_get(end_point).new(config))
+        end
+
+        @end_points << send(name)
+      end
+    end
+  end
+end

data/lib/esp_sdk/client.rb

@@ -0,0 +1,59 @@
+require 'rest_client'
+require_relative 'extensions/rest_client/request'
+
+module EspSdk
+  # Client class for our endpoints. Every endpoint gets its own client.
+  class Client
+    attr_reader :config, :errors
+
+    def initialize(config)
+      @config  = config
+    end
+
+    def connect(url, type = :get, payload = {})
+      payload = { payload_key => payload } if payload.present?
+
+      begin
+        if type == :get || type == :delete
+          if payload.present?
+            response = RestClient.send(type, url, headers.merge(params: payload))
+          else
+            response = RestClient.send(type, url, headers)
+          end
+        else
+          # The rest of our actions will require a payload
+          fail MissingAttribute, 'Missing required attributes' if payload.blank?
+          response = RestClient.send(type, url, payload, headers)
+        end
+      rescue RestClient::UnprocessableEntity, RestClient::Unauthorized => e
+        response = e.response
+        check_errors(JSON.load(response.body))
+      end
+
+      response
+    end
+
+    private
+
+    def headers
+      @headers ||= { 'Authorization' => @config.token, 'Authorization-Email' => @config.email, 'Content-Type' => 'application/json', 'Accept' => 'application/json' }
+    end
+
+    def payload_key
+      @payload_key ||= self.class.to_s.demodulize.singularize.underscore
+    end
+
+    def check_errors(body)
+      @errors  = body['errors'] if body.present? && body.is_a?(Hash) && body['errors'].present?
+      return unless @errors.present?
+
+      if @errors.select { |error| error.to_s.include?('Token has expired') }.present?
+        fail TokenExpired, 'Token has expired'
+      elsif (error = @errors.select { |error| error.to_s.include?('Record not found') }[0]).present?
+        fail RecordNotFound, error
+      else
+        fail EspSdk::Exception, "#{@errors.join('. ')}"
+      end
+    end
+  end
+end

data/lib/esp_sdk/configure.rb

@@ -0,0 +1,36 @@
+module EspSdk
+  class Configure
+    attr_accessor :token, :email, :version, :token_expires_at
+
+    def initialize(options)
+      @email   = options[:email]
+      @version = options[:version] || 'v1'
+      token_setup(options)
+    end
+
+    def uri
+      return @uri if @uri.present?
+
+      if EspSdk.production?
+        @uri = 'https://api.evident.io/api'
+      elsif EspSdk.release?
+        @uri = 'https://api-rel.evident.io/api'
+      else
+        @uri = 'http://0.0.0.0:3001/api'
+      end
+    end
+
+    private
+
+    def token_setup(options)
+      self.token = options[:password] || options[:token]
+      end_point  = options[:password].present? ? 'new' : 'valid'
+      client     = Client.new(self)
+      response   = client.connect("#{uri}/#{version}/token/#{end_point}")
+      user       = JSON.load(response.body)
+      self.token = user['authentication_token']
+      self.token_expires_at = user['token_expires_at'].to_s.to_datetime.utc ||
+        1.hour.from_now.to_datetime.utc
+    end
+  end
+end

data/lib/esp_sdk/end_points/base.rb

@@ -0,0 +1,86 @@
+require 'json'
+
+module EspSdk
+  module EndPoints
+    class Base < EspSdk::Client
+      attr_reader :current_page, :current_record
+
+      def next_page
+        return list if current_page.blank?
+
+        if @page_links['next'].present?
+          response = connect(@page_links['next'], :get)
+          pagination_links(response)
+          @current_page = JSON.load(response.body)
+        else
+          current_page
+        end
+      end
+
+      def prev_page
+        return list if current_page.blank?
+
+        if @page_links['prev'].present?
+          response      = connect(@page_links['prev'], :get)
+          pagination_links(response)
+          @current_page = JSON.load(response.body)
+        else
+          @current_page
+        end
+      end
+
+      # Get a pageable list of records
+      def list
+        response = connect(base_url, :get)
+        pagination_links(response)
+        @current_page = JSON.load(response.body)
+      end
+
+      # Get a single record
+      def show(params = {})
+        validate_id(params)
+        submit(id_url(params.delete(:id)), :get)
+      end
+
+      # Update a single record
+      def update(params = {})
+        validate_id(params)
+        submit(id_url(params.delete(:id)), :patch, params)
+      end
+
+      # Destroy a single record
+      def destroy(params = {})
+        validate_id(params)
+        submit(id_url(params.delete(:id)), :delete)
+      end
+
+      # Create a new record
+      def create(params = {})
+        submit(base_url, :post, params)
+      end
+
+      private
+
+      def validate_id(params)
+        fail MissingAttribute, 'Missing required attribute id' if params[:id].blank?
+      end
+
+      def id_url(id)
+        "#{base_url}/#{id}"
+      end
+
+      def base_url
+        "#{config.uri}/#{config.version}/#{self.class.to_s.demodulize.underscore}"
+      end
+
+      def submit(url, type, options = {})
+        response         = connect(url, type, options)
+        @current_record  = JSON.load(response.body)
+      end
+
+      def pagination_links(response)
+        @page_links = JSON.load(response.headers[:link])
+      end
+    end
+  end
+end

data/lib/esp_sdk/end_points/contact_requests.rb

@@ -0,0 +1,6 @@
+module EspSdk
+  module EndPoints
+    class ContactRequests < Base
+    end
+  end
+end

data/lib/esp_sdk/end_points/custom_signatures.rb

@@ -0,0 +1,41 @@
+module EspSdk
+  module EndPoints
+    class CustomSignatures < Base
+      def run(params = {})
+        validate_run_params(valid_run_params, params.keys)
+        submit(run_url, :post, params)
+      end
+
+      def run_raw(params = {})
+        validate_run_params(valid_run_raw_params, params.keys)
+        submit(run_url, :post, params)
+      end
+
+      private
+
+      def run_url
+        "#{base_url}/run"
+      end
+
+      def valid_run_params
+        [:id, :regions, :external_account_id]
+      end
+
+      def valid_run_raw_params
+        [:signature, :regions, :external_account_id]
+      end
+
+      def validate_run_params(valid_params, keys)
+        # Check that all the valid params are present
+        valid_params.each do |param|
+          fail MissingAttribute, "Missing required attribute #{param}" unless keys.include?(param)
+        end
+
+        # Check for invalid params
+        keys.each do |key|
+          fail UnknownAttribute, "Unknown attribute #{key}" unless valid_params.include?(key)
+        end
+      end
+    end
+  end
+end

data/lib/esp_sdk/end_points/dashboard.rb

@@ -0,0 +1,30 @@
+module EspSdk
+  module EndPoints
+    class Dashboard < Base
+      def timewarp(params = {})
+        validate_timewarp_params(params.keys)
+        submit(timewarp_url, :post, params)
+      end
+
+      private
+
+      def timewarp_url
+        "#{base_url}/timewarp"
+      end
+
+      def validate_timewarp_params(keys)
+        valid_timewarp_params = [:time]
+
+        # Check that all the valid params are present
+        valid_timewarp_params.each do |param|
+          fail MissingAttribute, "Missing required attribute #{param}" unless keys.include?(param)
+        end
+
+        # Check for invalid params
+        keys.each do |key|
+          fail UnknownAttribute, "Unknown attribute #{key}" unless valid_timewarp_params.include?(key)
+        end
+      end
+    end
+  end
+end

data/lib/esp_sdk/end_points/external_accounts.rb

@@ -0,0 +1,9 @@
+module EspSdk
+  module EndPoints
+    class ExternalAccounts < Base
+      def generate_external_id
+        SecureRandom.uuid
+      end
+    end
+  end
+end

data/lib/esp_sdk/end_points/organizations.rb

@@ -0,0 +1,6 @@
+module EspSdk
+  module EndPoints
+    class Organizations < Base
+    end
+  end
+end

data/lib/esp_sdk/end_points/reports.rb

@@ -0,0 +1,6 @@
+module EspSdk
+  module EndPoints
+    class Reports < Base
+    end
+  end
+end

data/lib/esp_sdk/end_points/services.rb

@@ -0,0 +1,6 @@
+module EspSdk
+  module EndPoints
+    class Services < Base
+    end
+  end
+end

data/lib/esp_sdk/end_points/signatures.rb

@@ -0,0 +1,39 @@
+module EspSdk
+  module EndPoints
+    class Signatures < Base
+      def run(params = {})
+        validate_run_params(params)
+        submit(run_url, :post, params)
+      end
+
+      def names
+        submit(name_url, :get)
+      end
+
+      private
+
+      def run_url
+        "#{base_url}/run"
+      end
+
+      def name_url
+        "#{base_url}/signature_names"
+      end
+
+      def validate_run_params(options)
+        valid_params = [:signature_name, :regions, :external_account_id]
+        keys         = options.keys
+
+        # Check that all the valid params are present
+        valid_params.each do |param|
+          fail EspSdk::MissingAttribute, "Missing required attribute #{param}" unless keys.include?(param)
+        end
+
+        # Check for invalid params
+        keys.each do |key|
+          fail EspSdk::UnknownAttribute, "Unknown attribute #{key}" unless valid_params.include?(key)
+        end
+      end
+    end
+  end
+end

data/lib/esp_sdk/end_points/sub_organizations.rb

@@ -0,0 +1,6 @@
+module EspSdk
+  module EndPoints
+    class SubOrganizations < Base
+    end
+  end
+end

data/lib/esp_sdk/end_points/teams.rb

@@ -0,0 +1,6 @@
+module EspSdk
+  module EndPoints
+    class Teams < Base
+    end
+  end
+end

data/lib/esp_sdk/end_points/users.rb

@@ -0,0 +1,6 @@
+module EspSdk
+  module EndPoints
+    class Users < Base
+    end
+  end
+end

data/lib/esp_sdk/exceptions.rb

@@ -0,0 +1,7 @@
+module EspSdk
+  class MissingAttribute < StandardError; end
+  class UnknownAttribute < StandardError; end
+  class TokenExpired     < StandardError; end
+  class RecordNotFound   < StandardError; end
+  class Exception        < StandardError; end
+end

data/lib/esp_sdk/extensions/rest_client/request.rb

@@ -0,0 +1,9 @@
+module RestClient
+  class Request
+    # Override execute to always use SSLv23
+    def self.execute(args, &block)
+      args.merge!(ssl_version: 'SSLv23')
+      new(args).execute(& block)
+    end
+  end
+end

data/lib/esp_sdk/version.rb

@@ -0,0 +1,3 @@
+module EspSdk
+  VERSION = '1.0.0'
+end

data/lib/esp_sdk.rb

@@ -0,0 +1,45 @@
+require 'active_support/all'
+require_relative 'esp_sdk/version'
+require_relative 'esp_sdk/configure'
+require_relative 'esp_sdk/client'
+require_relative 'esp_sdk/end_points/base'
+require_relative 'esp_sdk/end_points/reports'
+require_relative 'esp_sdk/end_points/users'
+require_relative 'esp_sdk/end_points/external_accounts'
+require_relative 'esp_sdk/end_points/custom_signatures'
+require_relative 'esp_sdk/end_points/organizations'
+require_relative 'esp_sdk/end_points/sub_organizations'
+require_relative 'esp_sdk/end_points/teams'
+require_relative 'esp_sdk/end_points/signatures'
+require_relative 'esp_sdk/end_points/dashboard'
+require_relative 'esp_sdk/end_points/contact_requests'
+require_relative 'esp_sdk/end_points/services'
+require_relative 'esp_sdk/api'
+require_relative 'esp_sdk/exceptions'
+
+module EspSdk
+  # Default environment is production
+  def self.env
+    @env ||= (ENV['ESP_ENV'] || ENV['RAILS_ENV'] || :production).to_sym
+  end
+
+  # Production environment query method
+  def self.production?
+    env == :production
+  end
+
+  # Release environment query method
+  def self.release?
+    env == :release
+  end
+
+  # Development environment query method
+  def self.development?
+    env == :development
+  end
+
+  # Test environment query method
+  def self.test?
+    env == :test
+  end
+end

data/test/esp_sdk/api_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class ApiTest < ActiveSupport::TestCase
+  context 'Api' do
+    context '#initalize' do
+      should 'raise a MissingAttribute error for a missing email' do
+        e = assert_raises EspSdk::MissingAttribute do
+          EspSdk::Api.new({ })
+        end
+        assert_equal 'Missing required email', e.message
+
+      end
+      should 'raise a MissingAttribute error for a missing token and password' do
+        e = assert_raises EspSdk::MissingAttribute do
+          EspSdk::Api.new(email: 'test@evident.io')
+        end
+        assert_equal 'Missing required password or token', e.message
+
+      end
+
+      should 'define our endpoint methods and add them to the end_points array' do
+        # Stub the token setup for our configuration object
+        EspSdk::Configure.any_instance.expects(:token_setup).returns(nil).at_least_once
+        api = EspSdk::Api.new(email: 'test@evident.io', password: 'password')
+        end_points = (EspSdk::EndPoints.constants - [:Base]).map(&:to_s).map(&:underscore)
+        methods = api.singleton_methods.map(&:to_s)
+
+        assert_equal end_points.count, api.end_points.count
+
+        methods.each do |method|
+          assert_includes end_points, method
+        end
+      end
+    end
+  end
+end

data/test/esp_sdk/client_test.rb

@@ -0,0 +1,119 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class ClientTest < ActiveSupport::TestCase
+  context 'Client' do
+    setup do
+      # Stub the token setup for our configuration object
+      EspSdk::Configure.any_instance.expects(:token_setup).returns(nil).at_least_once
+      @config = EspSdk::Configure.new(email: 'test@evident.io')
+      @config.token = '1234abc'
+      @client = EspSdk::Client.new(@config)
+    end
+
+    context '#initalize' do
+      # Sanity check really.
+      should 'set the config on the client' do
+        assert @client.config.is_a?(EspSdk::Configure)
+        assert_equal 'test@evident.io', @client.config.email
+        assert_equal '1234abc', @client.config.token
+      end
+    end
+
+    context '#connect' do
+      setup { @url = 'https://esp.evident.io/api/v1/test' }
+      [:get, :delete].each do |type|
+        should "make #{type} request with headers only" do
+          # Make sure the correct RestClient method is called and arguments are passed
+          RestClient.expects(type).with(@url, @client.send(:headers))
+          @client.connect(@url, type)
+        end
+
+        should "make #{type} request with headers and payload" do
+          payload = { id: 1 }
+          # Make sure the correct RestClient method is called and arguments are passed
+          RestClient.expects(type).with(@url, @client.send(:headers).merge(params: { @client.send(:payload_key) => payload }))
+          @client.connect(@url, type, payload)
+        end
+      end
+
+      [:post, :patch, :put].each do |type|
+        should "raise MissingAttribute exception for an empty payload from request type #{type}" do
+          e = assert_raises EspSdk::MissingAttribute do
+            @client.connect(@url, type)
+          end
+
+          assert_equal 'Missing required attributes', e.message
+        end
+
+        should "make #{type} request with headers and payload" do
+          payload = { id: 1 }
+          # Make sure the correct RestClient method is called and arguments are passed
+          RestClient.expects(type).with(@url, { @client.send(:payload_key) => payload }, @client.send(:headers))
+          @client.connect(@url, type, payload)
+        end
+      end
+    end
+
+    context '#headers' do
+      should 'have the correct keys and values' do
+        headers = @client.send(:headers)
+        # Assert the correct keys are present
+        assert headers.is_a?(Hash)
+        assert headers.key?('Authorization')
+        assert headers.key?('Authorization-Email')
+        assert headers.key?('Content-Type')
+        assert headers.key?('Accept')
+
+        # Assert the correct values are present
+        assert_equal @config.token, headers['Authorization']
+        assert_equal @config.email, headers['Authorization-Email']
+        assert_equal 'application/json', headers['Content-Type']
+        assert_equal 'application/json', headers['Accept']
+      end
+    end
+
+    context '#payload_key' do
+      should 'create the correct payload key' do
+        # Check this through and endpoint class.
+        # Should take the class name and turn it into a valid key the api understands
+        external_account = EspSdk::EndPoints::ExternalAccounts.new(@config)
+        assert_equal 'external_account', external_account.send(:payload_key)
+      end
+    end
+
+    context '#check_errors' do
+      should 'return nil when errors are blank' do
+        assert_nil @client.send(:check_errors, {})
+      end
+
+      should 'return nil when errors is not a hash' do
+        assert_nil @client.send(:check_errors, [1])
+      end
+
+      should 'return nil when errors is missing the errors key' do
+        assert_nil @client.send(:check_errors, { test: 1 })
+      end
+
+      should 'raise TokenExpired exception when a token has expired error is present' do
+        e = assert_raises EspSdk::TokenExpired do
+          @client.send(:check_errors, { 'errors' => ['Token has expired'] })
+        end
+        assert_equal 'Token has expired', e.message
+      end
+
+      should 'raise TokenExpired exception when a record has not been found' do
+        e = assert_raises EspSdk::RecordNotFound do
+          @client.send(:check_errors, { 'errors' => ['Record not found'] })
+        end
+        assert_equal 'Record not found', e.message
+      end
+
+      should 'join the return errors into a EspSdk::Exception' do
+        e = assert_raises EspSdk::Exception do
+          @client.send(:check_errors, { 'errors' => ['ARN is blank', 'External ID is blank'] })
+        end
+        assert_equal 'ARN is blank. External ID is blank', e.message
+      end
+    end
+  end
+end