kosapi_client 0.5.0 → 0.6.0

data/spec/kosapi_client/http_client_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::HTTPClient do
-
-  let(:response) { double(parsed: {}) }
-  let(:http_adapter) { instance_double(KOSapiClient::OAuth2HttpAdapter) }
-  let(:preprocessed_hash) { {} }
-  let(:preprocessor) { instance_double(KOSapiClient::ResponsePreprocessor, preprocess: preprocessed_hash) }
-  let(:converter) { instance_double(KOSapiClient::ResponseConverter, convert: nil) }
-  subject(:client) { KOSapiClient::HTTPClient.new(http_adapter, preprocessor, converter) }
-
-  describe '#send_request' do
-
-    it 'calls http adapter' do
-      expect(http_adapter).to receive(:send_request).and_return(response)
-      client.send_request(:get, 'http://example.com')
-    end
-
-  end
-
-  describe '#process_response' do
-
-    it 'converts items with converter' do
-      expect(converter).to receive(:convert).and_return(:foo)
-      expect(client.process_response(nil)).to eq(:foo)
-    end
-
-  end
-
-end

data/spec/kosapi_client/kosapi_client_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient do
-
-  before do
-    KOSapiClient.configure do |c|
-      c.client_id = 'foo'
-      c.client_secret = 'bar'
-    end
-    @client = KOSapiClient.client
-  end
-
-  describe '.configure' do
-
-    it 'can be configured via block' do
-      expect(@client).not_to be_nil
-    end
-
-  end
-
-  describe '.reset' do
-
-    it 'cleans stored ApiClient instance' do
-      KOSapiClient.reset
-      expect(KOSapiClient.client).not_to be @client
-    end
-
-  end
-
-  describe '.client' do
-
-    it 'provides client instance via reader' do
-      expect(KOSapiClient.client).to eq @client
-    end
-
-  end
-
-  it 'delegates missing methods to stored client instance' do
-    expect(@client).to receive(:course_events)
-    KOSapiClient.course_events
-  end
-
-  it 'handles missing methods not defined on client' do
-    expect { KOSapiClient.foo }.to raise_error NoMethodError
-  end
-
-  it 'throws error when sending request with no configured credentials' do
-    KOSapiClient.reset
-    expect { KOSapiClient.course_events.items }.to raise_error(RuntimeError)
-  end
-
-  it 'responds to client methods' do
-    allow(@client).to receive(:foo)
-    expect(KOSapiClient).to respond_to(:foo)
-  end
-
-end

data/spec/kosapi_client/kosapi_response_spec.rb

@@ -1,96 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::KOSapiResponse do
-
-  subject(:response) { KOSapiClient::KOSapiResponse.new(result) }
-  let(:client) { instance_double(KOSapiClient::HTTPClient) }
-
-  context 'with paginated response' do
-    let(:result) { {atom_feed: {atom_entry: [:entry1, :entry2], atom_link: [{rel: 'prev', href: 'courses/?offset=0&limit=10'}, {rel: 'next', href: 'courses/?offset=20&limit=10'}]}} }
-
-    describe '#is_paginated?' do
-
-      it 'returns true when result contains atom feed' do
-        expect(response.is_paginated?).to be
-      end
-
-    end
-
-    describe '#items' do
-
-      it 'returns all entries' do
-        expect(response.items).to eq [:entry1, :entry2]
-      end
-
-    end
-
-    describe '#item' do
-
-      it 'returns first entry' do
-        expect(response.item).to eq :entry1
-      end
-
-    end
-
-    describe '#links_hash' do
-
-      it 'extracts links from feed' do
-        expect(response.links_hash).to eq [{rel: 'prev', href: 'courses/?offset=0&limit=10'}, {rel: 'next', href: 'courses/?offset=20&limit=10'}]
-      end
-
-
-      context 'with single link' do
-        let(:result) { {atom_feed: {atom_link: {rel: 'next', href: 'courses/?offset=10&limit=10'}}} }
-
-        it 'extracts next link from feed' do
-          expect(response.links_hash).to eq({rel: 'next', href: 'courses/?offset=10&limit=10'})
-        end
-      end
-
-      context 'with no links' do
-        let(:result) { {atom_feed: {}} }
-
-        it 'returns null' do
-          expect(response.links_hash).not_to be
-        end
-      end
-
-    end
-
-  end
-
-  context 'with not-paginated response' do
-    let(:result) { { atom_entry: :entry} }
-
-    describe '#is_paginated?' do
-
-      it 'returns false when result contains atom feed' do
-        expect(response.is_paginated?).not_to be
-      end
-
-    end
-
-    describe '#items' do
-
-      it 'returns single entry wrapped in array' do
-        expect(response.items).to eq [:entry]
-      end
-
-    end
-
-    describe '#item' do
-
-      it 'returns first entry' do
-        expect(response.item).to eq :entry
-      end
-
-    end
-
-    describe '#links_hash' do
-      it 'returns null' do
-        expect(response.links_hash).not_to be
-      end
-    end
-  end
-
-end

