hydramata-works 0.0.1.prerelease

data/spec/models/hydramata/works/predicates_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_fast_helper'
+require 'hydramata/works/predicates'
+require 'hydramata/works/linters/implement_predicate_interface_matcher'
+
+
+module Hydramata
+  module Works
+    describe Predicates do
+
+      context '.find' do
+        it 'uses the identity to construct the appropriate predicate' do
+          expect(described_class.find('name', { something: 'george' })).to implement_predicate_interface
+        end
+      end
+
+    end
+  end
+end

data/spec/models/hydramata/works/presentation_structure_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_fast_helper'
+require 'hydramata/works/presentation_structure'
+
+module Hydramata
+  module Works
+    describe PresentationStructure do
+      subject { described_class.new }
+      let(:fieldset) { [:required, [:title]] }
+
+      context '.build' do
+        let(:object) { double('Object with predicate sets', predicate_sets: ['predicate_1', 'predicate_2']) }
+        it 'should transform an entities predicate_sets to fieldsets' do
+          structure = described_class.build_from(object)
+          expect(structure.fieldsets).to eq(object.predicate_sets)
+        end
+      end
+
+      context '#fieldsets' do
+        it 'can be appended' do
+          expect { subject.fieldsets << fieldset }.
+            to change { subject.fieldsets.count }.
+            by(1)
+        end
+      end
+    end
+  end
+end

data/spec/models/hydramata/works/property_set_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_fast_helper'
+require 'hydramata/works/property_set'
+
+module Hydramata
+  module Works
+    describe PropertySet do
+      subject { PropertySet.new }
+      let(:property) { Property.new(predicate: :title, value: 'value one') }
+
+      context 'predicate order' do
+        it 'the first predicate pushed will return as the first' do
+          subject << (first = Property.new(predicate: :one, value: 1))
+          subject << (second = Property.new(predicate: :two, value: 2))
+          subject << (third = Property.new(predicate: :three, value: 3))
+
+          # Note: I am pushing a Property with the same predicate as the first
+          # object pushed. This will modify
+          subject << Property.new(predicate: :one, value: 4)
+
+          expect { |b| subject.each(&b) }.to yield_successive_args(first, second, third)
+        end
+      end
+
+      it 'exposes #properties' do
+        subject << property
+        expect(subject.properties).to eq([property])
+      end
+
+      it 'allows properties to be pushed onto it' do
+        expect { subject << property }.
+          to change { subject.count }.
+          by(1)
+      end
+
+      it 'amends an existing property if a common predicate is found' do
+        property = Property.new(predicate: :title, value: 'value one')
+        property_with_same_predicate = Property.new(predicate: :title, value: 'another')
+        subject << property
+        expect do
+          expect { subject << property_with_same_predicate }.
+            to_not change { subject.count }
+        end.to change { property.values }.
+          from(['value one']).
+          to(['value one', 'another'])
+      end
+
+      context 'data retrieval methods' do
+        before { subject << property }
+
+        context '#predicates' do
+          it 'should be the predicate names' do
+            expect(subject.predicates).to eq [property.predicate.to_s]
+          end
+        end
+
+        context '#fetch' do
+          it 'should raise an error if the predicate is not found' do
+            expect { subject.fetch(:missing) }.to raise_error(KeyError)
+          end
+
+          it 'should return the values if the predicate exists' do
+            expect(subject.fetch(property.predicate)).to eq(property)
+          end
+        end
+
+        context '#key?' do
+          it 'should be false if predicate does not exist' do
+            expect(subject.key?(:missing)).to be_falsey
+          end
+
+          it 'should return the values if the predicate exists' do
+            expect(subject.key?(property.predicate)).to be_truthy
+          end
+        end
+
+        context '#[]' do
+          it 'should return nil if the predicate is not found' do
+            expect(subject[:missing]).to eq(Property.new(predicate: :missing))
+          end
+
+          it 'should return the values if the predicate exists' do
+            expect(subject[property.predicate]).to eq(property)
+          end
+        end
+
+        context '#each' do
+          it 'should yield the predicate and normalized values' do
+            expect { |b| subject.each(&b) }.to yield_with_args(property)
+          end
+        end
+
+        context '#==' do
+          it 'should return true if underlying properties are identical' do
+            property_set = described_class.new
+            other = described_class.new
+
+            expect(property_set == other).to be_truthy
+          end
+
+          it 'should return false if different classes' do
+            property_set = described_class.new
+            other = 'abc'
+
+            expect(property_set == other).to be_falsey
+          end
+
+          it 'should return false if underlyng properties are different' do
+            property_set = described_class.new
+            other = described_class.new
+            property_set << property
+
+            expect(property_set == other).to be_falsey
+          end
+
+          it 'should return true if empty property set and hash are compared' do
+            property_set = described_class.new
+            other = {}
+
+            expect(property_set == other).to be_truthy
+          end
+        end
+
+        context '#subset' do
+          let(:a_second_property) { { predicate: :another_predicate, value: 'another value' } }
+          it 'should return a property set that only has the specified keys' do
+            subject << a_second_property
+            subset = described_class.new
+            subset << property
+            expect(subject.subset(property.predicate)).to eq(subset)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/hydramata/works/property_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_fast_helper'
+require 'hydramata/works/property'
+
+module Hydramata
+  module Works
+    describe Property do
+      let(:predicate) { 'Predicate' }
+      let(:value) { double('Value') }
+      subject { described_class.new(predicate: predicate) }
+
+      it { should respond_to :values }
+      it { should respond_to :name }
+
+      it 'should delegate #each to #values' do
+        subject << value
+        expect { |b| subject.each(&b) }.to yield_with_args(value)
+      end
+
+      it 'can append to values' do
+        expect { subject << value }.
+          to change { subject.values }.
+          from([]).
+          to([value])
+      end
+
+      it 'should have a #to_translation_key_fragment' do
+        expect(subject.to_translation_key_fragment).to eq(subject.predicate.to_translation_key_fragment)
+      end
+
+      context 'case equality' do
+        it 'should delegate to the compared object' do
+          object = double('Double')
+          expect(object).
+            to receive(:instance_of?).
+            with(Property).
+            and_return(true)
+          expect(Property === object).to eq(true)
+        end
+      end
+
+      context 'equality' do
+        it 'is not equal if the predicates are different' do
+          property = described_class.new(predicate: :hello)
+          other = described_class.new(predicate: :goodbye)
+          expect(property == other).to eq(false)
+        end
+
+        it 'is equal if the predicates and values are the same' do
+          property = described_class.new(predicate: :hello, values: [123])
+          other = described_class.new(predicate: :hello, values: [123])
+          expect(property == other).to eq(true)
+        end
+
+        it 'is not equal if the predicates are the same but values are the different' do
+          property = described_class.new(predicate: :hello, values: [123])
+          other = described_class.new(predicate: :hello, values: [123, 345])
+          expect(property == other).to eq(false)
+        end
+
+        it 'is not equal if the predicates are different but the values are the same' do
+          property = described_class.new(predicate: :goodbye, values: [123])
+          other = described_class.new(predicate: :hello, values: [123])
+          expect(property == other).to eq(false)
+        end
+
+        it 'is not equal if of different classes' do
+          property = described_class.new(predicate: :goodbye, values: [123])
+          other = Struct.new(:predicate, :values).new(:goodbye, [123])
+          expect(property == other).to eq(false)
+        end
+      end
+    end
+  end
+end

