active-fedora 7.0.0.rc2 → 7.0.0.rc3

data/spec/unit/rdf_resource_datastream_spec.rb

@@ -0,0 +1,287 @@
+require 'spec_helper'
+
+describe ActiveFedora::RDFDatastream do
+  before do
+    class DummySubnode < ActiveFedora::Rdf::Resource
+      property :title, :predicate => RDF::DC[:title], :class_name => RDF::Literal
+      property :relation, :predicate => RDF::DC[:relation]
+    end
+
+    class DummyAsset < ActiveFedora::Base; end;
+
+    class DummyResource < ActiveFedora::RDFDatastream
+      property :title, :predicate => RDF::DC[:title], :class_name => RDF::Literal do |index|
+        index.as :searchable, :displayable
+      end
+      property :license, :predicate => RDF::DC[:license], :class_name => DummySubnode do |index|
+        index.as :searchable, :displayable
+      end
+      property :creator, :predicate => RDF::DC[:creator], :class_name => DummyAsset do |index|
+        index.as :searchable
+      end
+      def serialization_format
+        :ntriples
+      end
+    end
+
+    class DummyAsset < ActiveFedora::Base
+      has_metadata :name => 'descMetadata', :type => DummyResource
+      has_attributes :title, datastream: 'descMetadata', multiple: true
+      has_attributes :license, :datastream => 'descMetadata', :multiple => true
+      has_attributes :relation, :datastream => 'descMetadata', :at => [:license, :relation], :multiple => false
+    end
+  end
+
+  after do
+    Object.send(:remove_const, "DummyAsset") if Object
+    Object.send(:remove_const, "DummyResource") if Object
+    Object.send(:remove_const, "DummySubnode") if Object
+  end
+
+  subject {DummyAsset.new}
+
+  describe "#to_solr" do
+    before do
+      subject.descMetadata.title = "bla"
+      subject.descMetadata.license = DummySubnode.new('http://example.org/blah')
+    end
+
+    it "should not be blank" do
+      expect(subject.to_solr).not_to be_blank
+    end
+
+    it "should solrize" do
+      expect(subject.to_solr["desc_metadata__title_teim"]).to eq ["bla"]
+    end
+
+    it "should solrize uris" do
+      expect(subject.to_solr["desc_metadata__license_teim"]).to eq ['http://example.org/blah']
+    end
+  end
+
+  describe "delegation" do
+    it "should retrieve values" do
+      subject.descMetadata.title = "bla"
+      expect(subject.title).to eq ["bla"]
+    end
+
+    it "should set values" do
+      subject.title = "blah"
+      expect(subject.descMetadata.title).to eq ["blah"]
+    end
+
+    context "when the delegation is deep" do
+      before(:each) do
+        dummy = DummySubnode.new
+        dummy.relation = 'subbla'
+        subject.descMetadata.license = dummy
+      end
+
+      # This test is pending. For now we have no use case for deep delegation into an RDF graph.
+      xit "should retrieve values" do
+        expect(subject.relation).to eq ["subbla"]
+      end
+    end
+  end
+
+  describe "attribute setting" do
+    context "on text attributes" do
+      before do
+        subject.descMetadata.title = "bla"
+      end
+
+      it "should let you access" do
+        expect(subject.descMetadata.title).to eq ["bla"]
+      end
+
+      it "should mark it as changed" do
+        expect(subject.descMetadata).to be_changed
+      end
+
+      context "after it is persisted" do
+        before do
+          subject.save
+          subject.reload
+        end
+
+        it "should be persisted" do
+          expect(subject.descMetadata.resource.persisted?).to be_true
+        end
+
+        context "and it's reloaded" do
+          before do
+            subject.reload
+          end
+
+          it "should be accessible after being saved" do
+            expect(subject.descMetadata.title).to eq ["bla"]
+          end
+
+          it "should serialize to content" do
+            expect(subject.descMetadata.content).not_to be_blank
+          end
+        end
+
+        context "and it is found again" do
+          before do
+            @object = DummyAsset.find(subject.pid)
+          end
+
+          it "should serialize to content" do
+            expect(@object.descMetadata.content).not_to be_blank
+          end
+
+          it "should be accessible after being saved" do
+            expect(@object.descMetadata.title).to eq ["bla"]
+          end
+
+          it "should have datastream content" do
+            expect(@object.descMetadata.datastream_content).not_to be_blank
+          end
+        end
+      end
+    end
+
+    context "on rdf resource attributes" do
+      context "persisted to parent" do
+        before do
+          dummy = DummySubnode.new
+          dummy.title = 'subbla'
+          subject.descMetadata.license = dummy
+        end
+
+        it "should let you access" do
+          expect(subject.descMetadata.license.first.title).to eq ['subbla']
+        end
+
+        it "should mark it as changed" do
+          expect(subject.descMetadata).to be_changed
+        end
+      end
+      context "persisted to repository" do
+        before do
+          DummySubnode.configure :repository => :default
+          DummySubnode.any_instance.stub(:repository).and_return(RDF::Repository.new)
+          dummy = DummySubnode.new(RDF::URI('http://example.org/dummy/blah'))
+          dummy.title = 'subbla'
+          # We want to have to manually persist to the repository.
+          # Parent objects shouldn't be persisting children they share with other parents
+          dummy.persist!
+          subject.descMetadata.license = dummy
+        end
+
+        it "should let you access" do
+          expect(subject.descMetadata.license.first.title).to eq ['subbla']
+        end
+
+        it "should mark it as changed" do
+          expect(subject.descMetadata).to be_changed
+        end
+      end
+    end
+  end
+
+  describe "asset.load_instance_from_solr" do
+    before do
+      subject.descMetadata.title = "Monkeys"
+      subject.save
+      @loaded_object = DummyAsset.load_instance_from_solr(subject.pid)
+    end
+
+    it "should load the datastream" do
+      expect(@loaded_object.title).to eq ["Monkeys"]
+    end
+  end
+
+  describe "relationships" do
+    before do
+      @new_object = DummyAsset.new
+      @new_object.title = "subbla"
+      @new_object.save
+      subject.title = "bla"
+      subject.descMetadata.creator = @new_object
+    end
+
+    it "should have accessible relationship attributes" do
+      expect(subject.descMetadata.creator.first.title).to eq ["subbla"]
+    end
+
+    it "should let me get to an AF:Base object" do
+      subject.save
+      subject.reload
+      expect(subject.descMetadata.creator.first).to be_kind_of(ActiveFedora::Base)
+    end
+
+    it "should allow for deep attributes to be set directly" do
+      subject.descMetadata.creator.first.title = "Bla"
+      expect(subject.descMetadata.creator.first.title).to eq ["Bla"]
+    end
+
+    context "when the subject is set with base_uri" do
+      before do
+        DummyResource.resource_class.configure :base_uri => 'http://example.org/'
+        new_object = DummyAsset.new
+        new_object.save
+        subject.descMetadata.creator = new_object
+      end
+
+      it "should let me get to an AF:Base object" do
+        subject.save
+        subject.reload
+        expect(subject.descMetadata.creator.first).to be_kind_of(ActiveFedora::Base)
+      end
+    end
+
+    context "when the object with a relationship is saved" do
+      before do
+        subject.save
+        @object = subject.class.find(subject.pid)
+      end
+
+      it "should be retrievable" do
+        expect(subject.descMetadata.creator.first.title).to eq ["subbla"]
+      end
+    end
+
+    context "when the object with a relationship is frozen" do
+      before do
+        subject.save
+        @object = subject.class.find(subject.pid)
+        @object.freeze
+        subject.freeze
+      end
+
+      it "should be retrievable" do
+        expect(subject.descMetadata.creator.first.title).to eq ["subbla"]
+      end
+    end
+
+    context 'when the object has no Rdf::Resource' do
+      before do
+        class DummyOmAsset < ActiveFedora::Base
+          has_metadata :name => 'descMetadata', :type => OmDatastream
+        end
+
+        @new_object = DummyOmAsset.new
+        @new_object.save
+        subject.title = "bla"
+        subject.descMetadata.creator = @new_object
+        subject.save
+        subject.reload
+      end
+
+      after do
+        Object.send(:remove_const, "DummyOmAsset") if Object
+      end
+
+      it "should let me get to an AF:Base object" do
+        expect(subject.descMetadata.creator.first).to be_kind_of(ActiveFedora::Base)
+      end
+
+      it "should not allow writing to the graph" do
+        expect{@new_object.resource << RDF::Statement.new(RDF::Node.new, RDF::DC.title, 'title')
+}.to raise_error TypeError
+      end
+    end
+  end
+end

