active-fedora 11.0.0.rc6 → 11.0.0.rc7

data/spec/samples/models/mods_article.rb

@@ -1,9 +0,0 @@
-require "active-fedora"
-require_relative '../hydra-mods_article_datastream.rb'
-
-# This Model is used to load & index the test:fixture_mods_article1 fixture for use in tests.
-#
-# See lib/samples/sample_thing.rb for a fuller, annotated example of an ActiveFedora Model
-class ModsArticle < ActiveFedora::Base
-  has_subresource "descMetadata", class_name: 'Hydra::ModsArticleDatastream'
-end

data/spec/samples/samples.rb

@@ -1,2 +0,0 @@
-# require all of the files in the samples directory
-require 'samples/models/mods_article'

data/spec/unit/nom_datastream_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::NomDatastream do
-  describe "test" do
-    subject(:datastream) {
-      class MyNomDatastream < ActiveFedora::NomDatastream
-        set_terminology do |t|
-          t.a path: '//a', accessor: lambda { |x| x.text }, index: 'a_s'
-          t.b path: '//b', index: 'b_s'
-        end
-      end
-
-      MyNomDatastream.new
-    }
-    before do
-      datastream.content = '<root><a>123</a><b><c>asdf</c></b></root>'
-    end
-
-    it "works" do
-      expect(datastream.a).to include("123")
-    end
-
-    it "to_solrs" do
-      expect(datastream.to_solr['a_s']).to include('123')
-      expect(datastream.to_solr['b_s']).to include('asdf')
-    end
-  end
-
-  describe "with options for .set_terminology" do
-    subject(:datastream) {
-      class TerminologyOptions < ActiveFedora::NomDatastream
-        set_terminology(namespaces: {
-                          'dc' => "http://purl.org/dc/elements/1.1/",
-                          'dcterms' => "http://purl.org/dc/terms/"
-                        }) do |t|
-          t.a path: 'a', xmlns: 'dc', accessor: lambda { |x| x.text }
-        end
-      end
-
-      TerminologyOptions.new
-    }
-
-    before do
-      datastream.content = %(
-        <root
-          xmlns:dc="http://purl.org/dc/elements/1.1/"
-          xmlns:dcterms="http://purl.org/dc/terms/"
-        >
-          <dc:a>123</dc:a>
-          <dcterms:a>not-part-of-a</dcterms:a>
-          <dcterms:b>abcd</dcterms:b>
-        </root>
-      )
-    end
-
-    it "scopes #a attribute to only the dc namespace" do
-      expect(datastream.a).to eq ["123"]
-    end
-  end
-end

data/spec/unit/ntriples_datastream_spec.rb

