kong 0.1.0

data/lib/kong/belongs_to_consumer.rb

@@ -0,0 +1,30 @@
+module Kong
+  module BelongsToConsumer
+    attr_accessor :consumer
+
+    # Convert API end point relative to Kong Consumer resource
+    def use_consumer_end_point
+      self.api_end_point = "/consumers/#{self.consumer_id}#{self.class::API_END_POINT}" if self.consumer_id
+    end
+
+    # Get Consumer resource
+    # @return [Kong::Consumer]
+    def consumer
+      @consumer ||= Consumer.find(self.consumer_id)
+    end
+
+    # Set Consumer resource
+    # @param [Kong::Consumer] consumer
+    def consumer=(consumer)
+      @consumer = consumer
+      self.consumer_id = consumer.id
+    end
+
+    # Set Consumer id
+    # @param [String] id
+    def consumer_id=(id)
+      super(id)
+      use_consumer_end_point
+    end
+  end
+end

data/lib/kong/client.rb

@@ -0,0 +1,226 @@
+require 'singleton'
+require 'json'
+require 'excon'
+require_relative './error'
+
+module Kong
+  class Client
+    include Singleton
+
+    attr_accessor :default_headers
+    attr_reader :http_client
+
+    # Initialize api client
+    #
+    def initialize
+      Excon.defaults[:ssl_verify_peer] = false if ignore_ssl_errors?
+      @api_url = api_url
+      @http_client = Excon.new(@api_url, omit_default_port: true)
+      @default_headers = { 'Accept' => 'application/json' }
+    end
+
+    def self.api_url
+      self.instance.api_url
+    end
+
+    def self.api_url=(url)
+      self.instance.api_url = url
+    end
+
+    # Kong Admin API URL
+    #
+    # @return [String]
+    def api_url      
+      @api_url ||= ENV['KONG_URI'] || 'http://localhost:8001'
+    end
+
+    def api_url=(url)
+      @api_url = url
+    end
+
+
+    # Get request
+    #
+    # @param [String] path
+    # @param [Hash,NilClass] params
+    # @param [Hash] headers
+    # @return [Hash]
+    def get(path, params = nil, headers = {})
+      response = http_client.get(
+        path: path,
+        query: encode_params(params),
+        headers: request_headers(headers)
+      )
+      if response.status == 200
+        parse_response(response)
+      else
+        handle_error_response(response)
+      end
+    end
+
+    # Post request
+    #
+    # @param [String] path
+    # @param [Object] obj
+    # @param [Hash] params
+    # @param [Hash] headers
+    # @return [Hash]
+    def post(path, obj, params = {}, headers = {})
+      request_headers = request_headers(headers)
+      request_options = {
+          path: path,
+          headers: request_headers,
+          body: encode_body(obj, request_headers['Content-Type']),
+          query: encode_params(params)
+      }
+      response = http_client.post(request_options)
+      if [200, 201].include?(response.status)
+        parse_response(response)
+      else
+        handle_error_response(response)
+      end
+    end
+
+    # Put request
+    #
+    # @param [String] path
+    # @param [Object] obj
+    # @param [Hash] params
+    # @param [Hash] headers
+    # @return [Hash]
+    def patch(path, obj, params = {}, headers = {})
+      request_headers = request_headers(headers)
+      request_options = {
+          path: path,
+          headers: request_headers,
+          body: encode_body(obj, request_headers['Content-Type']),
+          query: encode_params(params)
+      }
+
+      response = http_client.patch(request_options)
+      if [200, 201].include?(response.status)
+        parse_response(response)
+      else
+        handle_error_response(response)
+      end
+    end
+
+
+    # Put request
+    #
+    # @param [String] path
+    # @param [Object] obj
+    # @param [Hash] params
+    # @param [Hash] headers
+    # @return [Hash]
+    def put(path, obj, params = {}, headers = {})
+      request_headers = request_headers(headers)
+      request_options = {
+          path: path,
+          headers: request_headers,
+          body: encode_body(obj, request_headers['Content-Type']),
+          query: encode_params(params)
+      }
+
+      response = http_client.put(request_options)
+      if [200, 201].include?(response.status)
+        parse_response(response)
+      else
+        handle_error_response(response)
+      end
+    end
+
+    # Delete request
+    #
+    # @param [String] path
+    # @param [Hash,String] body
+    # @param [Hash] params
+    # @param [Hash] headers
+    # @return [Hash]
+    def delete(path, body = nil, params = {}, headers = {})
+      request_headers = request_headers(headers)
+      request_options = {
+          path: path,
+          headers: request_headers,
+          body: encode_body(body, request_headers['Content-Type']),
+          query: encode_params(params)
+      }
+      response = http_client.delete(request_options)
+      unless response.status == 204
+        handle_error_response(response)
+      end
+    end
+
+    private
+
+    ##
+    # Get request headers
+    #
+    # @param [Hash] headers
+    # @return [Hash]
+    def request_headers(headers = {})
+      @default_headers.merge(headers)
+    end
+
+    ##
+    # Encode body based on content type
+    #
+    # @param [Object] body
+    # @param [String] content_type
+    def encode_body(body, content_type)
+      if content_type == 'application/json'
+        dump_json(body)
+      else
+        body
+      end
+    end
+
+    def encode_params(params)
+      return nil if params.nil?
+      URI.encode_www_form(params)
+    end
+
+    ##
+    # Parse response
+    #
+    # @param [HTTP::Message]
+    # @return [Object]
+    def parse_response(response)
+      if response.headers['Content-Type'].include?('application/json')
+        parse_json(response.body)
+      else
+        response.body
+      end
+    end
+
+    ##
+    # Parse json
+    #
+    # @param [String] json
+    # @return [Hash,Object,NilClass]
+    def parse_json(json)
+      JSON.parse(json) rescue nil
+    end
+
+    ##
+    # Dump json
+    #
+    # @param [Object] obj
+    # @return [String]
+    def dump_json(obj)
+      JSON.dump(obj)
+    end
+
+    def ignore_ssl_errors?
+      ENV['SSL_IGNORE_ERRORS'] == 'true'
+    end
+
+    def handle_error_response(response)
+      message = response.body
+      if response.status == 404 && message == ''
+        message = 'Not found'
+      end
+      raise Error.new(response.status, message)
+    end
+  end
+end