data/spec/unit/rdf_resource_spec.rb

@@ -0,0 +1,341 @@
+require "spec_helper"
+describe ActiveFedora::Rdf::Resource do
+
+  before do
+    class DummyLicense < ActiveFedora::Rdf::Resource
+      property :title, :predicate => RDF::DC.title
+    end
+
+    class DummyResource < ActiveFedora::Rdf::Resource
+      configure :type => RDF::URI('http://example.org/SomeClass')
+      property :license, :predicate => RDF::DC.license, :class_name => DummyLicense
+      property :title, :predicate => RDF::DC.title
+    end
+  end
+  after do
+    Object.send(:remove_const, "DummyResource") if Object
+    Object.send(:remove_const, "DummyLicense") if Object
+  end
+
+  subject { DummyResource.new }
+
+  describe 'rdf_subject' do
+    it "should be a blank node if we haven't set it" do
+      expect(subject.rdf_subject.node?).to be_true
+    end
+
+    it "should be settable" do
+      subject.set_subject! RDF::URI('http://example.org/moomin')
+      expect(subject.rdf_subject).to eq RDF::URI('http://example.org/moomin')
+    end
+
+    describe 'when changing subject' do
+      before do
+        subject << RDF::Statement.new(subject.rdf_subject, RDF::DC.title, RDF::Literal('Comet in Moominland'))
+        subject << RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.isPartOf, subject.rdf_subject)
+        subject << RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.relation, 'http://example.org/moomin_land')
+        subject.set_subject! RDF::URI('http://example.org/moomin')
+      end
+
+      it 'should update graph subjects' do
+        expect(subject.has_statement?(RDF::Statement.new(subject.rdf_subject, RDF::DC.title, RDF::Literal('Comet in Moominland')))).to be_true
+      end
+
+      it 'should update graph objects' do
+        expect(subject.has_statement?(RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.isPartOf, subject.rdf_subject))).to be_true
+      end
+
+      it 'should leave other uris alone' do
+        expect(subject.has_statement?(RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.relation, 'http://example.org/moomin_land'))).to be_true
+      end
+    end
+
+    describe 'with URI subject' do
+      before do
+        subject.set_subject! RDF::URI('http://example.org/moomin')
+      end
+
+      it 'should not be settable' do
+        expect{ subject.set_subject! RDF::URI('http://example.org/moomin2') }.to raise_error
+      end
+    end
+  end
+
+  describe "#persisted?" do
+    before do
+      repository = RDF::Repository.new
+      subject.stub(:repository).and_return(repository)
+    end
+
+    context "when the object is new" do
+      it "should return false" do
+        expect(subject).not_to be_persisted
+      end
+    end
+
+    context "when it is saved" do
+      before do
+        subject.title = "bla"
+        subject.persist!
+      end
+
+      it "should return true" do
+        expect(subject).to be_persisted
+      end
+
+      context "and then modified" do
+        before do
+          subject.title = "newbla"
+        end
+
+        it "should return true" do
+          expect(subject).to be_persisted
+        end
+      end
+      context "and then reloaded" do
+        before do
+          subject.reload
+        end
+
+        it "should reset the title" do
+          expect(subject.title).to eq ["bla"]
+        end
+
+        it "should be persisted" do
+          expect(subject).to be_persisted
+        end
+      end
+    end
+  end
+
+  describe "#persist!" do
+    context "when the repository is set" do
+      context "and the item is not a blank node" do
+
+        subject {DummyResource.new("info:fedora/example:pid")}
+
+        before do
+          @repo = RDF::Repository.new
+          subject.class.stub(:repository).and_return(nil)
+          subject.stub(:repository).and_return(@repo)
+          subject.title = "bla"
+          subject.persist!
+        end
+
+        it "should persist to the repository" do
+          expect(@repo.statements.first).to eq subject.statements.first
+        end
+
+        it "should delete from the repository" do
+          subject.reload
+          expect(subject.title).to eq ["bla"]
+          subject.title = []
+          expect(subject.title).to eq []
+          subject.persist!
+          subject.reload
+          expect(subject.title).to eq []
+          expect(@repo.statements.to_a.length).to eq 1 # Only the type statement
+        end
+      end
+    end
+  end
+
+  describe 'property methods' do
+    it 'should set and get properties' do
+      subject.title = 'Comet in Moominland'
+      expect(subject.title).to eq ['Comet in Moominland']
+    end
+  end
+
+  describe 'child nodes' do
+    it 'should return an object of the correct class when the value is a URI' do
+      subject.license = DummyLicense.new('http://example.org/license')
+      expect(subject.license.first).to be_kind_of DummyLicense
+    end
+
+    it 'should return an object with the correct URI when the value is a URI ' do
+      subject.license = DummyLicense.new('http://example.org/license')
+      expect(subject.license.first.rdf_subject).to eq RDF::URI("http://example.org/license")
+    end
+
+    it 'should return an object of the correct class when the value is a bnode' do
+      subject.license = DummyLicense.new
+      expect(subject.license.first).to be_kind_of DummyLicense
+    end
+  end
+
+  describe '#set_value' do
+    it 'should set a value in the graph' do
+      subject.set_value(RDF::DC.title, 'Comet in Moominland')
+      subject.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 set a value in the when given a registered property symbol' do
+      subject.set_value(:title, 'Comet in Moominland')
+      expect(subject.title).to eq ['Comet in Moominland']
+    end
+
+    it "raise an error if the value is not a URI, Node, Literal, RdfResource, or string" do
+      expect{subject.set_value(RDF::DC.title, Object.new)}.to raise_error
+    end
+
+    it "should be able to accept a subject" do
+      expect{subject.set_value(RDF::URI("http://opaquenamespace.org/jokes"), RDF::DC.title, 'Comet in Moominland')}.not_to raise_error
+      expect(subject.query(:subject => RDF::URI("http://opaquenamespace.org/jokes"), :predicate => RDF::DC.title).statements.to_a.length).to eq 1
+    end
+  end
+  describe '#get_values' do
+    before do
+      subject.title = ['Comet in Moominland', "Finn Family Moomintroll"]
+    end
+
+    it 'should return values for a predicate uri' do
+      expect(subject.get_values(RDF::DC.title)).to eq ['Comet in Moominland', 'Finn Family Moomintroll']
+    end
+
+    it 'should return values for a registered predicate symbol' do
+      expect(subject.get_values(:title)).to eq ['Comet in Moominland', 'Finn Family Moomintroll']
+    end
+
+    it "should return values for other subjects if asked" do
+      expect(subject.get_values(RDF::URI("http://opaquenamespace.org/jokes"),:title)).to eq []
+      subject.set_value(RDF::URI("http://opaquenamespace.org/jokes"), RDF::DC.title, 'Comet in Moominland')
+      expect(subject.get_values(RDF::URI("http://opaquenamespace.org/jokes"),:title)).to eq ["Comet in Moominland"]
+    end
+  end
+
+  describe '#type' do
+    it 'should return the type configured on the parent class' do
+      expect(subject.type).to eq [DummyResource.type]
+    end
+
+    it 'should set the type' do
+      subject.type = RDF::URI('http://example.org/AnotherClass')
+      expect(subject.type).to eq [RDF::URI('http://example.org/AnotherClass')]
+    end
+
+    it 'should be the type in the graph' do
+      subject.query(:subject => subject.rdf_subject, :predicate => RDF.type).statements do |s|
+        expect(s.object).to eq RDF::URI('http://example.org/AnotherClass')
+      end
+    end
+  end
+
+  describe '#rdf_label' do
+    it 'should return an array of label values' do
+      expect(subject.rdf_label).to be_kind_of Array
+    end
+
+    it 'should return the default label values' do
+      subject.title = 'Comet in Moominland'
+      expect(subject.rdf_label).to eq ['Comet in Moominland']
+    end
+
+    it 'should prioritize configured label values' do
+      custom_label = RDF::URI('http://example.org/custom_label')
+      subject.class.configure :rdf_label => custom_label
+      subject << RDF::Statement(subject.rdf_subject, custom_label, RDF::Literal('New Label'))
+      subject.title = 'Comet in Moominland'
+      expect(subject.rdf_label).to eq ['New Label']
+    end
+  end
+
+  describe '#solrize' do
+    it 'should return a label for bnodes' do
+      expect(subject.solrize).to eq subject.rdf_label
+    end
+
+    it 'should return a string of the resource uri' do
+      subject.set_subject! 'http://example.org/moomin'
+      expect(subject.solrize).to eq 'http://example.org/moomin'
+    end
+  end
+
+  describe 'editing the graph' do
+    it 'should write properties when statements are added' do
+      subject << RDF::Statement.new(subject.rdf_subject, RDF::DC.title, 'Comet in Moominland')
+      expect(subject.title).to include 'Comet in Moominland'
+    end
+
+    it 'should delete properties when statements are removed' do
+      subject << RDF::Statement.new(subject.rdf_subject, RDF::DC.title, 'Comet in Moominland')
+      subject.delete RDF::Statement.new(subject.rdf_subject, RDF::DC.title, 'Comet in Moominland')
+      expect(subject.title).to eq []
+    end
+  end
+
+  describe 'big complex graphs' do
+    before do
+      class DummyPerson < ActiveFedora::Rdf::Resource
+        configure :type => RDF::URI('http://example.org/Person')
+        property :name, :predicate => RDF::FOAF.name
+        property :publications, :predicate => RDF::FOAF.publications, :class_name => 'DummyDocument'
+        property :knows, :predicate => RDF::FOAF.knows, :class_name => DummyPerson
+      end
+
+      class DummyDocument < ActiveFedora::Rdf::Resource
+        configure :type => RDF::URI('http://example.org/Document')
+        property :title, :predicate => RDF::DC.title
+        property :creator, :predicate => RDF::DC.creator, :class_name => 'DummyPerson'
+      end
+
+      DummyResource.property :item, :predicate => RDF::DC.relation, :class_name => DummyDocument
+    end
+
+    subject { DummyResource.new }
+
+    let (:document1) do
+      d = DummyDocument.new
+      d.title = 'Document One'
+      d
+    end
+
+    let (:document2) do
+      d = DummyDocument.new
+      d.title = 'Document Two'
+      d
+    end
+
+    let (:person1) do
+      p = DummyPerson.new
+      p.name = 'Alice'
+      p
+    end
+
+    let (:person2) do
+      p = DummyPerson.new
+      p.name = 'Bob'
+      p
+    end
+
+    let (:data) { <<END
+_:1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/SomeClass> .
+_:1 <http://purl.org/dc/terms/relation> _:2 .
+_:2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/Document> .
+_:2 <http://purl.org/dc/terms/title> "Document One" .
+_:2 <http://purl.org/dc/terms/creator> _:3 .
+_:2 <http://purl.org/dc/terms/creator> _:4 .
+_:4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/Person> .
+_:4 <http://xmlns.com/foaf/0.1/name> "Bob" .
+_:3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/Person> .
+_:3 <http://xmlns.com/foaf/0.1/name> "Alice" .
+_:3 <http://xmlns.com/foaf/0.1/knows> _:4 ."
+END
+    }
+
+    after do
+      Object.send(:remove_const, "DummyDocument")
+      Object.send(:remove_const, "DummyPerson")
+    end
+
+    it 'should allow access to deep nodes' do
+      document1.creator = [person1, person2]
+      document2.creator = person1
+      person1.knows = person2
+      subject.item = [document1]
+      expect(subject.item.first.creator.first.knows.first.name).to eq ['Bob']
+    end
+  end
+end