representors 0.0.5

data/spec/lib/representors/complex_representor_spec.rb

@@ -0,0 +1,288 @@
+require 'spec_helper'
+require 'yaml'
+require 'uri'
+require 'fixtures/drds_hash'
+require 'fixtures/single_drd'
+module Representors
+  describe Representor do
+    before do
+      @representor_hash = ComplexRepresentor::DRDS_HASH
+      @representor_hash[:embedded] = {items: [ComplexRepresentor::DRD_HASH]}
+    end
+    let(:representor_hash) { @representor_hash }
+
+    let(:subject) { Representor.new(representor_hash) }
+
+    describe '.new' do
+      it 'returns a Representors::Representor instance' do
+        expect(subject).to be_an_instance_of(Representor)
+      end
+
+      describe '#to_s' do
+        it 'returns a string representation' do
+          expect(eval(subject.to_s)).to eq(representor_hash)
+        end
+      end
+
+      describe '#doc' do
+        it 'returns the same value specified under the doc element of the hash' do
+          doc = 'Describes the semantics, states and state transitions associated with DRDs.'
+          expect(subject.doc).to eq(doc)
+        end
+      end
+
+      describe '#to_hash' do
+        it 'returns a hash that it can be reconstructed with' do
+          expect(Representor.new(subject.to_hash).to_hash).to eq(@representor_hash)
+        end
+      end
+
+      describe '#to_yaml' do
+        it 'returns a yaml file that represents its internal hash' do
+          expect(YAML.load(subject.to_yaml)).to eq(YAML::load(YAML.dump(@representor_hash)))
+        end
+      end
+
+      describe '#properties' do
+        it 'returns a hash of attributes associated with the represented resource' do
+          semantic_elements_present =  %w(total_count).all? do |key|
+            subject.properties[key] == @representor_hash[:attributes][key][:value]
+          end
+          expect(semantic_elements_present).to eq(true)
+         end
+       end
+
+      describe '#embedded' do
+        let(:embedded_resource) {:items}
+
+        it 'returns a set of Representor objects' do
+          expect(subject.embedded[embedded_resource].first).to be_an_instance_of(Representors::Representor)
+        end
+
+        it 'returns a Representor objects that has its data' do
+          doc = 'Diagnostic Repair Drones or DRDs are small robots that move around Leviathans. They are built by a Leviathan as it grows.'
+          embedded_objects_valid = subject.embedded[embedded_resource].all? { |embed| embed.doc == doc }
+          expect(embedded_objects_valid).to eq(true)
+        end
+
+        it 'returns the all the Representors' do
+          expect(subject.embedded[embedded_resource].count).to eq(@representor_hash[:embedded].count)
+        end
+      end
+
+      describe '#transitions' do
+        it 'returns all transitions' do
+          expect(subject.transitions.size).to eq(5)
+          has_transitions = subject.transitions.all? { |trans| trans.instance_of?(Transition) }
+          expect(has_transitions).to eq(true)
+        end
+      end
+
+      describe '#meta_links' do
+        it 'should return a list of transitions representing those links' do
+          expect(subject.meta_links.size).to eq(3)
+          has_meta_link = subject.meta_links.all? { |trans| trans.instance_of?(Transition) }
+          expect(has_meta_link).to eq(true)
+        end
+      end
+
+      describe '#datalists' do
+        let(:embedded_resource) {:items}
+        it 'returns all paramters and attributes that are members of a datalist' do
+          first_datalist = subject.embedded[embedded_resource].first.datalists
+          expected_datalists = ["drd_status_options", "drd_status_options", "location_options", "location_detail_options"]
+          has_data_list = expect(first_datalist.map { |datalist| datalist.id }).to eq(expected_datalists)
+        end
+      end
+
+      describe '.transitions' do
+        describe '#to_s' do
+          it 'returns a string representation' do
+            expect(subject.transitions.first.to_s).to eq(representor_hash[:transitions].first.to_s)
+          end
+        end
+
+        describe '#to_hash' do
+          it 'returns a hash representation' do
+            hashed = Hash[subject.transitions.first.to_hash.map{|(k,v)| [k.to_sym,v]}]
+            expect(hashed).to eq(representor_hash[:transitions].first)
+          end
+        end
+
+        describe '#[]' do
+          let(:key)  {'href'}
+          let(:value) {representor_hash[:transitions].first[key.to_sym]}
+          it 'returns the value for the keys' do
+            expect(subject.transitions.first[key]).to eq(value)
+          end
+
+          it 'returns nil if the key is not in this transition' do
+            expect(subject.transitions.first['Ido not exists']).to be_nil
+          end
+
+          it 'has indifferent access to the hash' do
+            expect(subject.transitions.first[key.to_sym]).to eq(value)
+            expect(subject.transitions.first[key.to_s]).to eq(value)
+          end
+
+        end
+
+
+        describe '#rel' do
+          it 'returns the transition key' do
+            expect(subject.transitions.first.rel).to eq(representor_hash[:transitions].first[:rel])
+          end
+        end
+
+        describe '#interface_method' do
+          it 'returns the uniform interface method' do
+            expect(subject.transitions.first.interface_method).to eq('GET')
+          end
+        end
+
+        describe '#parameters' do
+          it 'returns a list of fields representing the link parameters' do
+            field = subject.transitions[2].parameters.first
+            expect(field).to be_an_instance_of(Field)
+          end
+        end
+
+        describe '#attributes' do
+          it 'returns a list of fields representing the link attributes' do
+            field = subject.transitions[3].attributes.first
+            expect(field).to be_an_instance_of(Field)
+          end
+        end
+
+        describe '#meta_links' do
+          it 'returns a list of Transitions' do
+            links = subject.transitions.first.meta_links.all? { |item| item.instance_of?(Transition) }
+            expect(links).to eq(true)
+          end
+        end
+
+        describe '#uri' do
+          it 'returns the bare link' do
+            expect(subject.transitions.first.uri).to eq('http://example.com/drds')
+          end
+        end
+
+        describe '#templated_uri' do
+          it 'returns the link parameterized' do
+            expect(subject.transitions[2].templated_uri).to eq('http://example.com/drds/search{?search_term,name}')
+          end
+        end
+
+        describe '#templated?' do
+          it 'returns false for the first element which has no parameters' do
+            expect(subject.transitions.first).not_to be_templated
+          end
+
+          it 'returns true for the second template which has parameters' do
+            expect(subject.transitions[2].templated?).to eq(true)
+          end
+        end
+
+        describe '.field' do
+
+          let(:field) { subject.transitions[3].attributes.first }
+          let(:field_hash) { {:name => representor_hash[:transitions].last[:descriptors][:name]} }
+
+          it 'returns a Representors::Field instance' do
+            expect(field).to be_an_instance_of(Representors::Field)
+          end
+
+          describe '#to_hash' do
+            it 'returns its constructor hash' do
+              expect(field.to_hash).to eq(field_hash)
+            end
+          end
+
+          describe '#to_yaml' do
+            it 'returns its constructor hash represented as a yaml document' do
+              expect(field.to_yaml).to eq(YAML.dump(field_hash))
+            end
+          end
+
+          describe '#name' do
+            it 'returns the key when requesting the name' do
+              expect(field.name).to eq(field_hash.keys.first)
+            end
+          end
+
+          %w(value default description type data_type).map(&:to_sym).each do |key|
+            describe "\##{key}" do
+              it "returns it's hash value" do
+               expect(field.send(key)).to eq(field_hash.first[1][key])
+              end
+            end
+          end
+        end
+      end
+
+      describe '#to_media_type' do
+        context 'when it serializes to hale' do
+          let (:hale_hash) { JSON.load(subject.to_media_type(:hale_json)) }
+          #TODO: Fix Hale Serializer - Complex objects not working
+
+          it 'has ths associated attributes' do
+            expect(hale_hash["total_count"]).to eq(subject.properties["total_count"])
+          end
+
+          it 'has transitions' do
+            expect(hale_hash["_links"]).to include("self","list","search","create")
+          end
+
+          it 'has meta links' do
+            subject.meta_links.each do |link|
+              expect(hale_hash["_links"][link.rel.to_s]["href"]).to eq(link.templated_uri)
+            end
+          end
+
+          it 'has embedded items' do
+            expect(hale_hash["_embedded"]["items"].count).to eq(@representor_hash[:embedded].count)
+          end
+
+        end
+
+        context 'when it serializes to hal' do
+          let (:hal_hash) { JSON.load(subject.to_media_type(:hal_json)) }
+
+          it 'has ths associated attributes' do
+            expect(hal_hash["total_count"]).to eq(subject.properties["total_count"])
+          end
+
+          it 'has transitions' do
+            subject.transitions.select { |transition| transition.rel != :items }.each do |link|
+              expect(hal_hash["_links"][link.rel]["href"]).to eq(link.templated_uri)
+            end
+          end
+
+          it 'has transitions for embedded resources' do
+            embedded_links = hal_hash["_embedded"]["items"].collect { |transition| transition["_links"]["self"]["href"] }
+            subject.transitions.reject { |transition| transition.rel != :items }.each do |link|
+              expect(embedded_links).to include(link.templated_uri)
+            end
+          end
+
+          it 'has meta links' do
+            subject.meta_links.each do |link|
+              expect(hal_hash["_links"][link.rel.to_s]["href"]).to eq(link.templated_uri)
+            end
+          end
+
+          it 'has embedded items' do
+           expect(hal_hash["_embedded"]["items"].count).to eq(1)
+          end
+
+          it 'renders a proper Hal document' do
+            expect(hal_hash).to eq(JSON.load(File.open(fixture_path('complex_hal.json'))))
+          end
+
+        end
+
+      end
+    end
+  end
+end
+

