kosapi_client 0.5.0

data/spec/kosapi_client/api_client_spec.rb

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

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

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

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

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

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

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

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

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

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

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