data/spec/kosapi_client/oauth2_http_adapter_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::OAuth2HttpAdapter, :vcr do
-  KOSAPI_ROOT_URL = 'https://kosapi.fit.cvut.cz/api/3/'
-  subject(:client) { KOSapiClient::OAuth2HttpAdapter.new(credentials, KOSAPI_ROOT_URL) }
-
-
-  context 'with invalid OAUTH credentials' do
-    let(:credentials) { { client_id: 'invalid_client_id', client_secret: 'invalid_secret' } }
-
-    it 'throws authentication error when fetching resource' do
-      expect { client.send_request(:get, 'courses') }.to raise_error(OAuth2::Error)
-    end
-  end
-
-  context 'with valid OAUTH credentials' do
-    let(:credentials) { { client_id: ENV['KOSAPI_OAUTH_CLIENT_ID'], client_secret: ENV['KOSAPI_OAUTH_CLIENT_SECRET'] } }
-
-    it 'fetches response from a REST resource' do
-      response = client.send_request(:get, 'courses')
-      expect(response).not_to be_nil
-    end
-
-  end
-end

data/spec/kosapi_client/request_builder_delegator_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::RequestBuilderDelegator do
-
-  let(:response) { double(:response) }
-  let(:builder) { double(:builder, response: response, finalize: nil) }
-  let(:block) { -> { 1 + 1 } }
-  subject(:delegator) { KOSapiClient::RequestBuilderDelegator.new(builder) }
-
-  describe '#method_missing' do
-
-    it 'delegates methods which builder responds to, to the builder' do
-      expect(builder).to receive(:foo)
-      delegator.foo
-    end
-
-    it 'evaluates builder when builder is not responding to a delegated method' do
-      expect(builder).to receive(:finalize)
-      expect(response).to receive(:bar)
-      delegator.bar
-    end
-
-    it 'delegates all methods to response once RequestBuilder is evaluated' do
-      allow(response).to receive(:bar)
-      expect(builder).not_to receive(:foo)
-      delegator.bar
-      expect { delegator.foo }.to raise_error(NoMethodError)
-    end
-
-    it 'throws error when method is not defined on builder or response' do
-      expect { delegator.foo }.to raise_error(NoMethodError)
-    end
-
-    it 'replaces builder.self with self' do
-      allow(builder).to receive(:foo).and_return(builder)
-      expect(delegator.foo).to be delegator
-    end
-
-    it 'delegates call with block to builder' do
-      allow(builder).to receive(:foo).with(:x) do |arg, &block|
-        expect(block).not_to be_nil
-      end
-
-      delegator.foo(:x, &block)
-    end
-
-    it 'delegates call with block to response' do
-      allow(response).to receive(:foo).with(:x) do |arg, &block|
-        expect(block).not_to be_nil
-      end
-
-      delegator.foo(:x, &block)
-    end
-
-  end
-
-  describe '#respond_to_missing?' do
-
-    it 'responds to methods on builder' do
-      allow(builder).to receive(:foo)
-      expect(delegator).to respond_to(:foo)
-    end
-
-    it 'responds to methods on response when evaluated' do
-      allow(response).to receive(:foo)
-      delegator.foo
-      expect(delegator).to respond_to(:foo)
-    end
-
-  end
-
-end