data/spec/lib/representors/field_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+require 'yaml'
+require 'uri'
+
+module Representors
+  describe Field do
+    before do
+      @field_hash = {
+        total_count: {
+          doc: 'The total count of DRDs.',
+          type: 'semantic',
+          profile: 'http://alps.io/schema.org/Integer',
+          sample: 1,
+          value: 2
+        }
+      }
+    end
+
+    let(:field_hash) { @field_hash }
+    let(:subject) { Field.new(field_hash) }
+
+    describe '.new' do
+      it 'returns a Representors::Field instance' do
+        expect(subject).to be_an_instance_of(Representors::Field)
+      end
+
+      it 'can be treated as the string of its value' do
+        expect(subject).to eq(subject.value.to_s)
+      end
+
+      it '#doc' do
+        expect("#{subject.doc} is #{subject}").to eq("The total count of DRDs. is 2")
+      end
+
+      describe '#to_hash' do
+        it 'returns its constructor hash' do
+          expect(subject.to_hash).to eq(field_hash)
+        end
+      end
+
+      describe '#to_yaml' do
+        it 'returns its constructor hash represented as a yaml document' do
+          expect(subject.to_yaml).to eq(YAML.dump(field_hash))
+        end
+      end
+
+      describe '#name' do
+        it 'returns the key when requesting the name' do
+          expect(subject.name).to eq(field_hash.keys.first)
+        end
+      end
+
+      %w(value default description type data_type).map(&:to_sym).each do |key|
+        describe "\##{key}" do
+          it "returns it's hash value" do
+           expect(subject.send(key)).to eq(field_hash.first[1][key])
+          end
+        end
+      end
+
+      describe '#options' do
+        it 'returns an options object' do
+          @field_hash[:total_count][:options] = {}
+
+          expect(subject.options).to be_an_instance_of(Options)
+        end
+
+        it 'works with empty options' do
+          @field_hash[:total_count][:options] = {}
+
+          expect(subject.options.to_hash).to eq(field_hash[:total_count][:options])
+        end
+
+        it 'has a list interface even when a hash' do
+          @field_hash[:total_count][:options] = { 'hash' => {'foo' => 'bar', 'ninja' => 'cow'} }
+
+          expect(subject.options.to_list).to eq(field_hash[:total_count][:options]['hash'].keys)
+        end
+
+        it 'has a values interface when a hash' do
+          @field_hash[:total_count][:options] = { 'hash' => {'foo' => 'bar', 'ninja' => 'cow'} }
+
+          expect(subject.options.values).to eq(field_hash[:total_count][:options]['hash'].values)
+        end
+
+        it 'has a hash interface even when a list' do
+          @field_hash[:total_count][:options] = { 'list' => ['bar', 'cow'] }
+
+          expect(subject.options.to_hash).to eq({'bar' => 'bar', 'cow' => 'cow'})
+        end
+
+        it 'has a hash interface when external' do
+          @field_hash[:total_count][:options] = { 'external' => {'source' => 'foo', 'target' => 'bar'} }
+
+          expect(subject.options.to_hash).to eq({'source' => 'foo', 'target' => 'bar'})
+        end
+
+        it 'defaults to a sensible id' do
+           @field_hash[:total_count][:options] = { 'external' => {'source' => 'foo', 'target' => 'bar'} }
+
+           expect(subject.options.id).to eq('total_count_options')
+        end
+
+        it 'gives back a passed in id' do
+          @field_hash[:total_count][:options] = { 'list' => ['bar', 'cow'], 'id' => 'fortunes grace' }
+
+          expect(subject.options.id).to eq('fortunes grace')
+        end
+
+      end
+
+      describe '#validators' do
+        it 'returns a list of hashes whose key is equal to the validator type' do
+          validators = [{ max_length: 8 }, :required]
+          @field_hash[:total_count][:validators] = validators
+          hash_keys = validators.map { |hs| hs.instance_of?(Symbol) ? hs : hs.keys.first }
+          object_keys = subject.validators.map { |hash| hash.keys.first }
+          expect(object_keys).to eq(hash_keys)
+        end
+
+        it 'returns a list of hashes whose value must be matched against' do
+          validators = [{max_length: 8}, :required]
+          @field_hash[:total_count][:validators] = validators
+          hash_values = validators.map { |hs| hs.instance_of?(Symbol) ? hs : hs[hs.keys.first] }
+          object_vals = subject.validators.map { |hash| hash[hash.keys[0]] }
+          expect(object_vals).to eq(hash_values)
+        end
+
+        it 'returns an empty list when there are no validators' do
+          expect(subject.validators).to eq([])
+        end
+      end
+
+      describe '#call' do
+        it 'returns the value when called' do
+          expect(subject.()).to eq(@field_hash[:total_count][:value])
+        end
+      end
+    end
+  end
+end