@@ -1,167 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::NtriplesRDFDatastream do
-  let(:remote_content) do
-    <<EOF
-<#{ActiveFedora.fedora.host}/test/test:1> <http://purl.org/dc/terms/created> "2010-12-31"^^<http://www.w3.org/2001/XMLSchema#date> .
-<#{ActiveFedora.fedora.host}/test/test:1> <http://purl.org/dc/terms/title> "Title of work" .
-<#{ActiveFedora.fedora.host}/test/test:1> <http://purl.org/dc/terms/publisher> "Penn State" .
-<#{ActiveFedora.fedora.host}/test/test:1> <http://xmlns.com/foaf/0.1/based_near> "New York, NY, US" .
-<#{ActiveFedora.fedora.host}/test/test:1> <http://www.w3.org/2000/01/rdf-schema#seeAlso> <http://google.com/> .
-<#{ActiveFedora.fedora.host}/test/test:1/content> <http://purl.org/dc/terms/title> "Title of datastream" .
-EOF
-  end
-
-  describe "an instance with content" do
-    before do
-      class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        property :created, predicate: ::RDF::Vocab::DC.created
-        property :title, predicate: ::RDF::Vocab::DC.title
-        property :publisher, predicate: ::RDF::Vocab::DC.publisher
-        property :creator, predicate: ::RDF::Vocab::DC.creator
-        property :educationLevel, predicate: ::RDF::Vocab::DC.educationLevel
-        property :based_near, predicate: ::RDF::Vocab::FOAF.based_near
-        property :related_url, predicate: ::RDF::Vocab::RDFS.seeAlso
-      end
-      @subject = MyDatastream.new(ActiveFedora::Base.id_to_uri('/test:1/descMetadata'))
-      @subject.content = remote_content
-    end
-    after do
-      Object.send(:remove_const, :MyDatastream)
-    end
-    it "has a subject" do
-      expect(@subject.rdf_subject).to eq "#{ActiveFedora.fedora.host}/test/test:1"
-    end
-    it "has mime_type" do
-      expect(@subject.mime_type).to eq 'text/plain'
-    end
-    it "has fields" do
-      expect(@subject.created).to eq [Date.parse('2010-12-31')]
-      expect(@subject.title).to eq ["Title of work"]
-      expect(@subject.publisher).to eq ["Penn State"]
-      expect(@subject.based_near).to eq ["New York, NY, US"]
-      expect(@subject.related_url.length).to eq 1
-      expect(@subject.related_url.first.rdf_subject).to eq "http://google.com/"
-    end
-
-    it "is able to call enumerable methods on the fields" do
-      expect(@subject.title.join(', ')).to eq "Title of work"
-      expect(@subject.title.count).to eq 1
-      expect(@subject.title.size).to eq 1
-      expect(@subject.title[0]).to eq "Title of work"
-      expect(@subject.title.to_a).to eq ["Title of work"]
-      val = []
-      @subject.title.each_with_index { |v, i| val << "#{i}. #{v}" }
-      expect(val).to eq ["0. Title of work"]
-    end
-
-    it "has method missing" do
-      expect(lambda { @subject.frank }).to raise_exception NoMethodError
-    end
-
-    it "sets fields" do
-      @subject.publisher = "St. Martin's Press"
-      expect(@subject.publisher).to eq ["St. Martin's Press"]
-    end
-    it "sets rdf literal fields" do
-      @subject.creator = RDF.Literal("Geoff Ryman")
-      expect(@subject.creator).to eq ["Geoff Ryman"]
-    end
-    it "appends fields" do
-      @subject.publisher << "St. Martin's Press"
-      expect(@subject.publisher).to contain_exactly "Penn State", "St. Martin's Press"
-    end
-    it "deletes fields" do
-      @subject.related_url.delete(RDF::URI("http://google.com/"))
-      expect(@subject.related_url).to eq []
-    end
-  end
-
-  describe "some dummy instances" do
-    before do
-      @one = ActiveFedora::RDFDatastream.new
-      @two = ActiveFedora::RDFDatastream.new
-    end
-    it "generates predictable prexies" do
-      expect(@one.send(:apply_prefix, "baz", 'myFoobar')).to eq 'my_foobar__baz'
-      expect(@two.send(:apply_prefix, "baz", 'myQuix')).to eq 'my_quix__baz'
-    end
-  end
-
-  describe "an instance with a custom subject" do
-    before do
-      class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        rdf_subject { |ds| "#{ActiveFedora.fedora.host}/test/#{ds.id}/content" }
-        property :created, predicate: ::RDF::Vocab::DC.created
-        property :title, predicate: ::RDF::Vocab::DC.title
-        property :publisher, predicate: ::RDF::Vocab::DC.publisher
-        property :based_near, predicate: ::RDF::Vocab::FOAF.based_near
-        property :related_url, predicate: ::RDF::Vocab::RDFS.seeAlso
-      end
-      @subject = MyDatastream.new
-      allow(@subject).to receive(:id).and_return 'test:1'
-      allow(@subject).to receive(:new_record?).and_return false
-      allow(@subject).to receive(:remote_content).and_return remote_content
-    end
-
-    after do
-      Object.send(:remove_const, :MyDatastream)
-    end
-
-    it "has fields" do
-      expect(@subject.title).to eq ["Title of datastream"]
-    end
-
-    it "has a custom subject" do
-      expect(@subject.rdf_subject).to eq "#{ActiveFedora.fedora.host}/test/test:1/content"
-    end
-  end
-
-  describe "a new instance" do
-    before do
-      class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        property :publisher, predicate: ::RDF::Vocab::DC.publisher
-      end
-      @subject = MyDatastream.new
-    end
-
-    after do
-      Object.send(:remove_const, :MyDatastream)
-    end
-
-    xit "supports to_s method" do
-      expect(@subject.publisher.to_s).to eq [].to_s
-      @subject.publisher = "Bob"
-      expect(@subject.publisher.to_s).to eq ["Bob"].to_s
-      @subject.publisher << "Jim"
-      expect(@subject.publisher.to_s).to eq ["Bob", "Jim"].to_s
-    end
-  end
-
-  describe "solr integration" do
-    before(:all) do
-      class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-      end
-    end
-
-    after(:all) do
-      Object.send(:remove_const, :MyDatastream)
-    end
-
-    before(:each) do
-      @subject = MyDatastream.new
-      @subject.content = File.new('spec/fixtures/solr_rdf_descMetadata.nt').read
-      @subject.serialize
-    end
-
-    it "provides .to_solr and return a SolrDocument" do
-      expect(@subject).to respond_to(:to_solr)
-      expect(@subject.to_solr).to be_kind_of(Hash)
-    end
-
-    it "optionally allows you to provide the Solr::Document to add fields to and return that document when done" do
-      doc = {}
-      expect(@subject.to_solr(doc)).to eq doc
-    end
-  end
-end