data/spec/kosapi_client/request_builder_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::RequestBuilder do
-
-  let(:url_builder) { instance_double(KOSapiClient::URLBuilder, url: 'http://example.com', set_path: nil, set_query_param: nil) }
-  let(:response) { double(foo: :bar) }
-  let(:http_client) { double(send_request: response) }
-  subject(:builder) { KOSapiClient::RequestBuilder.new('http://example.com', http_client, url_builder) }
-
-
-
-  describe '#finalize' do
-
-    it 'sends http request' do
-      expect(http_client).to receive(:send_request)
-      builder.finalize
-    end
-
-    it 'stores response' do
-      builder.finalize
-      expect(builder.response).to eq response
-    end
-
-  end
-
-  describe '#find' do
-
-    it_behaves_like 'fluent api command', method_name, 10
-
-    it 'sets path in URL' do
-      expect(url_builder).to receive(:set_path).with(10)
-      builder.find(10)
-    end
-
-  end
-
-  describe '#offset' do
-
-    it_behaves_like 'fluent api command', method_name, 10
-
-    it 'sets query param' do
-      expect(url_builder).to receive(:set_query_param).with(:offset, 10)
-      builder.offset(10)
-    end
-
-  end
-
-  describe '#limit' do
-
-    it_behaves_like 'fluent api command', method_name, 10
-
-    it 'sets query param' do
-      expect(url_builder).to receive(:set_query_param).with(:limit, 10)
-      builder.limit(10)
-    end
-
-  end
-
-  describe '#query' do
-
-    it_behaves_like 'fluent api command', method_name, foo: 10
-
-    it 'sets query param' do
-      expect(url_builder).to receive(:set_query_param).with(:query, 'foo==10;bar==20')
-      builder.query(foo: 10, bar: 20)
-    end
-
-    it 'throws error when params are empty' do
-      expect { builder.query({}) }.to raise_error(RuntimeError)
-    end
-
-    it 'accepts string instead of a hash' do
-      expect(url_builder).to receive(:set_query_param).with(:query, 'foo==10;bar==20')
-      builder.query('foo==10;bar==20')
-    end
-
-  end
-
-
-end

data/spec/kosapi_client/resource/courses_builder_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::Resource::CoursesBuilder do
-
-  let(:url_builder) { instance_double(KOSapiClient::URLBuilder, url: 'http://example.com', set_query_param: nil) }
-  let(:response) { double(foo: :bar) }
-  let(:http_client) { double(send_request: response) }
-  subject(:builder) { KOSapiClient::Resource::CoursesBuilder.new('http://example.com', http_client, url_builder) }
-
-  describe '#detail' do
-
-    it_behaves_like 'fluent api command', method_name, 10
-
-    it 'sets detail query parameter' do
-      expect(url_builder).to receive(:set_query_param).with(:detail, 1)
-      builder.detail
-    end
-
-  end
-end

data/spec/kosapi_client/resource/parallels_builder_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::Resource::ParallelsBuilder do
-
-  let(:url_builder) { instance_double(KOSapiClient::URLBuilder, url: 'http://example.com') }
-  let(:response) { double(foo: :bar) }
-  let(:http_client) { double(send_request: response) }
-  subject(:builder) { KOSapiClient::Resource::ParallelsBuilder.new('http://example.com', http_client, url_builder) }
-
-  describe '#related' do
-
-    before { allow(url_builder).to receive(:set_path) }
-
-    it 'throws error when parallel id not set' do
-      expect { builder.related }.to raise_error(RuntimeError)
-    end
-
-    it 'returns self' do
-      builder.find(42)
-      expect(builder.related).to eq builder
-    end
-
-    it 'adds related to URL' do
-      expect(url_builder).to receive(:set_path).with(42, 'related')
-      builder.find(42).related
-    end
-
-  end
-
-  describe '#students' do
-
-    before { allow(url_builder).to receive(:set_path) }
-
-    it 'throws error when parallel id not set' do
-      expect { builder.students }.to raise_error(RuntimeError)
-    end
-
-    it 'returns self' do
-      builder.find(42)
-      expect(builder.students).to eq builder
-    end
-
-    it 'adds students to URL' do
-      expect(url_builder).to receive(:set_path).with(42, 'students')
-      builder.find(42).students
-    end
-
-  end
-end

