kosapi_client 0.5.0 → 0.6.0

data/spec/integration/parallels_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-describe 'Parallels resource', :vcr, :integration do
-
-  let(:credentials) { { client_id: ENV['KOSAPI_OAUTH_CLIENT_ID'], client_secret: ENV['KOSAPI_OAUTH_CLIENT_SECRET'] } }
-  subject(:client) {  KOSapiClient.new(credentials) }
-
-  it 'fetches parallels list' do
-    page = client.parallels.offset(0).limit(50).query('course.department' => '18*')
-    expect(page.items.count).to eq 50
-  end
-
-  it 'parses relationship links properly' do
-    page = client.parallels
-    course = page.items.first.course
-    expect(course.link_title).not_to be_nil
-    expect(course.link_href).not_to be_nil
-  end
-
-  it 'parses entry ID properly' do
-    page = client.parallels
-    parallel = page.items.first
-    expect(parallel.id).not_to be_nil
-  end
-
-  it 'parses updated properly' do
-    page = client.parallels
-    parallel = page.items.first
-    expect(parallel.updated).not_to be_nil
-  end
-
-  it 'parses author properly' do
-    page = client.parallels
-    parallel = page.items.first
-    expect(parallel.author.name).not_to be_nil
-  end
-
-  it 'parses entry link properly' do
-    page = client.parallels
-    parallel = page.items.first
-    expect(parallel.link).not_to be_nil
-    expect(parallel.link.link_href).not_to be_nil
-    expect(parallel.link.link_rel).not_to be_nil
-  end
-
-  it 'parses timetable slot ID' do
-    page = client.parallels
-    slot = page.items.first.timetable_slots.first
-    expect(slot.id).not_to be_nil
-  end
-
-  it 'returns following result page with next callback' do
-    page = client.parallels
-    following_page = page.next
-    expect(following_page.items.count).to be > 0
-  end
-
-  it 'follows next link with RSQL query' do
-    page = client.parallels.where('(lastUpdatedDate>=2014-07-01T00:00:00;lastUpdatedDate<=2014-07-10T00:00:00)')
-    expect(page.next.items.count).to be > 0
-  end
-
-  it 'returns students for a parallel' do
-    students = client.parallels.find(339540000).students.limit(20)
-    expect(students.count).to eq 15
-  end
-
-end

data/spec/kosapi_client/api_client_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::ApiClient do
-  subject(:client) { KOSapiClient::ApiClient.new }
-
-  it 'responds to api resource methods' do
-    expect(client).to respond_to :course_events
-  end
-
-  it 'creates default builder when no custom builder is defined' do
-    builder = client.create_builder(:foo)
-    expect(builder).to be_an_instance_of KOSapiClient::RequestBuilder
-  end
-
-  it 'creates custom builder for resource when defined' do
-    class KOSapiClient::Resource::FooBarBuilder < KOSapiClient::RequestBuilder; end
-
-    builder = client.create_builder(:foo_bar)
-    expect(builder).to be_an_instance_of KOSapiClient::Resource::FooBarBuilder
-  end
-
-end

data/spec/kosapi_client/configuration_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::Configuration do
-
-  subject(:configuration) { KOSapiClient::Configuration.new }
-
-  it 'stores client_id' do
-    configuration.client_id = 'foo'
-    expect(configuration.client_id).to eq 'foo'
-  end
-
-  it 'stores client_secret' do
-    configuration.client_secret = 'bar'
-    expect(configuration.client_secret).to eq 'bar'
-  end
-
-  describe '#credentials' do
-
-    it 'returns OAUTH credentials when set' do
-      configuration.client_id = 'foo'
-      configuration.client_secret = 'bar'
-      expect(configuration.credentials).to eq({client_id: 'foo', client_secret: 'bar'})
-    end
-
-    it 'returns empty hash when no credentials set' do
-      expect(configuration.credentials).to eq({})
-    end
-
-  end
-end

data/spec/kosapi_client/entity/base_entity_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::Entity::BaseEntity do
-  let(:attributes) { {atom_id: 'urn:cvut:kos:courseevent:220200484405',
-                      atom_title: 'This is a title',
-                      atom_updated: '2010-05-13T09:12:58.0',
-                      atom_author: {atom_name: 'pochova'},
-                      atom_link: {rel: 'self', href: 'courseEvents/220200484405/'}
-  } }
-
-
-  it 'parses basic attributes' do
-    entity = KOSapiClient::Entity::BaseEntity.parse(attributes)
-
-    expect(entity.id).to eq 'urn:cvut:kos:courseevent:220200484405'
-    expect(entity.title).to eq 'This is a title'
-    expect(entity.link).to be_an_instance_of KOSapiClient::Entity::Link
-    expect(entity.author).to be_an_instance_of KOSapiClient::Entity::Author
-  end
-end

