ladder 0.1.0 → 0.1.1

data/spec/shared/resource.rb

@@ -0,0 +1,354 @@
+shared_examples 'a Resource' do
+  let(:subject) { Thing.new }
+  let(:person) { Person.new }
+
+  shared_context 'with data' do
+    let(:concept) { Concept.new }
+    let(:part)    { Part.new }
+    
+    before do
+      class Concept
+        include Ladder::Resource
+      end
+
+      class Part
+        include Ladder::Resource
+      end
+
+      # non-localized literal
+      subject.class.field :alt
+      subject.class.property :alt, :predicate => RDF::DC.alternative
+      subject.alt = 'Mumintrollet pa kometjakt'
+
+      # localized literal
+      subject.class.property :title, :predicate => RDF::DC.title
+      subject.title = 'Comet in Moominland'
+
+      # many-to-many
+      person.class.property :things, :predicate => RDF::DC.relation, :class_name => 'Thing'
+      subject.class.property :people, :predicate => RDF::DC.creator, :class_name => 'Person'
+      subject.people << person
+
+      # one-sided has-many
+      subject.class.has_and_belongs_to_many :concepts, inverse_of: nil
+      subject.class.property :concepts, :predicate => RDF::DC.subject, :class_name => 'Concept'
+      subject.concepts << concept
+
+      # embedded one
+      part.class.embedded_in :thing
+      part.class.property :thing, :predicate => RDF::DC.relation, :class_name => 'Thing'
+      subject.class.embeds_one :part, cascade_callbacks: true
+      subject.class.property :part, :predicate => RDF::DC.hasPart, :class_name => 'Part'
+      subject.part = part
+      subject.save
+    end
+
+    after do
+      Object.send(:remove_const, 'Concept')
+      Object.send(:remove_const, 'Part')
+    end
+
+    it 'should have relations' do
+      expect(subject.title).to eq 'Comet in Moominland'
+      expect(subject.people.to_a).to include person
+      expect(subject.concepts.to_a).to include concept
+      expect(subject.part).to eq part
+    end
+    
+    it 'should have reverse relations' do
+      expect(person.things.to_a).to include subject
+      expect(concept.relations).to be_empty
+      expect(part.thing).to eq subject
+    end
+  end
+
+  describe 'LADDER_BASE_URI' do
+    it 'should automatically have a base URI' do
+      expect(subject.rdf_subject.parent).to eq RDF::URI('http://example.org/things/')
+    end
+  end
+
+  describe '#property' do
+    context 'with non-localized literal' do
+      before do
+        subject.class.field :alt
+        subject.class.property :alt, :predicate => RDF::DC.alternative
+        subject.alt = 'Mumintrollet pa kometjakt'
+      end
+
+      it 'should return non-localized value' do
+        expect(subject.alt).to eq 'Mumintrollet pa kometjakt'
+      end
+      
+      it 'should not be a localized hash' do
+        expect(subject.attributes['alt']).to eq 'Mumintrollet pa kometjakt'
+      end
+      
+      it 'should have a valid predicate' do
+        expect(subject.class.properties['alt'].predicate).to eq RDF::DC.alternative
+      end
+
+      it 'allows resetting of properties' do
+        subject.class.property :alt, :predicate => RDF::DC.title
+        expect(subject.class.properties['alt'].predicate).to eq RDF::DC.title
+      end
+    end
+    
+    context 'with localized literal' do
+      before do
+        subject.class.property :title, :predicate => RDF::DC.title
+        subject.title = 'Comet in Moominland'
+      end
+      
+      it 'should return localized value' do
+        expect(subject.title).to eq 'Comet in Moominland'
+      end
+      
+      it 'should return all locales' do
+        expect(subject.attributes['title']).to eq({'en' => 'Comet in Moominland'})
+      end
+      
+      it 'should have a valid predicate' do
+        expect(subject.class.properties['title'].predicate).to eq RDF::DC.title
+      end
+
+      it 'allows resetting of properties' do
+        subject.class.property :title, :predicate => RDF::DC.alternative
+        expect(subject.class.properties['title'].predicate).to eq RDF::DC.alternative
+      end
+    end
+
+    context 'with many-to-many' do
+      before do
+        subject.class.property :people, :predicate => RDF::DC.creator, :class_name => 'Person'
+        person.class.property :things, :predicate => RDF::DC.relation, :class_name => 'Thing'
+        subject.people << person
+        subject.save
+      end
+
+      it 'should have a relation' do
+        expect(subject.relations['people'].relation).to eq (Mongoid::Relations::Referenced::ManyToMany)
+        expect(subject.people.to_a).to include person
+      end
+
+      it 'should have an inverse relation' do
+        expect(person.relations['things'].relation).to eq (Mongoid::Relations::Referenced::ManyToMany)
+        expect(person.things.to_a).to include subject
+      end
+
+      it 'should have a valid predicate' do
+        expect(subject.class.properties['people'].predicate).to eq RDF::DC.creator
+      end
+
+      it 'should have a valid inverse predicate' do
+        expect(person.class.properties['things'].predicate).to eq RDF::DC.relation
+      end
+    end
+
+    context 'with one-sided has-many' do
+      before do
+        subject.class.has_and_belongs_to_many :people, inverse_of: nil
+        subject.class.property :people, :predicate => RDF::DC.creator, :class_name => 'Person'
+        subject.people << person
+      end
+
+      it 'should have a relation' do
+        expect(subject.relations['people'].relation).to eq (Mongoid::Relations::Referenced::ManyToMany)
+        expect(subject.people.to_a).to include person
+      end
+
+      it 'should not have an inverse relation' do
+        expect(subject.relations['people'].inverse_of).to be nil
+        expect(person.relations).to be_empty
+      end
+
+      it 'should have a valid predicate' do
+        expect(subject.class.properties['people'].predicate).to eq RDF::DC.creator
+      end
+
+      it 'should not have an inverse predicate' do
+        expect(person.class.properties).to be_empty
+      end
+    end
+
+    context 'with embeds-many' do
+      before do
+        subject.class.embeds_many :people
+        subject.class.property :people, :predicate => RDF::DC.creator, :class_name => 'Person'
+
+        person.class.embedded_in :thing
+        person.class.property :thing, :predicate => RDF::DC.relation, :class_name => 'Thing'
+
+        subject.people << person
+      end
+
+      it 'should have a relation' do
+        expect(subject.relations['people'].relation).to eq (Mongoid::Relations::Embedded::Many)
+        expect(subject.people.to_a).to include person
+      end
+
+      it 'should have an inverse relation' do
+        expect(person.relations['thing'].relation).to eq (Mongoid::Relations::Embedded::In)
+        expect(person.thing).to eq subject
+      end
+
+      it 'should have a valid predicate' do
+        expect(subject.class.properties['people'].predicate).to eq RDF::DC.creator
+      end
+
+      it 'should have a valid inverse predicate' do
+        expect(person.class.properties['thing'].predicate).to eq RDF::DC.relation
+      end
+    end
+  end
+
+  describe '#update_resource' do
+
+    context 'without related: true' do
+      include_context 'with data'
+      
+      before do
+        subject.update_resource
+      end
+
+      it 'should have a literal object' do
+        subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.title).each_statement do |s|
+          expect(s.object.to_s).to eq 'Comet in Moominland'
+        end
+      end
+
+      it 'should have an embedded object' do
+        query = subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.hasPart)
+        expect(query.count).to eq 1
+        
+        query.each_statement do |s|
+          expect(s.object).to eq part.rdf_subject
+        end
+      end
+
+      it 'should have an embedded object relation' do
+        query = subject.resource.query(:subject => part.rdf_subject, :predicate => RDF::DC.relation)
+        expect(query.count).to eq 1
+        expect(query.to_hash).to eq part.resource.statements.to_hash
+
+        query.each_statement do |s|
+          expect(s.object).to eq subject.rdf_subject
+        end
+      end
+
+      it 'should not have related objects' do
+        expect(subject.resource.query(:subject => person.rdf_subject)).to be_empty
+        expect(subject.resource.query(:subject => concept.rdf_subject)).to be_empty
+      end
+
+      it 'should not have related object relations' do
+        expect(person.resource.statements).to be_empty
+        expect(concept.resource.statements).to be_empty
+      end
+    end
+
+    context 'with related: true' do
+      include_context 'with data'
+      
+      before do
+        subject.update_resource(:related => true)
+      end
+
+      it 'should have a literal object' do
+        subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.title).each_statement do |s|
+          expect(s.object.to_s).to eq 'Comet in Moominland'
+        end
+      end
+
+      it 'should have an embedded object' do
+        query = subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.hasPart)
+        expect(query.count).to eq 1
+        
+        query.each_statement do |s|
+          expect(s.object).to eq part.rdf_subject
+        end
+      end
+
+      it 'should have an embedded object relation' do
+        query = subject.resource.query(:subject => part.rdf_subject, :predicate => RDF::DC.relation)
+        expect(query.count).to eq 1
+        expect(query.to_hash).to eq part.resource.statements.to_hash
+
+        query.each_statement do |s|
+          expect(s.object).to eq subject.rdf_subject
+        end
+      end
+
+      it 'should have related objects' do
+        # many-to-many
+        query_creator = subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.creator)
+        expect(query_creator.count).to eq 1
+
+        query_creator.each_statement do |s|
+          expect(s.object).to eq person.rdf_subject
+        end
+
+        # one-sided has-many
+        query_subject = subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.subject)
+        expect(query_subject.count).to eq 1
+
+        query_subject.each_statement do |s|
+          expect(s.object).to eq concept.rdf_subject
+        end
+      end
+
+      it 'should have related object relations' do
+        # many-to-many
+        query = person.resource.query(:subject => person.rdf_subject, :predicate => RDF::DC.relation)
+        expect(query.count).to eq 1
+        expect(query.to_hash).to eq person.resource.statements.to_hash
+
+        query.each_statement do |s|
+          expect(s.object).to eq subject.rdf_subject
+        end
+        
+        # one-sided has-many
+        expect(subject.resource.query(:subject => concept.rdf_subject)).to be_empty
+        expect(concept.resource.statements).to be_empty
+      end
+    end
+
+    context 'with related and then without related' do
+      include_context 'with data'
+      
+      before do
+        subject.update_resource(:related => true)
+        subject.update_resource
+      end
+
+      it 'should not have related objects' do
+        expect(subject.resource.query(:subject => person.rdf_subject)).to be_empty
+        expect(subject.resource.query(:subject => concept.rdf_subject)).to be_empty
+      end
+
+      it 'should have related object relations' do
+        # many-to-many
+        query = person.resource.query(:subject => person.rdf_subject, :predicate => RDF::DC.relation)
+        expect(query.count).to eq 1
+        expect(query.to_hash).to eq person.resource.statements.to_hash
+
+        query.each_statement do |s|
+          expect(s.object).to eq subject.rdf_subject
+        end
+        
+        # one-sided has-many
+        expect(subject.resource.query(:subject => concept.rdf_subject)).to be_empty
+        expect(concept.resource.statements).to be_empty
+      end
+    end
+  end
+  
+  describe '#as_jsonld' do
+    include_context 'with data'
+    
+    it 'should output a valid jsonld representation of itself' do
+      g = RDF::Graph.new << JSON::LD::API.toRdf(subject.as_jsonld)
+      expect(subject.resource.to_hash == g.to_hash).to be true
+    end
+  end
+end

