hydramata-works 0.0.1.prerelease

data/spec/lib/hydramata/works/conversions/value_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_fast_helper'
+require 'hydramata/works/conversions/value'
+require 'hydramata/works/linters/implement_value_interface_matcher'
+
+module Hydramata
+  module Works
+    describe Conversions do
+      include Conversions
+
+      context '#Value' do
+        it 'should convert a Hash to a Value object' do
+          expect(Value(value: 'hello')).to implement_value_interface
+        end
+
+        it 'should convert an object that implements #to_value' do
+          object = double(to_value: Value.new(value: 'Value'))
+          expect(Value(object)).to eq(object.to_value)
+        end
+
+        it 'should convert a String to a Value object' do
+          expect(Value('hello')).to implement_value_interface
+        end
+
+        it 'should return the same Value if a Value is given' do
+          value = Value('hello')
+          expect(Value(value).object_id).to eq(value.object_id)
+        end
+
+        it 'should raise an error object is unexpected' do
+          expect { Value([]) }.to raise_error
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/hydramata/works/conversions/work_type_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_fast_helper'
+require 'hydramata/works/conversions/work_type'
+require 'hydramata/works/linters/implement_work_type_interface_matcher'
+
+module Hydramata
+  module Works
+    describe Conversions do
+      include Conversions
+
+      context '#WorkType' do
+        it 'should not convert something that is not empty' do
+          expect{ WorkType(double(:empty? => false)) }.to raise_error
+        end
+        it 'should convert an empty value to a WorkType null object' do
+          expect(WorkType()).to implement_work_type_interface.with(:identity, 'unknown')
+        end
+
+        it 'should convert an Array to a WorkType null object' do
+          expect(WorkType([])).to implement_work_type_interface.with(:identity, 'unknown')
+        end
+
+        it 'should convert Nil to a WorkType null object' do
+          expect(WorkType(nil)).to implement_work_type_interface.with(:identity, 'unknown')
+        end
+
+        it 'should convert a String to a WorkType object' do
+          expect(WorkType('hello')).to implement_work_type_interface
+        end
+
+        it 'should convert a Symbol to a WorkType object' do
+          expect(WorkType(:hello)).to implement_work_type_interface
+        end
+
+        it 'should return the same work_type if a WorkType is given' do
+          work_type = WorkType(:hello)
+          expect(WorkType(work_type).object_id).to eq(work_type.object_id)
+        end
+
+        it 'should convert a "well-formed" Hash to a WorkType object' do
+          expect(WorkType(identity: 'hello')).to implement_work_type_interface
+        end
+
+        it 'should convert a "#to_work_type" to a WorkType object' do
+          stored_object = double('Object', to_work_type: WorkType.new)
+          expect(WorkType(stored_object)).to implement_work_type_interface
+        end
+
+        it 'should raise an error if the Hash is not "well-formed"' do
+          expect { WorkType(other: 'hello') }.to raise_error
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/hydramata/works/translator_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_fast_helper'
+require 'hydramata/works/translator'
+
+module Hydramata
+  module Works
+    describe Translator do
+      subject do
+        described_class.new(
+          base_scope: base_scope,
+          translation_service: translation_service,
+          translation_service_error: translation_service_error
+        )
+      end
+      let(:base_scope) { ['hydramata', 'work'] }
+      let(:scopes) { [['grandparent', 'parent'], ['grandparent']] }
+      let(:translation_service) { double('TranslationService', translate: true) }
+      let(:translation_service_error) { ArgumentError }
+
+      context '#translate' do
+        it 'passes options to the default rendering' do
+          expect(translation_service).to receive(:translate).
+            with('child', scope: base_scope, default: 'default').
+            ordered.
+            and_return('With Default')
+
+          expect(subject.translate('child', default: 'default')).to eq('With Default')
+        end
+
+        it 'attempts to translate through each scope then finally via the base scope' do
+          expect(translation_service).to receive(:translate).
+            with('child', scope: (base_scope + scopes[0]), raise: true).
+            ordered.
+            and_raise(translation_service_error)
+          expect(translation_service).to receive(:translate).
+            with('child', scope: (base_scope + scopes[1]), raise: true).
+            ordered.
+            and_raise(translation_service_error)
+          expect(translation_service).to receive(:translate).
+            with('child', scope: base_scope, scopes: scopes).
+            ordered.
+            and_return('My Work Type')
+
+          expect(subject.translate('child', scopes: scopes)).to eq('My Work Type')
+        end
+
+        it 'translates through each scope until it finds a match then returns without processing more generic case' do
+          expect(translation_service).to receive(:translate).
+            with('child', scope: (base_scope + scopes[0]), raise: true).
+            ordered.
+            and_raise(translation_service_error)
+          expect(translation_service).to receive(:translate).
+            with('child', scope: (base_scope + scopes[1]), raise: true).
+            ordered.
+            and_return('Found Grandparent')
+          expect(translation_service).to_not receive(:translate).
+            with('child', scope: base_scope)
+
+          expect(subject.translate('child', scopes: scopes)).to eq('Found Grandparent')
+        end
+
+        it 'translates through each scope until it finds a match then returns without processing more generic case' do
+          expect(translation_service).to receive(:translate).
+            with('child', scope: (base_scope + scopes[0]), raise: true).
+            ordered.
+            and_raise(translation_service_error)
+          expect(translation_service).to receive(:translate).
+            with('child', scope: (base_scope + scopes[1]), raise: true).
+            ordered.
+            and_raise(translation_service_error)
+          expect(translation_service).to_not receive(:translate).
+            with('child', scope: base_scope, scopes: scopes).
+            ordered.
+            and_raise(translation_service_error)
+
+          expect { subject.translate('child', scopes: scopes) }.to raise_error
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# 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/data_definition'
+require 'hydramata/works/linters/implement_data_definition_interface_matcher'
+
+module Hydramata
+  module Works
+    describe DataDefinition do
+      subject { described_class.new(identity: 'My Identity') }
+      it { should implement_data_definition_interface }
+
+      it 'should initialize via attributes' do
+        expect(subject.identity).to eq('My Identity')
+      end
+
+      it 'should have a meaningful #to_s' do
+        expect(subject.to_s).to eq('My Identity')
+      end
+
+      context '#==' do
+        subject { described_class.new(identity: 'My Identity') }
+
+        it 'be true if class and identity is equal' do
+          other = described_class.new(identity: subject.identity)
+          expect(subject == other).to be_truthy
+        end
+
+        it 'be false if identity is equal but not class' do
+          other = double(identity: subject.identity)
+          expect(subject == other).to be_falsey
+        end
+
+        it 'be false if class is equal but not identity' do
+          other = subject.class.new(identity: "#{subject.identity}1")
+          expect(subject == other).to be_falsey
+        end
+      end
+
+      context '#to_translation_key_fragment' do
+        it 'should default to identity if no name is given for application usage' do
+          expect(subject.to_translation_key_fragment).to eq subject.identity
+        end
+
+        it 'should default to identity if no name is given for application usage' do
+          subject = described_class.new(identity: 'My Identity', name_for_application_usage: 'Twonky')
+          expect(subject.to_translation_key_fragment).to eq 'Twonky'
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'spec_fast_helper'
+require 'hydramata/works/entity'
+require 'hydramata/works/linters/implement_entity_interface_matcher'
+
+module Hydramata
+  module Works
+    describe Entity do
+      subject { described_class.new }
+      it { should implement_entity_interface }
+
+      let(:predicate) { :title }
+      let(:value) { 'Hello' }
+      let(:property) { Property.new(predicate: predicate, value: value) }
+
+
+      context '#to_presenter' do
+        let(:presenter_builder) { double('Presenter Builder', call: :built) }
+        subject { described_class.new(presenter_builder: presenter_builder) }
+        it 'should call the presenter_builder' do
+          expect(subject.to_presenter).to eq(:built)
+          expect(presenter_builder).to have_received(:call).with(subject)
+        end
+      end
+
+      context '#has_property?' do
+        it 'changes from false to true when the property is added' do
+          expect { subject.properties << property }.
+            to change { subject.has_property?(predicate) }.
+            from(false).
+            to(true)
+        end
+      end
+
+      context '#properties' do
+        it 'can be appended' do
+          expect { subject.properties << property }.
+            to change { subject.properties.count }.
+            by(1)
+        end
+      end
+
+      context '#property' do
+        it 'returns matching predicates' do
+          subject.properties << property
+          expect(subject.properties[predicate]).to eq(property)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# 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/predicate_presentation_sequences/storage'
+
+module Hydramata
+  module Works
+    module PredicatePresentationSequences
+
+      describe Storage do
+        subject { described_class.new }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'spec_fast_helper'
+require 'hydramata/works/predicate_set'
+require 'hydramata/works/linters/implement_predicate_set_interface_matcher'
+
+module Hydramata
+  module Works
+    describe PredicateSet do
+      subject { described_class.new(identity: 'My Identity') }
+      it { should implement_predicate_set_interface }
+
+      it 'should initialize via attributes' do
+        expect(subject.identity).to eq('My Identity')
+      end
+
+      it 'should initialize via attributes' do
+        expect(subject.identity).to eq('My Identity')
+      end
+
+      context 'comparability' do
+        let(:work_type) { 'Work Type' }
+        let(:identity) { 'Identity' }
+        subject { described_class.new(identity: 'Identity', work_type: work_type) }
+
+        it 'is != if they are different base classes' do
+          other = double(work_type: work_type, identity: identity)
+          expect(subject == other).to be_falsey
+        end
+
+        it 'is == if they are the same object' do
+          expect(subject == subject).to be_truthy
+        end
+
+        it 'is == if work type and identity are the same' do
+          other = described_class.new(identity: identity, work_type: work_type)
+          expect(subject == other).to be_truthy
+        end
+
+        it 'is != if work type is the same but not identity' do
+          other = described_class.new(identity: identity + 'not', work_type: work_type)
+          expect(subject == other).to be_falsey
+        end
+
+        it 'is != if identity is the same but not work type' do
+          other = described_class.new(identity: identity, work_type: work_type + 'not')
+          expect(subject == other).to be_falsey
+        end
+
+        it 'is "nil" when we are comparing against other objects' do
+          other = double("Other")
+          expect(subject <=> other).to be_nil
+        end
+
+        it 'is based on the array underlying array' do
+          other = described_class.new(identity: 'Z' + identity, work_type: 'A' + work_type)
+          # The other one is greater than this one
+          expect(subject <=> other).to eq(1)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# 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_type'
+require 'hydramata/works/predicate_sets/storage'
+require 'hydramata/works/linters/implement_predicate_set_interface_matcher'
+
+module Hydramata
+  module Works
+    module PredicateSets
+
+      describe Storage do
+        it { should implement_predicate_set_interface }
+
+        let(:identity) { 'a predicate' }
+        let(:work_type) { WorkTypes::Storage.create(identity: 'a_work_type') }
+        subject do
+          described_class.create(
+            work_type: work_type,
+            identity: identity,
+            presentation_sequence: 1,
+            name_for_application_usage: 'predicate_set_name'
+          )
+        end
+
+        it 'belongs to a work_type' do
+          expect(subject.work_type).to eq(work_type)
+        end
+
+        it 'has #to_predicate_set' do
+          expect(described_class.new.to_predicate_set).to implement_predicate_set_interface
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# 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/predicate'
+require 'hydramata/works/linters/implement_predicate_interface_matcher'
+require 'hydramata/works/linters/implement_data_definition_interface_matcher'
+
+module Hydramata
+  module Works
+    describe Predicate do
+      subject { described_class.new }
+      it { should implement_predicate_interface }
+      it { should implement_data_definition_interface }
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# 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/predicates/storage'
+require 'hydramata/works/linters/implement_predicate_interface_matcher'
+
+module Hydramata
+  module Works
+    module Predicates
+
+      describe Storage do
+        subject { described_class.new }
+
+        let(:identity) { 'http://hello.com/world' }
+        let(:predicate) do
+          described_class.create(
+            identity: identity,
+            name_for_application_usage: 'hello-world',
+            datastream_name: 'descMetadata',
+            value_coercer_name: 'SimpleParser',
+            value_parser_name: 'SimpleParser',
+            indexing_strategy: 'dsti',
+            validations: '{ "presence": { "on": "create" } }'
+          )
+        end
+
+        it { should implement_predicate_interface }
+
+        context '#to_predicate' do
+          it 'coerces itself to a predicate' do
+            expect(described_class.new.to_predicate).to implement_predicate_interface
+          end
+        end
+
+        context '.find_by_identity' do
+
+          it 'returns a Predicate object when identity exists' do
+            predicate # creating the object
+            expect(described_class.find_by_identity!(identity)).to implement_predicate_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 predicate attributes' do
+            predicate
+            keys = [
+              :id,
+              :identity,
+              :name_for_application_usage,
+              :datastream_name,
+              :value_coercer_name,
+              :value_parser_name,
+              :indexing_strategy
+            ]
+            actual_values = described_class.existing_attributes_for(identity).values_at(keys)
+            # Because date comparisons are a bit wonky
+            expect(actual_values).to eq(predicate.attributes.values_at(keys))
+          end
+
+          it 'should return the identity if a matching predicate 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
+
+      end
+    end
+  end
+end