data/lib/kong/consumer.rb

@@ -0,0 +1,71 @@
+module Kong
+  class Consumer
+    include Base
+
+    ATTRIBUTE_NAMES = %w(id custom_id username created_at).freeze
+    API_END_POINT = '/consumers/'.freeze
+
+    def delete
+      self.oauth2_tokens.each do |token|
+        token.delete
+      end
+      super
+    end
+
+    # List plugins
+    #
+    # @return [Array<Kong::Plugin>]
+    def plugins
+      Plugin.list({ consumer_id: self.id })
+    end
+
+    # List OAuth applications
+    #
+    # @return [Array<Kong::OAuthApp>]
+    def oauth_apps
+      apps = []
+      response = client.get("#{@api_end_point}#{self.username}/oauth2") rescue nil
+      if response
+        response['data'].each do |attributes|
+          apps << Kong::OAuthApp.new(attributes)
+        end
+      end
+      apps
+    end
+
+    # List KeyAuth credentials
+    #
+    # @return [Array<Kong::KeyAuth]
+    def basic_auths
+      apps = []
+      response = client.get("#{@api_end_point}#{self.username}/basic-auth") rescue nil
+      if response
+        response['data'].each do |attributes|
+          apps << Kong::BasicAuth.new(attributes)
+        end
+      end
+      apps
+    end
+
+    # List KeyAuth credentials
+    #
+    # @return [Array<Kong::KeyAuth]
+    def key_auths
+      apps = []
+      response = client.get("#{@api_end_point}#{self.username}/key-auth") rescue nil
+      if response
+        response['data'].each do |attributes|
+          apps << Kong::KeyAuth.new(attributes)
+        end
+      end
+      apps
+    end
+
+    # List OAuth2Tokens
+    #
+    # @return [Array<Kong::OAuth2Token>]
+    def oauth2_tokens
+      OAuth2Token.list({ authenticated_userid: self.custom_id })
+    end
+  end
+end