data/spec/lib/representors/representor_builder_spec.rb

@@ -0,0 +1,223 @@
+require 'spec_helper'
+
+
+RSpec.shared_examples_for 'one attribute added' do
+  it 'creates a semantic key at the top level of the output' do
+    expect(@builder.to_representor_hash.attributes).to_not be_empty
+  end
+
+  it 'adds the attribute name as a key under "semantic" in the output hash' do
+    expect(semantic_field.has_key?(attribute_name)).to eq(true)
+  end
+
+  it 'adds the value under "value" in a hash which key is the attribute name' do
+    expect(semantic_field[attribute_name][:value]).to eq(attribute_value)
+  end
+
+  it 'when called twice the value is overwritten' do
+    new_value = 'new_value'
+    @builder = @builder.add_attribute(attribute_name, new_value)
+    expect(semantic_field[attribute_name]).to eq({value: new_value})
+  end
+end
+
+
+RSpec.shared_examples_for 'one transition added' do
+  it 'creates a transition key at the top level of the output' do
+    expect(@builder.to_representor_hash.transitions).to_not be_empty
+  end
+
+  it 'adds an array under "transitions" ' do
+    expect(transitions_field).to be_instance_of(Array)
+  end
+
+  it 'the members of the transitions has a href' do
+    expect(transitions_field.first[:href]).to eq(transition_href)
+  end
+  it 'the members of the transitions has a rel' do
+    expect(transitions_field.first[:rel]).to eq(transition_name)
+  end
+end
+
+RSpec.shared_examples_for 'one embedded added' do
+  it 'creates a transition key at the top level of the output' do
+    expect(@builder.to_representor_hash.embedded).to_not be_empty
+  end
+
+  it 'adds a hash under "embedded" ' do
+    expect(embedded_field).to be_instance_of(Hash)
+  end
+
+  it 'creates an embedded resource inside its own hash' do
+    expect(embedded_field[embedded_name]).to eq(embedded_value)
+  end
+
+end
+
+RSpec.shared_examples_for 'it can reconstruct itself' do
+  it 'can be constructed with the hash' do
+    expect(
+      Representors::RepresentorBuilder.new(@builder.to_representor_hash).to_representor_hash
+    ).to eq(@builder.to_representor_hash)
+  end
+end
+
+RSpec.describe Representors::RepresentorBuilder do
+  let(:semantic_field) {@builder.to_representor_hash.attributes}
+  let(:transitions_field) {@builder.to_representor_hash.transitions}
+  let(:embedded_field) {@builder.to_representor_hash.embedded}
+
+  before do
+    @builder = Representors::RepresentorBuilder.new
+  end
+
+  context 'empty builder' do
+    it "returns an empty representor hash" do
+      empty_hash = {:id=>nil, :doc=>nil, :href=>nil, :protocol=>nil, :attributes=>{}, :embedded=>{}, :links=>{}, :transitions=>[]}
+      expect(@builder.to_representor_hash.to_h).to eq(empty_hash)
+    end
+  end
+
+  describe '#add_attribute' do
+    let(:attribute_name) {'some_name'}
+    let(:attribute_value) {'cool_value'}
+
+    context 'Added an attribute without extra options' do
+      before do
+        @builder = @builder.add_attribute(attribute_name, attribute_value)
+      end
+
+      it_behaves_like 'one attribute added'
+    end
+
+    context 'Added an attribute with no specified extra options' do
+      before do
+        @builder = @builder.add_attribute(attribute_name, attribute_value)
+      end
+
+      it_behaves_like 'one attribute added'
+    end
+
+    context 'Added an attribute with empty extra options' do
+      before do
+        @builder = @builder.add_attribute(attribute_name, attribute_value, {})
+      end
+
+      it_behaves_like 'one attribute added'
+    end
+
+    context 'Added an attribute with extra options' do
+      let(:extra_key) {'doc'}
+      let(:extra_value) {'Some documentation'}
+      let(:extra_options) { {extra_key => extra_value} }
+
+      before do
+        @builder = @builder.add_attribute(attribute_name, attribute_value, extra_options)
+      end
+
+      it_behaves_like 'one attribute added'
+
+      it_behaves_like 'it can reconstruct itself'
+
+      it 'adds any extra options as keys under the attribute name hash' do
+        expect(semantic_field[attribute_name].has_key?(extra_key)).to eq(true)
+      end
+
+      it 'adds the correct value for the extra options' do
+        expect(semantic_field[attribute_name][extra_key]).to eq(extra_value)
+      end
+    end
+
+  end
+
+  describe '#add_transition' do
+    let(:transition_name) {'trusmis'}
+    let(:transition_href) {'/path_to_there'}
+
+    context 'Added a transition without extra options' do
+      before do
+        @builder = @builder.add_transition(transition_name, transition_href)
+      end
+
+      it_behaves_like 'one transition added'
+
+      it_behaves_like 'it can reconstruct itself'
+    end
+
+    context 'Added a transition with extra options' do
+      let(:extra_key) {:doc}
+      let(:extra_value) {'Some documentation'}
+      let(:extra_options) { {extra_key => extra_value} }
+
+      before do
+        @builder = @builder.add_transition(transition_name, transition_href, extra_options)
+      end
+
+      it_behaves_like 'one transition added'
+
+      it 'adds any extra options as keys under the attribute name hash' do
+        expect(transitions_field.first.has_key?(extra_key)).to eq(true)
+      end
+
+      it 'adds the correct value for the extra options' do
+        expect(transitions_field.first[extra_key]).to eq(extra_value)
+      end
+
+      it_behaves_like 'it can reconstruct itself'
+    end
+  end
+
+  describe '#add_transition_array' do
+    let(:transition_name) {'mumismo'}
+    let(:transition_href) {'/path_to_there'}
+    let(:transition_array) { [{hello: 'world', :href => transition_href}, {count: 10, href: '/another_path'}]}
+
+    before do
+      @builder = @builder.add_transition_array(transition_name, transition_array)
+    end
+
+    it 'creates two elements under transitions' do
+      expect(transitions_field.size).to eq(2)
+    end
+
+    it_behaves_like 'one transition added'
+
+    it_behaves_like 'it can reconstruct itself'
+  end
+
+
+  describe '#add_embedded' do
+    let(:embedded_name) {'trusmis'}
+    let(:embedded_value) {  { 'data' => 'here'}}
+
+    context 'Added an embedded' do
+      before do
+        @builder = @builder.add_embedded(embedded_name, embedded_value)
+      end
+
+      it_behaves_like 'one embedded added'
+
+      it_behaves_like 'it can reconstruct itself'
+    end
+  end
+
+  context 'Reconstructing the Complex Hash Fixture' do
+    #TODO: Reconstructing the Complex Hash Fixture with Builder - Builder Needs Work
+    it 'accepts basic attributes' do
+      representor = Representors::Representor.new({protocol: 'http', # The protocol we're using
+        href: 'www.example.com/drds', # Crichton needs to say where we are
+        id: 'DRDs', # ID from desrciptor
+        doc: 'Describes the semantics, states and state transitions associated with DRDs.'
+        }) do |builder|
+          builder = builder.add_attribute('total_count', 2, { #semantic key
+            doc: 'The total count of DRDs.', # Descriptor semantic doc
+            type: 'semantic', # Descriptor semantic type
+            profile: 'http://alps.io/schema.org/Integer', # same as 'href' in Descriptor file
+            sample: 1, # same as sample in descriptor
+          },)
+        end # Doc from descriptor
+        expect(representor.properties["total_count"]).to eq(2)
+    end
+  end
+
+end