data/spec/shared/searchable.rb

@@ -0,0 +1,191 @@
+shared_examples 'a Searchable' do
+  let(:subject) { Thing.new }
+  let(:person) { Person.new }
+
+  shared_context 'with data' do
+    before do
+      subject.class.configure type: RDF::DC.BibliographicResource
+      subject.class.property :title, :predicate => RDF::DC.title
+      subject.title = 'Comet in Moominland'
+    end
+  end
+
+  describe '#index_for_search' do
+    include_context 'with data'
+
+    context 'with default' do
+      before do
+        subject.class.index_for_search
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+
+      it 'should exist in the index' do
+        results = subject.class.search('title:moomin*')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash).to eq JSON.parse(subject.as_indexed_json.to_json)
+      end
+    end
+
+    context 'with as qname' do
+      before do
+        subject.class.index_for_search as: :qname
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+
+      it 'should exist in the index' do
+        results = subject.class.search('dc.title.en:moomin*')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash).to eq JSON.parse(subject.as_qname.to_json)
+      end
+    end
+
+    context 'with as jsonld' do
+      before do
+        subject.class.index_for_search as: :jsonld
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+      
+      it 'should exist in the index' do
+        results = subject.class.search('dc\:title.@value:moomin*')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash).to eq subject.as_jsonld
+      end
+    end  
+  end
+
+  describe '#index_for_search related' do
+    include_context 'with data'
+    
+    before do
+      # related object
+      person.class.configure type: RDF::FOAF.Person
+      person.class.property :foaf_name, :predicate => RDF::FOAF.name
+      person.foaf_name = 'Tove Jansson'
+
+      # many-to-many relation
+      person.class.property :things, :predicate => RDF::DC.relation, :class_name => 'Thing'
+      subject.class.property :people, :predicate => RDF::DC.creator, :class_name => 'Person'
+      subject.people << person
+    end
+
+    context 'with default' do
+      before do
+        person.class.index_for_search
+        subject.class.index_for_search
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+
+      it 'should contain an ID for the related object' do
+        results = subject.class.search('person_ids.$oid:' + person.id)
+        expect(results.count).to eq 1
+      end
+
+      it 'should include the related object in the index' do
+        results = person.class.search('foaf_name:tove')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash).to eq JSON.parse(person.as_indexed_json.to_json)
+      end
+
+      it 'should contain an ID for the subject' do
+        results = person.class.search('thing_ids.$oid:' + subject.id)
+        expect(results.count).to eq 1
+      end
+    end
+
+    context 'with as qname' do
+      before do
+        person.class.index_for_search as: :qname
+        subject.class.index_for_search as: :qname
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+
+      it 'should contain an ID for the related object' do
+        results = subject.class.search('dc.creator:' + person.id)
+        expect(results.count).to eq 1
+      end
+
+      it 'should include the related object in the index' do
+        results = person.class.search('foaf.name.en:tove')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash).to eq JSON.parse(person.as_qname.to_json)
+      end
+
+      it 'should contain an ID for the subject' do
+        results = person.class.search('dc.relation:' + subject.id)
+        expect(results.count).to eq 1
+      end
+    end
+
+    context 'with as_qname related' do
+      before do
+        person.class.index_for_search as: :qname, related: true
+        subject.class.index_for_search as: :qname, related: true
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+
+      it 'should contain a embedded related object' do
+        results = subject.class.search('dc.creator.foaf.name.en:tove')
+        expect(results.count).to eq 1
+        expect(results.first._source['dc']['creator'].first).to eq Hashie::Mash.new person.as_qname
+      end
+
+      it 'should contain an embedded subject in the related object' do
+        results = person.class.search('dc.relation.dc.title.en:moomin*')
+        expect(results.count).to eq 1
+        expect(results.first._source['dc']['relation'].first).to eq Hashie::Mash.new subject.as_qname
+      end
+    end
+
+    context 'with as_jsonld' do
+      before do
+        person.class.index_for_search as: :jsonld
+        subject.class.index_for_search as: :jsonld
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+      
+      it 'should contain an ID for the related object' do
+        results = subject.class.search('dc\:creator.@id:' + person.id)
+        expect(results.count).to eq 1
+      end
+
+      it 'should include the related object in the index' do
+        results = person.class.search('foaf\:name.@value:tove')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash).to eq person.as_jsonld
+      end
+
+      it 'should contain an ID for the subject' do
+        results = person.class.search('dc\:relation.@id:' + subject.id)
+        expect(results.count).to eq 1
+      end
+    end
+
+    context 'with as_jsonld related' do
+      before do
+        person.class.index_for_search as: :jsonld, related: true
+        subject.class.index_for_search as: :jsonld, related: true
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+
+      it 'should contain a embedded related object' do
+        results = subject.class.search('dc\:creator.foaf\:name.@value:tove')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash['dc:creator']).to eq person.as_jsonld.except '@context'
+      end
+
+      it 'should contain an embedded subject in the related object' do
+        results = person.class.search('dc\:relation.dc\:title.@value:moomin*')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash['dc:relation']).to eq subject.as_jsonld.except '@context'
+      end
+    end
+  end
+end