data/spec/unit/om_datastream_spec.rb

@@ -1,294 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::OmDatastream do
-  subject(:datastream) { described_class.new }
-  it { should be_metadata }
-
-  it "includes the Solrizer::XML::TerminologyBasedSolrizer for .to_solr support" do
-    expect(described_class.included_modules).to include(OM::XML::TerminologyBasedSolrizer)
-  end
-
-  describe '#new' do
-    it 'loads xml from blob if provided' do
-      test_ds1 = described_class.new
-      test_ds1.content = "<xml><foo/></xml>"
-      expect(test_ds1.ng_xml.to_xml).to be_equivalent_to("<?xml version=\"1.0\"?>\n<xml>\n  <foo/>\n</xml>\n")
-    end
-
-    it "initializes from #xml_template if no xml is provided" do
-      expect(described_class).to receive(:xml_template).and_return("<fake template/>")
-      n = described_class.new
-      expect(n.ng_xml).to be_equivalent_to("<fake template/>")
-    end
-  end
-
-  describe "#prefix" do
-    subject(:datastream) { described_class.new }
-    it "reflects the dsid" do
-      expect(datastream.send(:prefix, 'descMetadata')).to eq "desc_metadata__"
-    end
-  end
-
-  describe '#xml_template' do
-    subject(:datastream) { described_class.xml_template.to_xml }
-    it "returns an empty xml document" do
-      expect(datastream).to be_equivalent_to("<?xml version=\"1.0\"?>\n<xml/>\n")
-    end
-  end
-
-  describe "to_solr" do
-    describe "with a dsid" do
-      subject { described_class.new.to_solr }
-      it { should be_empty }
-    end
-
-    describe "when prefix is set" do
-      before do
-        class MyDatastream < ActiveFedora::OmDatastream
-          set_terminology do |t|
-            t.root(path: "mods")
-            t.title(index_as: [:stored_searchable])
-          end
-
-          def prefix(_)
-            "foo__"
-          end
-        end
-        datastream.title = 'Science'
-      end
-      after do
-        Object.send(:remove_const, :MyDatastream)
-      end
-      subject(:datastream) { MyDatastream.new }
-      it "uses the prefix" do
-        expect(datastream.to_solr).to have_key('foo__title_tesim')
-      end
-      it "does not prefix fields that aren't defined by this datastream" do
-        expect(datastream.to_solr('id' => 'test:123')).to have_key('id')
-      end
-    end
-  end
-
-  describe ".update_indexed_attributes" do
-    before(:each) do
-      @mods_ds = Hydra::ModsArticleDatastream.new
-      @mods_ds.content = fixture(File.join("mods_articles", "mods_article1.xml")).read
-    end
-
-    it "applies submitted hash to corresponding datastream field values" do
-      result = @mods_ds.update_indexed_attributes([{ ":person" => "0" }, "role"] => { "0" => "role1", "1" => "role2", "2" => "role3" })
-      expect(result).to eq("person_0_role" => ["role1", "role2", "role3"])
-      expect(@mods_ds.property_values('//oxns:name[@type="personal"][1]/oxns:role')).to eq ["role1", "role2", "role3"]
-    end
-    it "supports single-value arguments (as opposed to a hash of values with array indexes as keys)" do
-      # In other words, { "fubar"=>"dork" } should have the same effect as { "fubar"=>{"0"=>"dork"} }
-      result = @mods_ds.update_indexed_attributes([{ ":person" => "0" }, "role"] => "the role")
-      expect(result).to eq("person_0_role" => ["the role"])
-      expect(@mods_ds.term_values('//oxns:name[@type="personal"][1]/oxns:role').first).to eq "the role"
-    end
-    it "does nothing if field key is a string (must be an array or symbol). Will not accept xpath queries!" do
-      xml_before = @mods_ds.to_xml
-      expect(ActiveFedora::Base.logger).to receive(:warn).with "WARNING: Hydra::ModsArticleDatastream ignoring {\"fubar\" => \"the role\"} because \"fubar\" is a String (only valid OM Term Pointers will be used).  Make sure your html has the correct field_selector tags in it."
-      expect(@mods_ds.update_indexed_attributes("fubar" => "the role")).to eq({})
-      expect(@mods_ds.to_xml).to eq xml_before
-    end
-    it "does nothing if there is no accessor corresponding to the given field key" do
-      xml_before = @mods_ds.to_xml
-      expect(@mods_ds.update_indexed_attributes([{ "fubar" => "0" }] => "the role")).to eq({})
-      expect(@mods_ds.to_xml).to eq xml_before
-    end
-
-    ### Examples copied over form metadata_datastream_spec
-
-    it "works for text fields" do
-      att = { [{ "person" => "0" }, "description"] => { "-1" => "mork", "1" => "york" } }
-      result = @mods_ds.update_indexed_attributes(att)
-      expect(result).to eq("person_0_description" => ["mork", "york"])
-      expect(@mods_ds.get_values([{ person: 0 }, :description])).to eq ['mork', 'york']
-      att = { [{ "person" => "0" }, "description"] => { "-1" => "dork" } }
-      result2 = @mods_ds.update_indexed_attributes(att)
-      expect(result2).to eq("person_0_description" => ["dork"])
-      expect(@mods_ds.get_values([{ person: 0 }, :description])).to eq ['dork']
-    end
-
-    it "allows deleting of values and should delete values so that to_xml does not return emtpy nodes" do
-      att = { [{ "person" => "0" }, "description"] => { "0" => "york", "1" => "mangle", "2" => "mork" } }
-      @mods_ds.update_indexed_attributes(att)
-      expect(@mods_ds.get_values([{ "person" => "0" }, "description"])).to eq ['york', 'mangle', 'mork']
-
-      @mods_ds.update_indexed_attributes([{ "person" => "0" }, { "description" => '1' }] => nil)
-      expect(@mods_ds.get_values([{ "person" => "0" }, "description"])).to eq ['york', 'mork']
-
-      @mods_ds.update_indexed_attributes([{ "person" => "0" }, { "description" => '0' }] => :delete)
-      expect(@mods_ds.get_values([{ "person" => "0" }, "description"])).to eq ['mork']
-    end
-
-    it "sets changed to true" do
-      expect(@mods_ds.get_values([{ title_info: 0 }, :main_title])).to eq ["ARTICLE TITLE", "TITLE OF HOST JOURNAL"]
-      @mods_ds.update_indexed_attributes [{ "title_info" => "0" }, "main_title"] => { "-1" => "mork" }
-      expect(@mods_ds).to be_changed
-    end
-  end
-
-  describe ".get_values" do
-    before(:each) do
-      @mods_ds = Hydra::ModsArticleDatastream.new
-      @mods_ds.content = fixture(File.join("mods_articles", "mods_article1.xml")).read
-    end
-
-    it "calls lookup with field_name and return the text values from each resulting node" do
-      expect(@mods_ds).to receive(:term_values).with("--my xpath--").and_return(["value1", "value2"])
-      expect(@mods_ds.get_values("--my xpath--")).to eq ["value1", "value2"]
-    end
-    it "assumes that field_names that are strings are xpath queries" do
-      expect(described_class).to receive(:accessor_xpath).never
-      expect(@mods_ds).to receive(:term_values).with("--my xpath--").and_return(["abstract1", "abstract2"])
-      expect(@mods_ds.get_values("--my xpath--")).to eq ["abstract1", "abstract2"]
-    end
-  end
-
-  describe '.save' do
-    let(:base_path) { '/foo' }
-
-    let(:ldp_source) { Ldp::Resource.new(mock_client, nil, nil, base_path) }
-
-    let(:conn_stubs) do
-      Faraday::Adapter::Test::Stubs.new do |stub|
-        stub.post(base_path) { [200, { 'Last-Modified' => 'Tue, 22 Jul 2014 02:23:32 GMT' }] }
-      end
-    end
-
-    let(:mock_conn) do
-      Faraday.new do |builder|
-        builder.adapter :test, conn_stubs do |_stub|
-        end
-      end
-    end
-
-    let :mock_client do
-      Ldp::Client.new mock_conn
-    end
-
-    before do
-      allow(datastream).to receive(:ldp_source).and_return(ldp_source)
-    end
-
-    it "persists the product of .to_xml in fedora" do
-      datastream.serialize!
-      datastream.save
-      expect(datastream.mime_type).to eq 'text/xml'
-    end
-  end
-
-  describe 'setting content' do
-    subject(:datastream) { described_class.new }
-    before { datastream.content = "<a />" }
-
-    it "updates the content" do
-      expect(datastream.content).to eq "<?xml version=\"1.0\"?>\n<a/>"
-    end
-
-    it "marks the object as changed" do
-      expect(datastream).to be_changed
-    end
-
-    it "update ngxml and mark the xml as loaded" do
-      expect(datastream.ng_xml.to_xml).to match(/<a\/>/)
-      expect(datastream.xml_loaded).to be true
-    end
-  end
-
-  describe 'ng_xml=' do
-    let(:sample_raw_xml) { "<foo><xmlelement/></foo>" }
-
-    subject(:datastream) { described_class.new }
-
-    it "parses raw xml for you" do
-      datastream.ng_xml = sample_raw_xml
-      expect(datastream.ng_xml).to be_kind_of Nokogiri::XML::Document
-      expect(datastream.ng_xml.to_xml).to be_equivalent_to(sample_raw_xml)
-    end
-
-    it "alwayses set a document when an Element is passed" do
-      datastream.ng_xml = Nokogiri::XML(sample_raw_xml).xpath('//xmlelement').first
-      expect(datastream.ng_xml).to be_kind_of Nokogiri::XML::Document
-      expect(datastream.ng_xml.to_xml).to be_equivalent_to("<xmlelement/>")
-    end
-
-    it "marks the datastream as changed" do
-      expect {
-        datastream.ng_xml = sample_raw_xml
-      }.to change { datastream.changed? }.from(false).to(true)
-    end
-  end
-
-  describe '.to_xml' do
-    let(:doc) { Nokogiri::XML::Document.parse("<text_document/>") }
-
-    it "ng_xml.to_xmls" do
-      allow(datastream).to receive(:ng_xml).and_return(doc)
-      expect(datastream.to_xml).to eq "<?xml version=\"1.0\"?>\n<text_document/>"
-    end
-
-    it 'accepts an optional Nokogiri::XML Document as an argument and insert its fields into that (mocked test)' do
-      expect(doc.root).to receive(:add_child) # .with(test_ds.ng_xml.root)
-      datastream.to_xml(doc)
-    end
-
-    context "with some existing content" do
-      before do
-        datastream.content = "<test_xml/>"
-      end
-      it 'accepts an optional Nokogiri::XML Document as an argument and insert its fields into that (functional test)' do
-        expected_result = "<test_document><foo/><test_xml/></test_document>"
-        doc = Nokogiri::XML::Document.parse("<test_document><foo/></test_document>")
-        result = datastream.to_xml(doc)
-        expect(doc).to be_equivalent_to expected_result
-        expect(result).to be_equivalent_to expected_result
-      end
-
-      it 'adds to root of Nokogiri::XML::Documents, but add directly to the elements if a Nokogiri::XML::Node is passed in' do
-        doc = Nokogiri::XML::Document.parse("<test_document/>")
-        el = Nokogiri::XML::Node.new("test_element", Nokogiri::XML::Document.new)
-        expect(datastream.to_xml(doc)).to be_equivalent_to "<test_document><test_xml/></test_document>"
-        expect(datastream.to_xml(el)).to be_equivalent_to "<test_element/>"
-      end
-    end
-  end
-
-  describe '.update_values' do
-    subject(:datastream) { described_class.new }
-
-    before { datastream.content = fixture(File.join("mods_articles", "mods_article1.xml")).read }
-
-    it "updates a value internally call OM::XML::TermValueOperators::update_values if internal_solr_doc is not set" do
-      expect(datastream).to receive(:om_update_values)
-      datastream.update_values([{ ":person" => "0" }, "role", "text"] => { "0" => "role1", "1" => "role2", "2" => "role3" })
-    end
-
-    it "sets changed to true" do
-      datastream.update_values([{ ":person" => "0" }, "role", "text"] => { "0" => "role1", "1" => "role2", "2" => "role3" })
-      expect(datastream).to be_changed
-    end
-  end
-
-  describe "an instance that exists in the datastore, but hasn't been loaded" do
-    before do
-      class MyObj < ActiveFedora::Base
-        has_subresource 'descMetadata', class_name: 'Hydra::ModsArticleDatastream'
-      end
-      @obj = MyObj.new
-      @obj.descMetadata.title = 'Foobar'
-      @obj.save
-    end
-    after do
-      @obj.destroy
-      Object.send(:remove_const, :MyObj)
-    end
-    subject(:datastream) { @obj.reload.descMetadata }
-    it "does not load the descMetadata datastream when calling content_changed?" do
-      expect(@obj).to_not receive(:content)
-      expect(datastream).to_not be_content_changed
-    end
-  end
-end