kong-client 0.4.0

data/spec/kong/base_spec.rb

@@ -0,0 +1,169 @@
+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 '.respond_to' do
+    context 'when attribute exits' do
+      it 'will respond to find_by_* methods' do
+        expect(Klass.respond_to?(:find_by_name)).to be_truthy
+      end
+
+      it 'will respond to find_all_by_* methods' do
+        expect(Klass.respond_to?(:find_all_by_name)).to be_truthy
+      end
+    end
+
+    context 'when attribute does not exit' do
+      it 'will not respond to find_by_* methods' do
+        expect(Klass.respond_to?(:find_by_invalid)).to be_falsey
+      end
+
+      it 'will not respond to find_all_by_* methods' do
+        expect(Klass.respond_to?(:find_all_by_invalid)).to be_falsey
+      end
+    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/json' }
+      attributes = { 'name' => 'test object' }
+      expect(Kong::Client.instance).to receive(:post).with('/resources/', attributes, nil, headers)
+        .and_return(attributes)
+      subject.name = 'test object'
+      subject.create
+    end
+
+    it 'returns resource instance' do
+      headers = { 'Content-Type' => 'application/json' }
+      attributes = { 'name' => 'test object' }
+      allow(Kong::Client.instance).to receive(:post).with('/resources/', attributes, nil, 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/json' }
+        subject.id = '12345'
+        subject.name = 'test object'
+        expect(Kong::Client.instance).to receive(:patch).with('/resources/12345', subject.attributes, nil, headers)
+          .and_return(subject.attributes)
+        subject.update
+      end
+
+      it 'returns resource instance' do
+        headers = { 'Content-Type' => 'application/json' }
+        subject.id = '12345'
+        subject.name = 'test object'
+        allow(Kong::Client.instance).to receive(:patch).with('/resources/12345', subject.attributes, nil, 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

data/spec/kong/basic_auth_spec.rb

@@ -0,0 +1,26 @@
+require_relative "../spec_helper"
+
+describe Kong::BasicAuth do
+  let(:valid_attribute_names) do
+    %w(id username password consumer_id)
+  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('/basic-auth/')
+    end
+  end
+
+  describe '#init_attributes' do
+    it 'uses correct api end point if api_id is present' do
+      subject = described_class.new({ consumer_id: ':consumer_id' })
+      expect(subject.api_end_point).to eq('/consumers/:consumer_id/basic-auth/')
+    end
+  end
+end

data/spec/kong/client_spec.rb

@@ -0,0 +1,297 @@
+require_relative "../spec_helper"
+
+describe Kong::Client do
+
+  let(:subject) do
+    described_class.instance
+  end
+
+  let(:http_client) do
+    spy
+  end
+
+  describe '#initialize' do
+    it 'initializes Excon with Kong URI' do
+      described_class.api_url = nil
+      expect(Excon).to receive(:new).with('http://localhost:8001', { omit_default_port: true })
+      described_class.send(:new)
+    end
+
+    it 'initializes default headers' do
+      expect(described_class.instance.default_headers).to eq({ 'Accept' => 'application/json' })
+      described_class.send(:new)
+    end
+  end
+
+  describe '#api_url' do
+
+    def client_params
+      uri = URI.parse described_class.api_url
+      params = {
+        host: uri.host,
+        hostname: uri.hostname,
+        path: uri.path,
+        port: uri.port,
+        query: uri.query,
+        scheme: uri.scheme
+      }
+      described_class.instance.http_client.params.merge(params)
+    end
+
+    it 'returns localhost as default' do
+      described_class.api_url = nil
+      expect(subject.api_url).to eq('http://localhost:8001')
+    end
+
+    it 'returns value from environment variable' do
+      allow(ENV).to receive(:[]).with('NO_PROXY')
+      allow(ENV).to receive(:[]).with('no_proxy')
+      allow(ENV).to receive(:[]).with('SSL_IGNORE_ERRORS')
+      allow(ENV).to receive(:[]).with('KONG_URI').and_return('http://kong-api:8001')
+      described_class.api_url = nil
+      subject = described_class.send(:new)
+      expect(subject.api_url).to eq('http://kong-api:8001')
+    end
+
+    it 'returns custom api_url if set' do
+      url = 'http://foo.bar:1337'
+      described_class.api_url = url
+      expect(described_class.send(:new).api_url).to eq(url)
+    end
+
+    it 'can edit api_url' do
+      described_class.api_url = nil
+      expect(described_class.instance.http_client.params).to eq(client_params)
+      described_class.api_url = 'http://foo.bar:1337'
+      expect(described_class.instance.http_client.params).to eq(client_params)
+    end
+  end
+
+  describe '#get' do
+    before(:each) do
+      allow(subject).to receive(:http_client).and_return(http_client)
+    end
+    it 'creates HTTP GET request with given params' do
+      http_client_params = {
+        path: 'path',
+        query: { key: 'value' },
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(200)
+      expect(http_client).to receive(:get).and_return(response)
+      subject.get('path', { key: 'value' })
+    end
+
+    it 'raises Kong::Error if request returns error' do
+      http_client_params = {
+        path: 'path',
+        query: { key: 'value' },
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(403)
+      expect(http_client).to receive(:get).and_return(response)
+      expect {
+        subject.get('path', { key: 'value' })
+      }.to raise_error(Kong::Error)
+    end
+
+    it 'parses response JSON' do
+      http_client_params = {
+        path: 'path',
+        query: { key: 'value' },
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(200)
+      allow(response).to receive(:body).and_return({ id: '12345' }.to_json)
+      allow(response).to receive(:headers).and_return({ 'Content-Type' => 'application/json' })
+      allow(http_client).to receive(:get).and_return(response)
+      expect(subject.get('path', { key: 'value' })).to eq({ 'id' => '12345' })
+    end
+
+    it 'returns response text' do
+      http_client_params = {
+        path: 'path',
+        query: { key: 'value' },
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(200)
+      allow(response).to receive(:body).and_return('<html></html>')
+      allow(response).to receive(:headers).and_return({ 'Content-Type' => 'text/html' })
+      allow(http_client).to receive(:get).and_return(response)
+      expect(subject.get('path', { key: 'value' })).to eq('<html></html>')
+    end
+  end
+
+  describe '#post' do
+    before(:each) do
+      allow(subject).to receive(:http_client).and_return(http_client)
+    end
+    it 'creates HTTP POST request with given params' do
+      http_client_params = {
+        path: 'path',
+        query: { key: 'value' },
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(200)
+      expect(http_client).to receive(:post).and_return(response)
+      subject.post('path', nil, { key: 'value' })
+    end
+
+
+    it 'raises Kong::Error if request returns error' do
+      http_client_params = {
+        path: 'path',
+        query: { key: 'value' },
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(403)
+      expect(http_client).to receive(:post).and_return(response)
+      expect {
+        subject.post('path', nil, { key: 'value' })
+      }.to raise_error(Kong::Error)
+    end
+
+    it 'parses response JSON' do
+      http_client_params = {
+        path: 'path',
+        query: { key: 'value' },
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(200)
+      allow(response).to receive(:body).and_return({ id: '12345' }.to_json)
+      allow(response).to receive(:headers).and_return({ 'Content-Type' => 'application/json' })
+      allow(http_client).to receive(:post).and_return(response)
+      expect(subject.post('path', nil, { key: 'value' })).to eq({ 'id' => '12345' })
+    end
+  end
+  describe '#patch' do
+    before(:each) do
+      allow(subject).to receive(:http_client).and_return(http_client)
+    end
+    it 'creates HTTP PATCH request with given params' do
+      http_client_params = {
+        path: 'path',
+        query: { key: 'value' },
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(200)
+      expect(http_client).to receive(:patch).and_return(response)
+      subject.patch('path', nil, { key: 'value' })
+    end
+
+
+    it 'raises Kong::Error if request returns error' do
+      http_client_params = {
+        path: 'path',
+        query: { key: 'value' },
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(403)
+      expect(http_client).to receive(:patch).and_return(response)
+      expect {
+        subject.patch('path', nil, { key: 'value' })
+      }.to raise_error(Kong::Error)
+    end
+
+    it 'parses response JSON' do
+      http_client_params = {
+        path: 'path',
+        query: { key: 'value' },
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(200)
+      allow(response).to receive(:body).and_return({ id: '12345' }.to_json)
+      allow(response).to receive(:headers).and_return({ 'Content-Type' => 'application/json' })
+      allow(http_client).to receive(:patch).and_return(response)
+      expect(subject.patch('path', nil, { key: 'value' })).to eq({ 'id' => '12345' })
+    end
+  end
+
+  describe '#put' do
+    before(:each) do
+      allow(subject).to receive(:http_client).and_return(http_client)
+    end
+    it 'creates HTTP PUT request with given params' do
+      http_client_params = {
+        path: 'path',
+        query: { key: 'value' },
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(200)
+      expect(http_client).to receive(:put).and_return(response)
+      subject.put('path', nil, { key: 'value' })
+    end
+
+
+    it 'raises Kong::Error if request returns error' do
+      http_client_params = {
+        path: 'path',
+        query: { key: 'value' },
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(403)
+      expect(http_client).to receive(:put).and_return(response)
+      expect {
+        subject.put('path', nil, { key: 'value' })
+      }.to raise_error(Kong::Error)
+    end
+
+    it 'parses response JSON' do
+      http_client_params = {
+        path: 'path',
+        query: { key: 'value' },
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(200)
+      allow(response).to receive(:body).and_return({ id: '12345' }.to_json)
+      allow(response).to receive(:headers).and_return({ 'Content-Type' => 'application/json' })
+      allow(http_client).to receive(:put).and_return(response)
+      expect(subject.put('path', nil, { key: 'value' })).to eq({ 'id' => '12345' })
+    end
+  end
+
+  describe '#delete' do
+    before(:each) do
+      allow(subject).to receive(:http_client).and_return(http_client)
+    end
+    it 'creates HTTP DELETE request with given params' do
+      http_client_params = {
+        path: 'path',
+        query: {},
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(204)
+      expect(http_client).to receive(:delete).and_return(response)
+      subject.delete('path', nil, {})
+    end
+
+
+    it 'raises Kong::Error if request returns other than 204' do
+      http_client_params = {
+        path: 'path',
+        query: {},
+        headers: {}
+      }
+      response = spy
+      allow(response).to receive(:status).and_return(403)
+      expect(http_client).to receive(:delete).and_return(response)
+      expect {
+        subject.delete('path', nil, {})
+      }.to raise_error(Kong::Error)
+    end
+  end
+end

data/spec/kong/consumer_spec.rb

@@ -0,0 +1,72 @@
+require_relative "../spec_helper"
+
+describe Kong::Consumer do
+  let(:valid_attribute_names) do
+    %w(id custom_id username created_at)
+  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('/consumers/')
+    end
+  end
+
+  describe '#oauth_apps' do
+    it 'requests consumer\'s oauth_apps' do
+      subject.id = ':id'
+      expect(Kong::Client.instance).to receive(:get).with("/consumers/:id/oauth2")
+        .and_return({ 'data' => [{ 'id' => '123456', 'name' => 'my app' }] })
+      subject.oauth_apps
+    end
+
+    it 'returns list of OAuthApp' do
+      subject.id = ':id'
+      allow(Kong::Client.instance).to receive(:get).with("/consumers/:id/oauth2")
+        .and_return({ 'data' => [{ 'id' => '123456', 'name' => 'my app' }] })
+      result = subject.oauth_apps
+      expect(result.first.is_a?(Kong::OAuthApp)).to be_truthy
+    end
+  end
+
+  describe '#oauth2_tokens' do
+    context 'when custom_id is set' do
+      it 'requests oauth2_tokens assigned to consumer' do
+        subject.custom_id = 'custom_id'
+        expect(Kong::OAuth2Token).to receive(:list).with({ authenticated_userid: subject.custom_id })
+        subject.oauth2_tokens
+      end
+    end
+    context 'when custom_id is not set' do
+      it 'requests oauth2_tokens assigned to consumer' do
+        expect(Kong::OAuth2Token).not_to receive(:list)
+        subject.oauth2_tokens
+      end
+      it 'returns empty array' do
+        expect(subject.oauth2_tokens).to eq([])
+      end
+    end
+  end
+
+  describe '#acls' do
+    it 'requests consumer\'s acls' do
+      subject.id = ':id'
+      expect(Kong::Client.instance).to receive(:get).with("/consumers/:id/acls")
+        .and_return({ 'data' => [{ 'id' => '123456', 'group' => 'group1' }] })
+      subject.acls
+    end
+
+    it 'returns list of Acls' do
+      subject.id = ':id'
+      allow(Kong::Client.instance).to receive(:get).with("/consumers/:id/acls")
+        .and_return({ 'data' => [{ 'id' => '123456', 'group' => 'group1' }] })
+      result = subject.acls
+      expect(result.first.is_a?(Kong::Acl)).to be_truthy
+    end
+  end
+end

data/spec/kong/error_spec.rb

@@ -0,0 +1,23 @@
+require_relative "../spec_helper"
+
+describe Kong::Error do
+  let(:instance) { described_class.new(status, message) }
+  let(:status) { 123 }
+  let(:message) { 'Error Message' }
+
+  describe '.status' do
+    subject { instance.status }
+
+    it 'exposes error status' do
+      is_expected.to eq status
+    end
+  end
+
+  describe '.message' do
+    subject { instance.message }
+
+    it 'exposes error message' do
+      is_expected.to eq message
+    end
+  end
+end

data/spec/kong/hmac_auth_spec.rb

@@ -0,0 +1,26 @@
+require_relative "../spec_helper"
+
+describe Kong::HmacAuth do
+  let(:valid_attribute_names) do
+    %w(id username consumer_id)
+  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('/hmac-auth/')
+    end
+  end
+
+  describe '#init_attributes' do
+    it 'uses correct api end point if api_id is present' do
+      subject = described_class.new({ consumer_id: ':consumer_id' })
+      expect(subject.api_end_point).to eq('/consumers/:consumer_id/hmac-auth/')
+    end
+  end
+end

data/spec/kong/key_auth_spec.rb

@@ -0,0 +1,26 @@
+require_relative "../spec_helper"
+
+describe Kong::KeyAuth do
+  let(:valid_attribute_names) do
+    %w(id key consumer_id)
+  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('/key-auth/')
+    end
+  end
+
+  describe '#init_attributes' do
+    it 'uses correct api end point if api_id is present' do
+      subject = described_class.new({ consumer_id: ':consumer_id' })
+      expect(subject.api_end_point).to eq('/consumers/:consumer_id/key-auth/')
+    end
+  end
+end

data/spec/kong/oauth2_token_spec.rb

@@ -0,0 +1,19 @@
+require_relative "../spec_helper"
+
+describe Kong::OAuth2Token do
+  let(:valid_attribute_names) do
+    %w(id credential_id expires_in created_at token_type access_token refresh_token scope authenticated_userid)
+  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('/oauth2_tokens/')
+    end
+  end
+end

data/spec/kong/oauth_app_spec.rb

@@ -0,0 +1,19 @@
+require_relative "../spec_helper"
+
+describe Kong::OAuthApp do
+  let(:valid_attribute_names) do
+    %w(id name client_id client_secret redirect_uri consumer_id)
+  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('/oauth2/')
+    end
+  end
+end