data/lib/kong/error.rb

@@ -0,0 +1,8 @@
+module Kong
+  class Error < StandardError
+    def initialize(status, message)
+      @status = status
+      super(message)
+    end
+  end
+end

data/lib/kong/key_auth.rb

@@ -0,0 +1,8 @@
+module Kong
+  class KeyAuth
+    include Base
+    include BelongsToConsumer
+    ATTRIBUTE_NAMES = %w(id key consumer_id).freeze
+    API_END_POINT = "/key-auth/".freeze
+  end
+end

data/lib/kong/oauth2_token.rb

@@ -0,0 +1,14 @@
+require_relative './base'
+module Kong
+  class OAuth2Token
+    include Base
+    ATTRIBUTE_NAMES = %w(id credential_id expires_in created_at token_type access_token refresh_token scope authenticated_userid).freeze
+    API_END_POINT = "/oauth2_tokens/".freeze
+
+    # Get OAuthApp resource
+    # @return [Kong::OAuthApp]
+    def oauth_app
+      Kong::OAuthApp.find_by_id(self.credential_id)
+    end
+  end
+end

data/lib/kong/oauth_app.rb

@@ -0,0 +1,8 @@
+module Kong
+  class OAuthApp
+    include Base
+    include BelongsToConsumer
+    ATTRIBUTE_NAMES = %w(id name client_id client_secret redirect_uri consumer_id).freeze
+    API_END_POINT = "/oauth2/".freeze
+  end
+end

data/lib/kong/plugin.rb

@@ -0,0 +1,9 @@
+module Kong
+  class Plugin
+    include Base
+    include BelongsToApi
+
+    ATTRIBUTE_NAMES = %w(id api_id name config enabled consumer_id).freeze
+    API_END_POINT = '/plugins/'.freeze
+  end
+end

data/lib/kong/version.rb

@@ -0,0 +1,3 @@
+module Kong
+  VERSION = '0.1.0'.freeze
+end

data/spec/kong/api_spec.rb

@@ -0,0 +1,27 @@
+require_relative "../spec_helper"
+
+describe Kong::Api do
+  let(:valid_attribute_names) do
+    %w(id name request_host request_path strip_request_path preserve_host upstream_url)
+  end
+
+  describe 'ATTRIBUTE_NAMES' do
+    it 'contains valid names' do
+      expect(subject.class::ATTRIBUTE_NAMES).to eq(valid_attribute_names)
+    end
+  end
+
+  describe 'API_END_POINT' do
+    it 'contains valid end point' do
+      expect(subject.class::API_END_POINT).to eq('/apis/')
+    end
+  end
+
+  describe '.plugins' do
+    it 'requests plugins attached to Api' do
+      subject.id = '12345'
+      expect(Kong::Plugin).to receive(:list).with({ api_id: subject.id })
+      subject.plugins
+    end
+  end
+end

data/spec/kong/base_spec.rb

