kosapi_client 0.5.0

data/spec/kosapi_client/entity/parallel_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe KOSapiClient::Entity::Parallel do
+  let(:attributes) { { code: '42',
+                       capacity_overfill: 'DENIED',
+                       teacher: [{ xlink_href: 'teachers/smitkdan/', __content__: 'Ing. arch. Daniel Smitka Ph.D.' }]
+  } }
+
+
+  it 'parses parallel attributes' do
+    parallel = KOSapiClient::Entity::Parallel.parse(attributes)
+    expect(parallel.code).to eq 42
+    expect(parallel.capacity_overfill).to eq :denied
+    expect(parallel.teachers.first).to be_an_instance_of KOSapiClient::Entity::Link
+    expect(parallel.teachers.first.link_href).to eq 'teachers/smitkdan/'
+    expect(parallel.teachers.first.link_title).to eq 'Ing. arch. Daniel Smitka Ph.D.'
+  end
+end

data/spec/kosapi_client/entity/result_page_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe KOSapiClient::Entity::ResultPage do
+
+  ResultPage = KOSapiClient::Entity::ResultPage
+
+  subject(:result_page) { ResultPage.new([item], links) }
+  let(:item) { double(:item) }
+  let(:item2) { double(:second_item) }
+  let(:links) { instance_double(KOSapiClient::ResponseLinks, next: next_link) }
+  let(:next_page) { ResultPage.new([item2], instance_double(KOSapiClient::ResponseLinks, next: nil)) }
+  let(:next_link) { instance_double(KOSapiClient::Entity::Link, follow: next_page) }
+
+  describe '#each' do
+
+    it 'is auto-paginated by default' do
+      [item, item2].each { |it| expect(it).to receive(:foo) }
+      result_page.each { |it| it.foo }
+    end
+
+    context 'with auto-pagination disabled' do
+
+      subject(:result_page) { ResultPage.new([item], links, false) }
+
+      it 'is not auto-paginated' do
+        expect(item).to receive(:foo)
+        expect(item2).not_to receive(:foo)
+        result_page.each { |it| it.foo }
+      end
+    end
+
+  end
+
+  describe '#count' do
+
+    it 'returns item count' do
+      expect(result_page.count).to eq 1
+    end
+
+  end
+
+end

data/spec/kosapi_client/entity/teacher_timetable_slot_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe KOSapiClient::Entity::TeacherTimetableSlot do
+
+  describe '.parse' do
+
+    it 'can be parsed from a hash' do
+      slot = described_class.parse({
+        id: '42', day: '1', first_hour: '3', duration: '2', parity: 'BOTH', title: 'Sleep'
+      })
+      expect(slot.id).to eq 42
+      expect(slot.day).to eq 1
+      expect(slot.first_hour).to eq 3
+      expect(slot.duration).to eq 2
+      expect(slot.parity).to eq :both
+      expect(slot.title).to eq 'Sleep'
+    end
+  end
+end

data/spec/kosapi_client/entity/timetable_slot_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe KOSapiClient::Entity::TimetableSlot do
+
+  TimetableSlot = KOSapiClient::Entity::TimetableSlot
+
+  describe '.parse' do
+
+    it 'can be parsed from a hash' do
+      slot = TimetableSlot.parse({id: '42', day: '1', first_hour: '3', duration: '2', parity: 'BOTH', room: { __contents__: 'no-title', xlink_href: 'rooms/10010205/' }})
+      expect(slot.id).to eq 42
+      expect(slot.day).to eq 1
+      expect(slot.first_hour).to eq 3
+      expect(slot.duration).to eq 2
+      expect(slot.parity).to eq :both
+      expect(slot.room).to be_an_instance_of(Link)
+      expect(slot.room.link_href).to eq 'rooms/10010205/'
+    end
+
+  end
+
+end

data/spec/kosapi_client/hash_utils_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe KOSapiClient::HashUtils do
+
+  let(:k1) {double(visited: :k1)}
+  let(:k2) {double(visited: :k2)}
+  let(:source_hash) { {k1 => [{k2 => :foo}]} }
+
+  it 'iterates over all keys' do
+    expect(k1).to receive(:visited)
+    expect(k2).to receive(:visited)
+    KOSapiClient::HashUtils.deep_transform_hash_keys(source_hash) { |key| key.visited }
+  end
+
+  it 'returns hash with modified keys' do
+    result = KOSapiClient::HashUtils.deep_transform_hash_keys(source_hash) { |key| key.visited }
+    expect(result).to eq({k1: [{k2: :foo}]})
+  end
+
+end

data/spec/kosapi_client/http_client_spec.rb

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,80 @@
+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