require 'spec_helper' describe ActiveFedora::NtriplesRDFDatastream do before do class FileVocabulary < RDF::Vocabulary("http://downlode.org/Code/RDF/File_Properties/schema#") property :size end class MyDatastream < ActiveFedora::NtriplesRDFDatastream property :title, predicate: RDF::DC.title do |index| index.as :stored_searchable, :facetable end property :date_uploaded, predicate: RDF::DC.dateSubmitted do |index| index.type :date index.as :stored_searchable, :sortable end property :filesize, predicate: FileVocabulary.size do |index| index.type :integer index.as :stored_sortable end property :part, predicate: RDF::DC.hasPart property :based_near, predicate: RDF::FOAF.based_near property :related_url, predicate: RDF::RDFS.seeAlso end class RdfTest < ActiveFedora::Base has_metadata 'rdf', type: MyDatastream has_attributes :based_near, :related_url, :part, :date_uploaded, datastream: 'rdf', multiple: true has_attributes :title, :filesize, datastream: 'rdf', multiple: false end @subject = RdfTest.new end subject { @subject } after do Object.send(:remove_const, :RdfTest) Object.send(:remove_const, :MyDatastream) Object.send(:remove_const, :FileVocabulary) end it "should not try to send an empty datastream" do @subject.save end it "should save content properly upon save" do foo = RdfTest.new(pid: 'test:1') #Pid needs to match the subject in the loaded file foo.title = 'Hamlet' foo.save expect(foo.title).to eq('Hamlet') foo.rdf.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read foo.save expect(foo.title).to eq('Title of work') end it "should delegate as_json to the fields" do @subject = RdfTest.new(title: "Title of work") expect(@subject.rdf.title.as_json).to eq(["Title of work"]) expect(@subject.rdf.title.to_json).to eq("\[\"Title of work\"\]") end it "should solrize even when the object is not new" do foo = RdfTest.new expect(foo).to receive(:update_index).once foo.title = "title1" foo.save foo = RdfTest.find(foo.pid) expect(foo).to receive(:update_index).once foo.title = "The Work2" foo.save end describe "serializing" do it "should handle dates" do subject.date_uploaded = [Date.parse('2012-11-02')] expect(subject.date_uploaded.first).to be_kind_of Date solr_document = subject.to_solr expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__date_uploaded', type: :date)]).to eq(['2012-11-02T00:00:00Z']) end it "should handle integers" do subject.filesize = 12345 expect(subject.filesize).to be_kind_of Fixnum solr_document = subject.to_solr expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__filesize', :stored_sortable, type: :integer)]).to eq('12345') end end it "should produce a solr document" do @subject = RdfTest.new(title: "War and Peace") solr_document = @subject.to_solr expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__title', :facetable)]).to eq(["War and Peace"]) expect(solr_document[ActiveFedora::SolrService.solr_name('rdf__title', type: :string)]).to eq(["War and Peace"]) end it "should set and recall values" do @subject.title = 'War and Peace' expect(@subject.rdf).to be_changed @subject.based_near = ["Moscow, Russia"] @subject.related_url = ["http://en.wikipedia.org/wiki/War_and_Peace"] @subject.part = ["this is a part"] @subject.save expect(@subject.title).to eq('War and Peace') expect(@subject.based_near).to eq(["Moscow, Russia"]) expect(@subject.related_url).to eq(["http://en.wikipedia.org/wiki/War_and_Peace"]) expect(@subject.part).to eq(["this is a part"]) end it "should set, persist, and recall values" do @subject.title = 'War and Peace' @subject.based_near = ["Moscow, Russia"] @subject.related_url = ["http://en.wikipedia.org/wiki/War_and_Peace"] @subject.part = ["this is a part"] @subject.save loaded = RdfTest.find(@subject.pid) expect(loaded.title).to eq('War and Peace') expect(loaded.based_near).to eq(['Moscow, Russia']) expect(loaded.related_url).to eq(['http://en.wikipedia.org/wiki/War_and_Peace']) expect(loaded.part).to eq(['this is a part']) end it "should set multiple values" do @subject.part = ["part 1", "part 2"] @subject.save loaded = RdfTest.find(@subject.pid) expect(loaded.part).to eq(['part 1', 'part 2']) end it "should append values" do @subject.part = ["thing 1"] @subject.save @subject.part << "thing 2" expect(@subject.part).to eq(["thing 1", "thing 2"]) end it "should be able to save a blank document" do @subject.title = "" @subject.save end it "should load n-triples into the graph" do ntrip = ' "Image" . "Benton County (Ore.)" . ' @subject.rdf.content = ntrip expect(@subject.rdf.graph.dump(:ntriples)).to eq(ntrip) end describe "using rdf_subject" do before do # reopening existing class class MyDatastream < ActiveFedora::NtriplesRDFDatastream rdf_subject { |ds| RDF::URI.new("http://oregondigital.org/ns/#{ds.pid.split(':')[1]}") } property :dctype, predicate: RDF::DC.type property :spatial, predicate: RDF::DC.spatial end end after do @subject.destroy end it "should write rdf with proper subjects" do @subject.inner_object.pid = 'test:99' @subject.rdf.dctype = "Frog" @subject.save! @subject.reload expect(@subject.rdf.graph.dump(:ntriples)).to eq(" \"Frog\" .\n") @subject.rdf.dctype == ['Frog'] end end it "should delete values" do @subject.title = "Hamlet" @subject.related_url = ["http://psu.edu/"] @subject.related_url << "http://projecthydra.org/" expect(@subject.title).to eq("Hamlet") expect(@subject.related_url).to include("http://psu.edu/") expect(@subject.related_url).to include("http://projecthydra.org/") @subject.title = "" #empty string can be meaningful, don't assume delete. expect(@subject.title).to eq('') @subject.title = nil @subject.related_url.delete("http://projecthydra.org/") expect(@subject.title).to be_nil expect(@subject.related_url).to eq(["http://psu.edu/"]) end it "should delete multiple values at once" do @subject.part = ["MacBeth"] @subject.part << "Hamlet" @subject.part << "Romeo & Juliet" expect(@subject.part.first).to eq("MacBeth") @subject.part.delete("MacBeth", "Romeo & Juliet") expect(@subject.part).to eq(["Hamlet"]) expect(@subject.part.first).to eq("Hamlet") end it "should ignore values to be deleted that do not exist" do @subject.part = ["title1", "title2", "title3"] @subject.part.delete("title2", "title4", "title6") expect(@subject.part).to eq(["title1", "title3"]) end describe "term proxy methods" do before(:each) do class TitleDatastream < ActiveFedora::NtriplesRDFDatastream property :title, predicate: RDF::DC.title end class Foobar < ActiveFedora::Base has_metadata 'rdf', type: TitleDatastream has_attributes :title, datastream: 'rdf', multiple: true end @subject = Foobar.new @subject.title = ["title1", "title2", "title3"] end after(:each) do Object.send(:remove_const, :Foobar) Object.send(:remove_const, :TitleDatastream) end it "should support the count method to determine # of values" do expect(@subject.title.count).to eq(3) end it "should iterate over multiple values" do expect(@subject.title).to respond_to(:each) end it "should get the first value" do expect(@subject.title.first).to eq("title1") end it "should evaluate equality predictably" do expect(@subject.title).to eq(["title1", "title2", "title3"]) end it "should support the empty? method" do expect(@subject.title).to respond_to(:empty?) expect(@subject.title.empty?).to be_falsey @subject.title.delete("title1", "title2", "title3") expect(@subject.title.empty?).to be_truthy end it "should support the is_a? method" do expect(@subject.title.is_a?(Array)).to eq(true) end end end