data/spec/kosapi_client/entity/base_person_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::Entity::BasePerson do
-
-  describe '#full_name' do
-
-    it 'returns whole name with titles' do
-      person = described_class.parse(first_name: 'Foo', last_name: 'Bar', titles_pre: 'Ing.', titles_post: 'Ph.D.')
-      expect(person.full_name).to eq 'Ing. Foo Bar Ph.D.'
-    end
-
-    it 'skips title if not set' do
-      person = described_class.parse(first_name: 'Foo', last_name: 'Bar', titles_pre: 'Ing.')
-      expect(person.full_name).to eq 'Ing. Foo Bar'
-    end
-
-  end
-
-end

data/spec/kosapi_client/entity/boolean_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::Entity::Boolean do
-
-  describe '.parse' do
-
-    subject(:boolean) { described_class }
-
-    it 'parses true string to true' do
-      expect(boolean.parse('true')).to be true
-    end
-
-    it 'parses false string to false' do
-      expect(boolean.parse('false')).to be false
-    end
-
-    it 'throws error with invalid string' do
-      expect { boolean.parse('invalid') }.to raise_error(RuntimeError)
-    end
-
-  end
-
-end

data/spec/kosapi_client/entity/course_event_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::Entity::CourseEvent do
-  let('course_event_input') {  {atom_id: 'urn:cvut:kos:courseevent:220200484405',
-                                atom_updated: '2010-05-13T09:12:58.0',
-                                atom_author: {atom_name: 'pochova'},
-                                atom_link: {rel: 'self', xlink_href: 'courseEvents/220200484405/'},
-                                capacity: '70',
-                                course: {__content__: 'Computer Structure  and Architecture',
-                                         xlink_href: 'courses/BI-SAP/'},
-                                end_date: '2010-05-18T14:01:00',
-                                name: {__content__: 'test1 oprava', xml_lang: 'cs'},
-                                occupied: '50',
-                                room: {__content__: 'TK:PU1', xlink_href: 'rooms/TK:PU1/'},
-                                semester: {__content__: 'Summer 2009/2010', xlink_href: 'semesters/B092/'},
-                                signin_deadline: '2010-05-17',
-                                start_date: '2010-05-18T14:00:00',
-                                type: ['courseEvent', 'xml']} }
-
-  it 'parses provided data' do
-    course_event = KOSapiClient::Entity::CourseEvent.parse(course_event_input)
-    expect(course_event.capacity).to eq 70
-    expect(course_event.course).to be_an_instance_of(KOSapiClient::Entity::Link)
-  end
-
-  it 'parses base attributes' do
-    course_event = KOSapiClient::Entity::CourseEvent.parse(course_event_input)
-    expect(course_event.id).to eq 'urn:cvut:kos:courseevent:220200484405'
-  end
-end

data/spec/kosapi_client/entity/data_mappings_spec.rb