data/spec/models/hydramata/works/value_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_fast_helper'
+require 'date'
+require 'hydramata/works/value'
+require 'hydramata/works/linters/implement_value_interface_matcher'
+
+module Hydramata
+  module Works
+    describe Value do
+      let(:raw_object) { double('Raw Object') }
+      let(:value) { 123456789 }
+      subject { described_class.new(value: value, raw_object: raw_object) }
+
+      it { should implement_value_interface }
+
+      it 'should have a #raw_object' do
+        expect(subject.raw_object).to eq(raw_object)
+      end
+
+      it 'should have a friendly inspect message, because tracking it down could be a pain' do
+        expect(subject.inspect).to include("#{described_class}")
+        expect(subject.inspect).to include(raw_object.inspect)
+        expect(subject.inspect).to include(value.inspect)
+      end
+
+      it 'should be an instance of the presented object\'s class' do
+        expect(subject.instance_of?(value.class)).to be_truthy
+      end
+
+      context '#==' do
+        context 'for two value objects' do
+          it 'should not be true if underlying objects do not match' do
+            expect(described_class.new(value: 123) == described_class.new(value: 1234)).to be_falsey
+          end
+          it 'should be true if underlying objects match' do
+            expect(described_class.new(value: Date.new(2013,1,3)) == described_class.new(value: Date.new(2013,1,3))).to be_truthy
+          end
+        end
+        context 'for integers' do
+          let(:value) { 123456789 }
+          it 'should be equal when base value is the same' do
+            expect(subject == value).to be_truthy
+          end
+        end
+
+        context 'for strings' do
+          let(:value) { 'Hello World' }
+          it 'should be equal when base value is the same' do
+            expect(subject == value).to be_truthy
+          end
+        end
+
+        context 'for dates' do
+          let(:value) { Date.new(2013,1,3) }
+          it 'should be equal when base value is the same' do
+            expect(subject == Date.new(2013,1,3)).to be_truthy
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/hydramata/works/work_type_spec.rb