data/spec/kosapi_client/resource_mapper_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::ResourceMapper do
-
-  let(:dummy_class) { Class.new { include KOSapiClient::ResourceMapper } }
-  let(:dummy_instance) { dummy_class.new }
-
-  it 'defines class method .resource' do
-    expect(dummy_class).to respond_to(:resource)
-  end
-
-  describe '.resource' do
-
-    it 'creates instance method with the resource name' do
-      dummy_class.resource(:foo)
-      expect(dummy_instance).to respond_to(:foo)
-    end
-
-    it 'creates method which returns builder delegator' do
-      dummy_class.resource(:foo)
-      allow(dummy_instance).to receive(:create_builder)
-      expect(dummy_instance.foo).to be_an_instance_of(KOSapiClient::RequestBuilderDelegator)
-    end
-
-    it 'calls #create_builder' do
-      dummy_class.resource(:foo)
-      expect(dummy_instance).to receive(:create_builder).with(:foo)
-      dummy_instance.foo
-    end
-
-  end
-
-end

data/spec/kosapi_client/response_converter_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::ResponseConverter do
-
-  let(:client) { instance_double(KOSapiClient::HTTPClient) }
-  subject(:converter) { described_class.new(client) }
-
-  describe '#convert' do
-
-    context 'with paginated response' do
-
-      let(:next_link) { instance_double(KOSapiClient::Entity::Link) }
-      let(:prev_link) { instance_double(KOSapiClient::Entity::Link) }
-      let(:links) { instance_double(KOSapiClient::ResponseLinks, next: next_link, prev: prev_link) }
-      let(:api_response) { double(is_paginated?: true, items: [{xsi_type: 'courseEvent', capacity: 70}, {xsi_type: 'courseEvent', capacity: 40}], links_hash: links) }
-
-      before(:each) { allow(converter).to receive(:create_links).and_return(links) }
-
-      it 'processes paginated response' do
-        result = converter.convert(api_response)
-        expect(result).to be_an_instance_of(KOSapiClient::Entity::ResultPage)
-      end
-
-      it 'creates next link' do
-        result = converter.convert(api_response)
-        expect(result.next).to be next_link
-      end
-
-      it 'creates prev link' do
-        result = converter.convert(api_response)
-        expect(result.prev).to be prev_link
-      end
-    end
-
-    context 'with single entry response' do
-
-      let(:api_response) { double(is_paginated?: false, item: {xsi_type: 'courseEvent', capacity: 70}) }
-
-      it 'processes non-paginated response' do
-        result = converter.convert(api_response)
-        expect(result).to be_an_instance_of(KOSapiClient::Entity::CourseEvent)
-      end
-
-    end
-
-    context 'unknown type' do
-
-      let(:api_response) { double(is_paginated?: false, item: {xsi_type: 'unknownType'}) }
-
-      it 'raises error when type not found' do
-        expect { converter.convert(api_response) }.to raise_error(RuntimeError)
-      end
-
-    end
-
-  end
-
-end

data/spec/kosapi_client/response_links_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::ResponseLinks do
-
-  let(:client) { instance_double(KOSapiClient::HTTPClient) }
-  subject(:links) { described_class.new }
-
-  describe '.parse' do
-
-    context 'with no links' do
-      it 'returns instance with no links set' do
-        links = described_class.parse(nil, client)
-        expect(links.next).not_to be
-        expect(links.prev).not_to be
-      end
-    end
-
-    context 'with both links' do
-      it 'parses both links' do
-        links = described_class.parse([{rel: 'prev', href: 'courses/?offset=0&limit=10'}, {rel: 'next', href: 'courses/?offset=20&limit=10'}], client)
-        expect(links.next.link_href).to eq 'courses/?offset=20&limit=10'
-        expect(links.prev.link_href).to eq 'courses/?offset=0&limit=10'
-      end
-    end
-
-    context 'with next link' do
-      it 'parses next link' do
-        links = described_class.parse({rel: 'next', href: 'courses/?offset=20&limit=10'}, client)
-        expect(links.next.link_href).to eq 'courses/?offset=20&limit=10'
-        expect(links.next.link_rel).to eq 'next'
-        expect(links.prev).not_to be
-      end
-    end
-
-    context 'with prev link' do
-      it 'parses prev link' do
-        links = described_class.parse({rel: 'prev', href: 'courses/?offset=20&limit=10'}, client)
-        expect(links.next).not_to be
-        expect(links.prev.link_href).to eq 'courses/?offset=20&limit=10'
-        expect(links.prev.link_rel).to eq 'prev'
-      end
-    end
-
-    it 'injects http client' do
-      links = described_class.parse({rel: 'next', href: 'courses/?offset=20&limit=10'}, client)
-      expect(client).to receive(:send_request)
-      links.next.follow
-    end
-
-  end
-
-end