@@ -1,154 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::Entity::DataMappings do
-
-  let(:dummy_class) { Class.new { include KOSapiClient::Entity::DataMappings } }
-  let(:derived_class) { Class.new(dummy_class) }
-  let(:dummy_instance) { dummy_class.new }
-
-  it 'defines .parse class method' do
-    expect(dummy_class).to respond_to(:parse)
-  end
-
-  it 'defines .map_data class method' do
-    expect(dummy_class).to respond_to(:map_data)
-  end
-
-  describe '.parse' do
-
-    it 'parses to string by default' do
-      dummy_class.map_data :foo
-      parsed = dummy_class.parse({foo: 'bar'})
-      expect(parsed).to be_an_instance_of(dummy_class)
-      expect(parsed.foo).to eq 'bar'
-    end
-
-    it 'parses integer type' do
-      dummy_class.map_data :foo, Integer
-      parsed = dummy_class.parse({foo: '1'})
-      expect(parsed.foo).to eq 1
-    end
-
-    it 'parses array of types' do
-      dummy_class.map_data :foo, [Integer]
-      parsed = dummy_class.parse({foo: %w(5 7 11)})
-      expect(parsed.foo).to eq [5, 7, 11]
-    end
-
-    it 'parses single item as array when set' do
-      dummy_class.map_data :foo, [Integer]
-      parsed = dummy_class.parse({foo: '11'})
-      expect(parsed.foo).to eq [11]
-    end
-
-    it 'parses custom types' do
-      dummy_class.map_data :foo, KOSapiClient::Entity::Enum
-      parsed = dummy_class.parse({foo: 'bar'})
-      expect(parsed.foo).to eq :bar
-    end
-
-    it 'throws error when required attribute is missing' do
-      dummy_class.map_data :foo, String, required: true
-      expect { dummy_class.parse({}) }.to raise_error(RuntimeError)
-    end
-
-    it 'sets attribute to nil when not required attribute is missing' do
-      dummy_class.map_data :foo, String
-      parsed = dummy_class.parse({})
-      expect(parsed.foo).to be_nil
-    end
-
-    it 'throws error on type without parse method' do
-      dummy_class.map_data :foo, Object
-      expect{ dummy_class.parse({foo: 'bar'}) }.to raise_error(RuntimeError)
-    end
-
-    it 'accepts context hash' do
-      dummy_class.map_data :foo, KOSapiClient::Entity::Enum
-      context = {}
-      parsed = dummy_class.parse({foo: 'bar'}, context)
-      expect(parsed.foo).to eq :bar
-    end
-
-    it 'parses nil collection as empty array' do
-      dummy_class.map_data :foo, [Integer]
-      parsed = dummy_class.parse({ })
-      expect(parsed.foo).to eq []
-    end
-
-  end
-
-  describe '.map_data' do
-
-    it 'maps parent attributes' do
-      dummy_class.map_data :foo
-      derived_class.map_data :bar
-      instance = derived_class.parse({foo: '123', bar: '456'})
-      expect(instance).to respond_to(:foo, :bar)
-    end
-
-    it 'does not map child attributes' do
-      dummy_class.map_data :foo
-      derived_class.map_data :bar
-      instance = dummy_class.parse({foo: '123', bar: '456'})
-      expect(instance).to respond_to(:foo)
-      expect(instance).not_to respond_to(:bar)
-    end
-
-
-    it 'supports namespace configuration' do
-      dummy_class.map_data :foo, String, namespace: :bar
-      instance = dummy_class.parse({bar_foo: '123', bar: '456'})
-      expect(instance.foo).to eq '123'
-    end
-
-    it 'supports source element name configuration' do
-      dummy_class.map_data :foo, String, element: :bar
-      instance = dummy_class.parse({bar: '123'})
-      expect(instance.foo).to eq '123'
-    end
-
-  end
-
-  describe '#to_hash' do
-
-    it 'converts mapped attributes to a hash' do
-      dummy_class.map_data :foo
-      instance = dummy_class.parse({foo: 'bar'})
-      expect(instance.to_hash).to eq({foo: 'bar'})
-    end
-
-    it 'converts class hierarchy attributes to a hash' do
-      dummy_class.map_data :foo
-      derived_class.map_data :bar
-      instance = derived_class.parse({foo: '123', bar: '456'})
-      expect(instance.to_hash).to eq({foo: '123', bar: '456'})
-    end
-
-    it 'converts array to a hash' do
-      dummy_class.map_data :foo, [Integer]
-      instance = dummy_class.parse({foo: %w(123 456)})
-      expect(instance.to_hash).to eq({foo: [123, 456]})
-    end
-
-    it 'converts nested instances' do
-      dummy_class.map_data :foo
-      instance = dummy_class.new()
-      instance2 = dummy_class.new()
-      instance.foo = instance2
-      instance2.foo = 'bar'
-      expect(instance.to_hash).to eq({foo: {foo: 'bar'}})
-    end
-
-    it 'converts array of nested instances' do
-      dummy_class.map_data :foo
-      instance = dummy_class.new()
-      instance2 = dummy_class.new()
-      instance.foo = [instance2]
-      instance2.foo = 'bar'
-      expect(instance.to_hash).to eq({foo: [{foo: 'bar'}]})
-    end
-
-  end
-
-end

data/spec/kosapi_client/entity/enum_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::Entity::Enum do
-
-  Enum = KOSapiClient::Entity::Enum
-
-  describe '.parse' do
-
-    it 'parses a string to a symbol' do
-      res = Enum.parse('foo')
-      expect(res).to eq :foo
-    end
-
-    it 'downcases the string before converting to a symbol' do
-      res = Enum.parse('FOO')
-      expect(res).to eq :foo
-    end
-
-  end
-end