@@ -0,0 +1,45 @@
+# Instead of using spec_helper, I'm using the twice as fast custom helper
+# for active record objects.
+require 'spec_fast_helper'
+require 'hydramata/works/work_type'
+require 'hydramata/works/linters/implement_work_type_interface_matcher'
+require 'hydramata/works/linters/implement_data_definition_interface_matcher'
+
+module Hydramata
+  module Works
+    describe WorkType do
+      subject { described_class.new(identity: 'My Identity') }
+      it { should implement_work_type_interface }
+      it { should implement_data_definition_interface }
+
+      context '#predicate_sets=' do
+        it 'handles predicate set conversion' do
+          subject = described_class.new(identity: 'My Identity', predicate_sets: ['one predicate', 'two predicate'])
+          expect(subject.predicate_sets).to eq([PredicateSet.new(identity: 'one predicate'), PredicateSet.new(identity: 'two predicate')])
+        end
+      end
+
+      it 'should have #fieldsets that is an alias of #predicate_sets' do
+        subject = described_class.new(identity: 'My Identity', predicate_sets: ['one predicate', 'two predicate'])
+        expect(subject.fieldsets).to eq(subject.predicate_sets)
+      end
+
+      context '#itemtype_schema_dot_org' do
+        it 'should utilize the default' do
+          subject = described_class.new(identity: 'My Identity')
+          expect(subject.itemtype_schema_dot_org).to match(/\Ahttps?:\/\/schema.org/)
+        end
+
+        it 'should prepend http://schema.org if is missing' do
+          subject = described_class.new(identity: 'My Identity', itemtype_schema_dot_org: 'Thing')
+          expect(subject.itemtype_schema_dot_org).to eq('http://schema.org/Thing')
+        end
+
+        it 'should accept http directly' do
+          subject = described_class.new(identity: 'My Identity', itemtype_schema_dot_org: 'http://schema.org/CreativeWork')
+          expect(subject.itemtype_schema_dot_org).to eq('http://schema.org/CreativeWork')
+        end
+      end
+    end
+  end
+end

data/spec/models/hydramata/works/work_types/storage_spec.rb

@@ -0,0 +1,74 @@
+# Instead of using spec_helper, I'm using the twice as fast custom helper
+# for active record objects.
+require 'spec_active_record_helper'
+require 'hydramata/works/work_types/storage'
+require 'hydramata/works/linters/implement_work_type_interface_matcher'
+
+module Hydramata
+  module Works
+    module WorkTypes
+
+      describe Storage do
+        subject { described_class.new }
+        it { should implement_work_type_interface }
+
+        let(:identity) { 'http://hello.com/world' }
+        subject { described_class.create(identity: identity, name_for_application_usage: 'hello_world') }
+
+        context '#to_work_type' do
+          it 'returns a WorkType object' do
+            work_type = described_class.new do |work_type|
+              work_type.predicate_sets.build(identity: 'hello')
+            end.to_work_type
+
+            expect(work_type).to implement_work_type_interface
+            expect(work_type.predicate_sets.size).to eq(1)
+          end
+        end
+
+        context '.find_by_identity' do
+
+          it 'returns a WorkType object when identity exists' do
+            subject # creating the object
+            expect(described_class.find_by_identity!(identity)).to implement_work_type_interface
+          end
+
+          it 'returns nil when identity is missing' do
+            # @TODO - Should this be a NullPredicate?
+            expect { described_class.find_by_identity!(identity) }.to raise_error
+          end
+        end
+
+        context '.existing_attributes_for' do
+          it 'should return the existing work_type attributes' do
+            subject
+            keys = [
+              :id,
+              :identity,
+              :name_for_application_usage
+            ]
+            actual_values = described_class.existing_attributes_for(identity).values_at(keys)
+            # Because date comparisons are a bit wonky
+            expect(actual_values).to eq(subject.attributes.values_at(keys))
+          end
+
+          it 'should return the identity if a matching work_type was not found' do
+            expect(described_class.existing_attributes_for(identity)).to eq(identity: identity)
+          end
+
+          it 'should handle connection failed' do
+            expect(described_class).to receive(:find_by_identity!).and_raise(ActiveRecord::ConnectionNotEstablished)
+            expect(described_class.existing_attributes_for(identity)).to eq(identity: identity)
+          end
+        end
+
+        it 'should have many :predicate_sets' do
+          expect { subject.predicate_sets.create(identity: 'required', presentation_sequence: 1) }.
+            to change { subject.predicate_sets.count }.
+            by(1)
+        end
+
+      end
+    end
+  end
+end

data/spec/models/hydramata/works/work_types_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_fast_helper'
+require 'hydramata/works/work_types'
+require 'hydramata/works/linters/implement_work_type_interface_matcher'
+
+
+module Hydramata
+  module Works
+    describe WorkTypes do
+      context '.find' do
+        it 'uses the identity to construct the appropriate work_type' do
+          expect(described_class.find('name', { something: 'george' })).to implement_work_type_interface
+        end
+      end
+    end
+  end
+end