@@ -0,0 +1,147 @@
+require_relative "../spec_helper"
+
+describe Kong::Base do
+
+  let(:resource_class) do
+    Class.new do
+      include Kong::Base
+
+    end
+  end
+
+  let(:subject) do
+    Klass.new
+  end
+
+  before do
+    stub_const 'Klass', resource_class
+    stub_const 'Klass::API_END_POINT', '/resources/'
+    stub_const 'Klass::ATTRIBUTE_NAMES', %w(id name)
+  end
+
+  describe '.list' do
+    it 'requests GET /:resource_end_point/' do
+      expect(Kong::Client.instance).to receive(:get).with('/resources/', {}).and_return({ data: [] })
+      Klass.list
+    end
+
+    it 'returns array of resource instances' do
+      allow(Kong::Client.instance).to receive(:get).with('/resources/', {})
+        .and_return({ 'data' => [{ 'id' => '12345', 'name' => 'resource' }] })
+      result = Klass.list
+      expect(result[0].is_a?(Klass)).to be_truthy
+    end
+  end
+
+  describe '.all' do
+    it 'is alias of .list' do
+      expect(Klass.method(:list)).to eq(Klass.method(:all))
+    end
+  end
+
+  describe '.find' do
+    it 'creates GET /:resource_end_point/:id request' do
+      expect(Kong::Client.instance).to receive(:get).with('/resources/12345').and_return({ data: [] })
+      Klass.find('12345')
+    end
+  end
+
+  describe '#get' do
+    it 'creates GET /:resource_end_point/:id request' do
+      expect(Kong::Client.instance).to receive(:get).with('/resources/12345').and_return({ data: [] })
+      subject.get('12345')
+    end
+
+    it 'returns resource instance' do
+      allow(Kong::Client.instance).to receive(:get).with('/resources/12345')
+        .and_return({ 'data' => [{ 'id' => '12345', 'name' => 'resource' }] })
+      result = subject.get('12345')
+      expect(result.is_a?(Klass)).to be_truthy
+    end
+
+    it 'returns nil if resource is not found' do
+      allow(Kong::Client.instance).to receive(:get).with('/resources/123456')
+        .and_return(nil)
+      result = subject.get('123456')
+      expect(result).to be_nil
+    end
+  end
+
+  describe '#new?' do
+    it 'returns true if resource id is missing' do
+      expect(subject.new?).to be_truthy
+    end
+
+    it 'returns false if resource has id' do
+      subject.id = '12345'
+      expect(subject.new?).to be_falsey
+    end
+  end
+
+  describe '#create' do
+    it 'creates POST /:resource_end_point/ request with resource attributes' do
+      headers = { 'Content-Type' => 'application/x-www-form-urlencoded' }
+      attributes = { 'name' => 'test object' }
+      expect(Kong::Client.instance).to receive(:post).with('/resources/', nil, attributes, headers)
+        .and_return(attributes)
+      subject.name = 'test object'
+      subject.create
+    end
+
+    it 'returns resource instance' do
+      headers = { 'Content-Type' => 'application/x-www-form-urlencoded' }
+      attributes = { 'name' => 'test object' }
+      allow(Kong::Client.instance).to receive(:post).with('/resources/', nil, attributes, headers)
+        .and_return(attributes.merge({ 'id' => '12345' }))
+      subject.name = 'test object'
+      expect(subject.create).to eq(subject)
+      expect(subject.id).to eq('12345')
+    end
+  end
+
+  describe '#create_or_update' do
+    it 'creates PUT /:resource_end_point/ request with resource attributes as json payload' do
+      headers = { 'Content-Type' => 'application/json' }
+      attributes = { 'name' => 'test object' }
+      expect(Kong::Client.instance).to receive(:put).with('/resources/', attributes, nil, headers)
+        .and_return(attributes.merge({ 'id' => '12345' }))
+      subject.name = 'test object'
+      subject.create_or_update
+    end
+
+    it 'returns resource instance' do
+      headers = { 'Content-Type' => 'application/json' }
+      attributes = { 'name' => 'test object' }
+      expect(Kong::Client.instance).to receive(:put).with('/resources/', attributes, nil, headers)
+        .and_return(attributes.merge({ 'id' => '12345' }))
+      subject.name = 'test object'
+      expect(subject.create_or_update).to eq(subject)
+    end
+
+    describe '#update' do
+      it 'creates PATCH /:resource_end_point/:resource_id request with resource attributes' do
+        headers = { 'Content-Type' => 'application/x-www-form-urlencoded' }
+        subject.id = '12345'
+        subject.name = 'test object'
+        expect(Kong::Client.instance).to receive(:patch).with('/resources/12345', nil, subject.attributes, headers)
+          .and_return(subject.attributes)
+        subject.update
+      end
+
+      it 'returns resource instance' do
+        headers = { 'Content-Type' => 'application/x-www-form-urlencoded' }
+        subject.id = '12345'
+        subject.name = 'test object'
+        allow(Kong::Client.instance).to receive(:patch).with('/resources/12345', nil, subject.attributes, headers)
+          .and_return(subject.attributes)
+        expect(subject.update).to eq(subject)
+      end
+    end
+
+    it 'will respond to attribute' do
+      expect(subject.respond_to?(:name)).to be_truthy
+    end
+
+  end
+
+end