data/spec/kosapi_client/entity/id_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::Entity::Id do
-
-  describe '.parse' do
-
-    it 'parses id from string' do
-      id = described_class.parse('urn:cvut:kos:parallel:10160605')
-      expect(id).to eq '10160605'
-    end
-  end
-
-end

data/spec/kosapi_client/entity/link_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::Entity::Link do
-
-  Link = KOSapiClient::Entity::Link
-
-  let(:client) { instance_double(KOSapiClient::HTTPClient) }
-  subject(:link) { Link.parse({href: 'http://example.com/foo/bar/42', __content__: 'Example Site', rel: 'next'}) }
-  let(:result) { double(:result, foo: :bar) }
-  before(:example) { link.inject_client(client) }
-
-  describe '.parse' do
-
-    it 'can be parsed from a hash' do
-      expect(link.link_href).to eq 'http://example.com/foo/bar/42'
-      expect(link.link_title).to eq 'Example Site'
-      expect(link.link_rel).to eq 'next'
-    end
-
-  end
-
-  describe '#initialize' do
-
-    it 'encodes href URL' do
-      href = 'parallels?query=(lastUpdatedDate%3E=2014-07-01T00:00:00;lastUpdatedDate%3C=2014-07-10T00:00:00)&offset=10&limit=10'
-      link = Link.new(nil, href, nil)
-      expect(link.link_href).to eq 'parallels?query=(lastUpdatedDate%3E=2014-07-01T00:00:00%3BlastUpdatedDate%3C=2014-07-10T00:00:00)&offset=10&limit=10'
-    end
-
-  end
-
-  describe '#link_id' do
-
-    it 'returns last href segment' do
-      expect(link.link_id).to eq '42'
-    end
-
-  end
-
-  describe '#follow' do
-
-    it 'throws error when not http client set' do
-      link.inject_client(nil)
-      expect { link.follow }.to raise_error(RuntimeError)
-    end
-
-    it 'calls http client with href' do
-      expect(client).to receive(:send_request).with(:get, 'http://example.com/foo/bar/42')
-      link.follow
-    end
-
-  end
-
-  describe '#method_missing?' do
-
-    it 'calls follow when method not defined' do
-      expect(link).to receive(:follow)
-      expect { link.foo }.to raise_error(NoMethodError)
-    end
-
-    it 'delegates missing methods to returned object' do
-      expect(result).to receive(:foo).and_return(:bar)
-      allow(link).to receive(:follow).and_return(result)
-      expect(link.foo).to eq :bar
-    end
-
-    it 'caches returned object' do
-      expect(link).to receive(:follow).once.and_return(result)
-      2.times { link.foo }
-    end
-
-  end
-
-  describe '#respond_to_missing?' do
-
-    it 'responds to target object methods' do
-      allow(link).to receive(:follow).and_return(double(foo: :bar))
-      expect(link).to respond_to(:foo)
-    end
-  end
-
-  describe '#to_hash' do
-    it 'converts link attributes to hash' do
-      expect(link.to_hash).to eq({href: 'http://example.com/foo/bar/42', title: 'Example Site', rel: 'next'})
-    end
-
-  end
-
-end

data/spec/kosapi_client/entity/ml_string_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe KOSapiClient::Entity::MLString do
-
-  MLString = described_class
-
-  def translations
-    @translations || {en: 'Lorem Ipsum', cs: 'Foo'}
-  end
-
-  let(:mlstring) { MLString.new(translations) }
-
-  describe '.parse' do
-
-    it 'parses itself from a hash' do
-      str = MLString.parse({xml_lang: :en, __content__: 'Lorem Ipsum'})
-      expect(str.translations).to eq({en: 'Lorem Ipsum'})
-    end
-
-  end
-
-  describe '#to_s' do
-
-    it 'returns translation specified in parameter when present' do
-      expect(mlstring.to_s(:cs)).to eq 'Foo'
-    end
-
-    it 'returns nil when specified language not present' do
-      expect(mlstring.to_s(:sk)).to be_nil
-    end
-
-    it 'returns translation in default language when language not specified' do
-      expect(mlstring.to_s).to eq 'Lorem Ipsum'
-    end
-
-    it 'returns first translation when default default language not present' do
-      @translations = {cs: 'Foo', sk: 'Bar'}
-      expect(mlstring.to_s).to eq 'Foo'
-    end
-
-  end
-
-  describe 'default language' do
-
-    it 'can set default language in initialize' do
-      str = MLString.new(translations, :cs)
-      expect(str.to_s).to eq 'Foo'
-    end
-
-  end
-
-end

data/spec/kosapi_client/entity/parallel_spec.rb

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

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

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

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

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