data/spec/kosapi_client/response_preprocessor_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::ResponsePreprocessor do
-  subject(:preprocessor) { KOSapiClient::ResponsePreprocessor.new }
-  let(:response) { double(parsed: parsed_response) }
-  let(:parsed_response) { {atom_entry: {}, 'sampleKey' => 'value', 'nestedHash' => ['stuff', {'foo'=>'bar'}]} }
-
-  it 'stringifies hash keys and make then snakecase' do
-    result = preprocessor.preprocess(response)
-    expect(result).to eq({atom_entry: {}, sample_key: 'value', nested_hash: ['stuff', {foo: 'bar'}]})
-  end
-
-  it 'converts entries to array when required' do
-    resp = {atom_feed: {
-        atom_entry: {id: '1234'}
-    }}
-    result = preprocessor.preprocess(double(parsed: resp))
-    expect(result).to eq({atom_feed: {atom_entry: [{id: '1234'}]}})
-  end
-
-  it 'merges contents to entries in feed' do
-    resp = {atom_feed: {
-        atom_entry: [{id: '1234', atom_content: {foo: :bar}}]
-    }}
-    result = preprocessor.preprocess(double(parsed: resp))
-    expect(result).to eq({atom_feed: {atom_entry: [{id: '1234', foo: :bar}]}})
-  end
-
-  it 'merges content in single entry' do
-    resp = {atom_entry: {id: '1234', atom_content: {foo: :bar}}}
-    result = preprocessor.preprocess(double(parsed: resp))
-    expect(result).to eq({atom_entry: {id: '1234', foo: :bar}})
-  end
-
-  it 'handles empty response' do
-    resp = {atom_feed: {} }
-    result = preprocessor.preprocess(double(parsed: resp))
-    expect(result).to eq({atom_feed: {}})
-  end
-
-  context 'with invalid response' do
-
-    let(:parsed_response) { 'foo' }
-
-    it 'raises error when parsed type is not a hash' do
-      expect { preprocessor.preprocess(response) }.to raise_error(RuntimeError)
-    end
-
-  end
-
-end

data/spec/kosapi_client/url_builder_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::URLBuilder do
-
-  let(:root) { 'http://example.com' }
-  subject(:builder) { KOSapiClient::URLBuilder.new(root) }
-
-  describe '#set_query_param' do
-
-    it 'adds new query parameters to ur' do
-      builder.set_query_param('foo', 'bar')
-      builder.set_query_param('boo', 'far')
-      expect(builder.url).to eq 'http://example.com?foo=bar&boo=far'
-    end
-
-    it 'overwrites already used query parameters' do
-      builder.set_query_param('foo', 'bar')
-      builder.set_query_param('foo', 'far')
-      expect(builder.url).to eq 'http://example.com?foo=far'
-    end
-
-  end
-
-  describe '#set_path' do
-
-    it 'sets path correctly' do
-      builder.set_path('foo', 'bar')
-      expect(builder.url).to eq 'http://example.com/foo/bar'
-    end
-
-    context 'with custom root' do
-
-      let(:root) { 'https://kosapi.fit.cvut.cz/api/3' }
-
-      it 'creates correct path' do
-        builder.set_path('bar')
-        expect(builder.url).to eq 'https://kosapi.fit.cvut.cz/api/3/bar'
-      end
-
-    end
-
-  end
-
-end