active-fedora 11.0.0.rc6 → 11.0.0.rc7

data/lib/active_fedora/rdf/rdfxml_datastream.rb

@@ -1,13 +0,0 @@
-require 'rdf/rdfxml'
-
-module ActiveFedora
-  class RDFXMLDatastream < RDFDatastream
-    def serialization_format
-      :rdfxml
-    end
-
-    def mime_type
-      'text/xml'
-    end
-  end
-end

data/spec/integration/complex_rdf_datastream_spec.rb

@@ -1,227 +0,0 @@
-require 'spec_helper'
-
-describe "Nested Rdf Objects" do
-  describe "without type" do
-    before do
-      class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
-        property :parts, predicate: ::RDF::Vocab::DC.hasPart, class_name: 'Component'
-
-        class Component < ActiveTriples::Resource
-          property :label, predicate: ::RDF::Vocab::DC.title
-        end
-      end
-    end
-
-    after do
-      Object.send(:remove_const, :SpecDatastream)
-    end
-
-    let(:ds) do
-      SpecDatastream.new("#{ActiveFedora.fedora.host}/test/test:124/descMd")
-    end
-
-    describe "#new_record?" do
-      it "is true when its built" do
-        v = ds.parts.build(label: 'Alternator')
-        expect(v).to be_new_record
-      end
-
-      it "does not be new when it's loaded from fedora" do
-        ds.content = "_:g70324142325120 <http://purl.org/dc/terms/title> \"Alternator\" .
-<#{ActiveFedora.fedora.host}/test/test:124> <http://purl.org/dc/terms/hasPart> _:g70324142325120 ."
-        ds.resource.persist!
-        expect(ds.parts.first).to_not be_new_record
-      end
-    end
-
-    it "is able to nest a complex object" do
-      comp = SpecDatastream::Component.new(nil, ds.graph)
-      comp.label = ["Alternator"]
-      ds.parts = comp
-      expect(ds.parts.first.label).to eq ["Alternator"]
-    end
-
-    it "is able to replace attributes" do
-      ds.parts.build(label: 'Alternator')
-      expect(ds.parts.first.label).to eq ['Alternator']
-      ds.parts.first.label = ['Distributor']
-      expect(ds.parts.first.label).to eq ['Distributor']
-    end
-
-    it "is able to replace objects" do
-      ds.parts.build(label: 'Alternator')
-      ds.parts.build(label: 'Distributor')
-      expect(ds.parts.size).to eq 2
-      comp = SpecDatastream::Component.new(nil, ds.graph)
-      comp.label = "Injector port"
-      ds.parts = [comp]
-      expect(ds.parts.size).to eq 1
-    end
-
-    it "is able to nest many complex objects" do
-      comp1 = SpecDatastream::Component.new nil, ds.graph
-      comp1.label = ["Alternator"]
-      comp2 = SpecDatastream::Component.new nil, ds.graph
-      comp2.label = ["Crankshaft"]
-      ds.parts = [comp1, comp2]
-      expect(ds.parts.map(&:label)).to contain_exactly ["Alternator"], ["Crankshaft"]
-    end
-
-    it "is able to clear complex objects" do
-      comp1 = SpecDatastream::Component.new nil, ds.graph
-      comp1.label = ["Alternator"]
-      comp2 = SpecDatastream::Component.new nil, ds.graph
-      comp2.label = ["Crankshaft"]
-      ds.parts = [comp1, comp2]
-      ds.parts = []
-      expect(ds.parts).to eq []
-    end
-
-    it "loads complex objects" do
-      ds.content = <<END
-_:g70350851837440 <http://purl.org/dc/terms/title> "Alternator" .
-<#{ActiveFedora.fedora.host}/test/test:124> <http://purl.org/dc/terms/hasPart> _:g70350851837440 .
-<#{ActiveFedora.fedora.host}/test/test:124> <http://purl.org/dc/terms/hasPart> _:g70350851833380 .
-_:g70350851833380 <http://purl.org/dc/terms/title> "Crankshaft" .
-END
-      expect(ds.parts.map(&:label)).to contain_exactly ["Alternator"], ["Crankshaft"]
-    end
-
-    it "builds complex objects when a parent node doesn't exist" do
-      part = ds.parts.build
-      expect(part).to be_kind_of SpecDatastream::Component
-      part.label = "Wheel bearing"
-      expect(ds.parts.first.label).to eq ['Wheel bearing']
-    end
-
-    it "does not create a child node when hitting the accessor" do
-      ds.parts
-      expect(ds.parts.first).to be_nil
-      expect(ds.serialize).to eq ''
-    end
-
-    it "builds complex objects when a parent node exists" do
-      part = ds.parts.build
-      expect(part).to be_kind_of SpecDatastream::Component
-      part.label = "Wheel bearing"
-      expect(ds.parts.first.label).to eq ['Wheel bearing']
-    end
-
-    describe "#first_or_create" do
-      it "returns a result if the predicate exists" do
-        part1 = ds.parts.build
-        expect(ds.parts.first_or_create).to eq part1
-      end
-
-      it "creates a new result if the predicate doesn't exist" do
-        expect(ds.parts).to eq []
-        part = ds.parts.first_or_create(label: 'Front control arm bushing')
-        expect(part.label).to eq ['Front control arm bushing']
-        expect(ds.parts).to eq [part]
-      end
-    end
-  end
-
-  describe "with type" do
-    describe "one class per assertion" do
-      before(:each) do
-        class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
-          property :mediator, predicate: ::RDF::Vocab::DC.mediator, class_name: 'MediatorUser'
-
-          class MediatorUser < ActiveTriples::Resource
-            configure type: ::RDF::Vocab::DC.AgentClass
-            property :title, predicate: ::RDF::Vocab::DC.title
-          end
-        end
-      end
-
-      after(:each) do
-        Object.send(:remove_const, :SpecDatastream)
-      end
-      let(:ds) { SpecDatastream.new("#{ActiveFedora.fedora.host}/test/test:124/descMd") }
-
-      it "stores the type of complex objects when type is specified" do
-        comp = SpecDatastream::MediatorUser.new nil, ds.graph
-        comp.title = ["Doctor"]
-        ds.mediator = comp
-        expect(ds.mediator.first.type.first).to be_instance_of ::RDF::URI
-        expect(ds.mediator.first.type.first.to_s).to eq "http://purl.org/dc/terms/AgentClass"
-        expect(ds.mediator.first.title.first).to eq 'Doctor'
-      end
-
-      it "adds the type of complex object when it is not provided" do
-        ds.content = <<END
-  _:g70350851837440 <http://purl.org/dc/terms/title> "Mediation Person" .
-  <#{ActiveFedora.fedora.host}/test/test:124> <http://purl.org/dc/terms/mediator> _:g70350851837440 .
-END
-        expect(ds.mediator.first.type.first.to_s).to eq "http://purl.org/dc/terms/AgentClass"
-      end
-
-      it "adds load the type of complex objects when provided (superceeding what is specified by the class)" do
-        ds.content = <<END
-  _:g70350851837440 <http://purl.org/dc/terms/title> "Mediation Orgainzation" .
-  _:g70350851837440 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.ebu.ch/metadata/ontologies/ebucore#Organisation> .
-  <#{ActiveFedora.fedora.host}/test/test:124> <http://purl.org/dc/terms/mediator> _:g70350851837440 .
-END
-        expect(ds.mediator.first.type.map(&:to_s)).to include "http://www.ebu.ch/metadata/ontologies/ebucore#Organisation"
-      end
-    end
-
-    describe "shared assertion to different classes" do
-      before(:each) do
-        class EbuCore < RDF::Vocabulary("http://www.ebu.ch/metadata/ontologies/ebucore#")
-          property :isEpisodeOf
-          property :title
-        end
-
-        class SpecContainer < ActiveFedora::Base
-          has_subresource :info, class_name: 'SpecDatastream'
-        end
-
-        class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
-          property :series, predicate: EbuCore.isEpisodeOf, class_name: 'Series'
-          property :program, predicate: EbuCore.isEpisodeOf, class_name: 'Program'
-
-          class Series < ActiveTriples::Resource
-            configure type: 'http://www.ebu.ch/metadata/ontologies/ebucore#Series'
-            property :title, predicate: EbuCore.title
-          end
-
-          class Program < ActiveTriples::Resource
-            configure type: 'http://www.ebu.ch/metadata/ontologies/ebucore#Programme'
-            property :title, predicate: EbuCore.title
-          end
-        end
-      end
-
-      after(:each) do
-        Object.send(:remove_const, :SpecDatastream)
-        Object.send(:remove_const, :SpecContainer)
-      end
-
-      let(:parent) { SpecContainer.new id: '124' }
-      let(:file) { parent.info }
-
-      it "stores the type of complex objects when type is specified" do
-        pending "This is no longer supported by ActiveTriples - can we deprecate this altogether?"
-        series = SpecDatastream::Series.new nil, file.graph
-        series.title = ["renovating bathrooms"]
-        file.series = series
-
-        program = SpecDatastream::Program.new nil, file.graph
-        program.title = ["This old House"]
-        file.program = program
-
-        expect(file.program.first.type.size).to eq 1
-        expect(file.program.first.type.first.to_s).to eq 'http://www.ebu.ch/metadata/ontologies/ebucore#Programme'
-        expect(file.series.first.type.size).to eq 1
-        expect(file.series.first.type.first.to_s).to eq 'http://www.ebu.ch/metadata/ontologies/ebucore#Series'
-      end
-
-      it "creates an object of the correct type" do
-        expect(file.program.build).to be_kind_of SpecDatastream::Program
-        expect(file.series.build).to be_kind_of SpecDatastream::Series
-      end
-    end
-  end
-end

data/spec/integration/datastream_rdf_nested_attributes_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-
-describe "Nesting attribute behavior of RDFDatastream" do
-  describe ".attributes=" do
-    context "complex properties in a datastream" do
-      before do
-        class DummyMADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
-          # TODO: this test is order dependent. It expects to use the object created in the previous test
-          # componentList and Types of components
-          property :componentList
-          property :Topic
-          property :Temporal
-          property :PersonalName
-          property :CorporateName
-          property :ComplexSubject
-
-          # elementList and elementList values
-          property :elementList
-          property :elementValue
-          property :TopicElement
-          property :TemporalElement
-          property :NameElement
-          property :FullNameElement
-          property :DateNameElement
-        end
-
-        class ComplexRDFDatastream < ActiveFedora::NtriplesRDFDatastream
-          property :topic, predicate: DummyMADS.Topic, class_name: "Topic"
-          property :personalName, predicate: DummyMADS.PersonalName, class_name: "PersonalName"
-          property :title, predicate: ::RDF::Vocab::DC.title
-
-          accepts_nested_attributes_for :topic, :personalName
-
-          class Topic < ActiveTriples::Resource
-            property :elementList, predicate: DummyMADS.elementList, class_name: "ComplexRDFDatastream::ElementList"
-            accepts_nested_attributes_for :elementList
-          end
-          class PersonalName < ActiveTriples::Resource
-            property :elementList, predicate: DummyMADS.elementList, class_name: "ComplexRDFDatastream::ElementList"
-            property :extraProperty, predicate: DummyMADS.elementValue, class_name: "ComplexRDFDatastream::Topic"
-            accepts_nested_attributes_for :elementList, :extraProperty
-          end
-          class ElementList < ActiveTriples::List
-            configure type: DummyMADS.elementList
-            property :topicElement, predicate: DummyMADS.TopicElement, class_name: "ComplexRDFDatastream::MadsTopicElement"
-            property :temporalElement, predicate: DummyMADS.TemporalElement
-            property :fullNameElement, predicate: DummyMADS.FullNameElement
-            property :dateNameElement, predicate: DummyMADS.DateNameElement
-            property :nameElement, predicate: DummyMADS.NameElement
-            property :elementValue, predicate: DummyMADS.elementValue
-            accepts_nested_attributes_for :topicElement
-          end
-          class MadsTopicElement < ActiveTriples::Resource
-            configure type: DummyMADS.TopicElement
-            property :elementValue, predicate: DummyMADS.elementValue
-          end
-        end
-      end
-      after do
-        Object.send(:remove_const, :ComplexRDFDatastream)
-        Object.send(:remove_const, :DummyMADS)
-      end
-      subject(:complex_datastream) { ComplexRDFDatastream.new }
-      let(:params) do
-        { myResource:
-          {
-            topic_attributes: {
-              '0' =>
-              {
-                elementList_attributes: [{
-                  topicElement_attributes: [{
-                    id: 'http://library.ucsd.edu/ark:/20775/bb3333333x',
-                    elementValue: "Cosmology"
-                  }]
-                }]
-              },
-              '1' =>
-              {
-                elementList_attributes: [{
-                  topicElement_attributes: { '0' => { elementValue: "Quantum Behavior" } }
-                }]
-              }
-            },
-            personalName_attributes: [
-              {
-                id: 'http://library.ucsd.edu/ark:20775/jefferson',
-                elementList_attributes: [{
-                  fullNameElement: "Jefferson, Thomas",
-                  dateNameElement: "1743-1826"
-                }]
-              }
-              # , "Hemings, Sally"
-            ]
-          } }
-      end
-
-      describe "on lists" do
-        subject(:personal_name) { ComplexRDFDatastream::PersonalName.new(nil) }
-        it "accepts a hash" do
-          personal_name.elementList_attributes = [{ topicElement_attributes: { '0' => { elementValue: "Quantum Behavior" }, '1' => { elementValue: "Wave Function" } } }]
-          expect(personal_name.elementList.first[0].elementValue).to eq ["Quantum Behavior"]
-          expect(personal_name.elementList.first[1].elementValue).to eq ["Wave Function"]
-        end
-        it "accepts an array" do
-          personal_name.elementList_attributes = [{ topicElement_attributes: [{ elementValue: "Quantum Behavior" }, { elementValue: "Wave Function" }] }]
-          element_values = personal_name.elementList.first.map(&:elementValue)
-          expect(element_values).to contain_exactly ["Quantum Behavior"], ["Wave Function"]
-        end
-      end
-
-      context "from nested objects" do
-        before do
-          # Replace the graph's contents with the Hash
-          complex_datastream.attributes = params[:myResource]
-        end
-
-        it 'has attributes' do
-          element_values = complex_datastream.topic.map { |x| x.elementList.first[0].elementValue }
-          expect(element_values).to contain_exactly ["Cosmology"], ["Quantum Behavior"]
-          expect(complex_datastream.personalName.first.elementList.first.fullNameElement).to contain_exactly "Jefferson, Thomas"
-          expect(complex_datastream.personalName.first.elementList.first.dateNameElement).to contain_exactly "1743-1826"
-        end
-
-        it 'builds nodes with ids' do
-          element_list_elements = complex_datastream.topic.flat_map { |y| y.elementList.first[0].rdf_subject }
-          expect(element_list_elements).to include 'http://library.ucsd.edu/ark:/20775/bb3333333x'
-          expect(complex_datastream.personalName.first.rdf_subject).to eq 'http://library.ucsd.edu/ark:20775/jefferson'
-        end
-
-        it 'fails when writing to a non-predicate' do
-          attributes = { topic_attributes: { '0' => { elementList_attributes: [{ topicElement_attributes: [{ fake_predicate: "Cosmology" }] }] } } }
-          expect { complex_datastream.attributes = attributes }.to raise_error ArgumentError
-        end
-
-        it 'fails when writing to a non-predicate with a setter method' do
-          attributes = { topic_attributes: { '0' => { elementList_attributes: [{ topicElement_attributes: [{ name: "Cosmology" }] }] } } }
-          expect { complex_datastream.attributes = attributes }.to raise_error ArgumentError
-        end
-      end
-    end
-
-    describe "with an existing object" do
-      before(:each) do
-        class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
-          property :parts, predicate: ::RDF::Vocab::DC.hasPart, class_name: 'Component'
-          accepts_nested_attributes_for :parts, allow_destroy: true
-
-          class Component < ActiveTriples::Resource
-            property :label, predicate: ::RDF::Vocab::DC.title
-          end
-        end
-      end
-
-      after(:each) do
-        Object.send(:remove_const, :SpecDatastream)
-      end
-      subject(:spec_datastream) { SpecDatastream.new }
-      before do
-        spec_datastream.attributes = { parts_attributes: [
-          { label: 'Alternator' },
-          { label: 'Distributor' },
-          { label: 'Transmission' },
-          { label: 'Fuel Filter' }
-        ] }
-      end
-      let(:replace_object_id) { spec_datastream.parts.find { |x| x.label == ['Distributor'] }.rdf_subject.to_s }
-      let(:remove_object_id) { spec_datastream.parts.find { |x| x.label == ['Fuel Filter'] }.rdf_subject.to_s }
-
-      it "updates nested objects" do
-        spec_datastream.parts_attributes = [{ id: replace_object_id, label: "Universal Joint" }, { label: "Oil Pump" }, { id: remove_object_id, _destroy: '1', label: "bar1 uno" }]
-
-        expect(spec_datastream.parts.map { |p| p.label.first }).to contain_exactly 'Alternator', 'Universal Joint', 'Transmission', 'Oil Pump'
-      end
-      it "create a new object when the id is provided" do
-        spec_datastream.parts_attributes = [{ id: 'http://example.com/part#1', label: "Universal Joint" }]
-        expect(spec_datastream.parts.map(&:rdf_subject)).to include RDF::URI('http://example.com/part#1')
-      end
-    end
-  end
-end

data/spec/integration/ntriples_datastream_spec.rb

@@ -1,215 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::NtriplesRDFDatastream do
-  before do
-    class FileVocabulary < RDF::Vocabulary("http://downlode.org/Code/RDF/File_Properties/schema#")
-      property :size
-    end
-
-    Deprecation.silence(ActiveFedora::RDFDatastream) do
-      class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-        property :title, predicate: ::RDF::Vocab::DC.title do |index|
-          index.as :stored_searchable, :facetable
-        end
-        property :date_uploaded, predicate: ::RDF::Vocab::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::Vocab::DC.hasPart
-        property :based_near, predicate: ::RDF::Vocab::FOAF.based_near
-        property :related_url, predicate: ::RDF::RDFS.seeAlso
-      end
-    end
-
-    class RdfTest < ActiveFedora::Base
-      has_subresource 'rdf', class_name: 'MyDatastream'
-    end
-  end
-
-  subject(:my_datastream) { MyDatastream.new(described_class.id_to_uri('test:1')) }
-
-  after do
-    Object.send(:remove_const, :RdfTest)
-    Object.send(:remove_const, :MyDatastream)
-    Object.send(:remove_const, :FileVocabulary)
-  end
-
-  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
-
-  it "delegates as_json to the fields" do
-    my_datastream.title = "Title of work"
-    expect(my_datastream.title.as_json).to eq ["Title of work"]
-    expect(my_datastream.title.to_json).to eq "\[\"Title of work\"\]"
-  end
-
-  describe "serializing" do
-    it "handles dates" do
-      my_datastream.date_uploaded = [Date.parse('2012-11-02')]
-      expect(my_datastream.date_uploaded.first).to be_kind_of Date
-    end
-    it "handles integers" do
-      my_datastream.filesize = 12_345
-      expect(my_datastream.filesize).to eq [12_345]
-      expect(my_datastream.filesize.first).to be_kind_of Fixnum
-    end
-  end
-
-  it "sets and recall values" do
-    my_datastream.title = 'War and Peace'
-    expect(my_datastream).to be_changed
-    my_datastream.based_near = ["Moscow, Russia"]
-    my_datastream.related_url = ["http://en.wikipedia.org/wiki/War_and_Peace"]
-    my_datastream.part = ["this is a part"]
-    my_datastream.save
-    expect(my_datastream.title).to eq ['War and Peace']
-    expect(my_datastream.based_near).to eq ["Moscow, Russia"]
-    expect(my_datastream.related_url).to eq ["http://en.wikipedia.org/wiki/War_and_Peace"]
-    expect(my_datastream.part).to eq ["this is a part"]
-  end
-
-  it "set, persist, and recall values" do
-    my_datastream.title = 'War and Peace'
-    my_datastream.based_near = ["Moscow, Russia"]
-    my_datastream.related_url = ["http://en.wikipedia.org/wiki/War_and_Peace"]
-    my_datastream.part = ["this is a part"]
-    my_datastream.save
-
-    loaded = MyDatastream.new(my_datastream.uri)
-    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 "sets multiple values" do
-    my_datastream.part = ["part 1", "part 2"]
-    my_datastream.save
-
-    loaded = MyDatastream.new(my_datastream.uri)
-    expect(loaded.part).to contain_exactly 'part 1', 'part 2'
-  end
-
-  it "appends values" do
-    my_datastream.part = ["thing 1"]
-    my_datastream.save
-
-    my_datastream.part << "thing 2"
-    expect(my_datastream.part).to contain_exactly "thing 1", "thing 2"
-  end
-
-  it "is able to save a blank document" do
-    my_datastream.title = ""
-    my_datastream.save
-  end
-
-  it "loads n-triples into the graph" do
-    ntrip = '<http://oregondigital.org/ns/62> <http://purl.org/dc/terms/type> "Image" .
-<http://oregondigital.org/ns/62> <http://purl.org/dc/terms/spatial> "Benton County (Ore.)" .
-'
-    my_datastream.content = ntrip
-    expect(my_datastream.graph.statements.to_a).to contain_exactly(*RDF::NTriples::Reader.new(ntrip).statements.to_a)
-  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/#{parent_uri(ds).split('/')[-1].split(':')[1]}") }
-        property :dctype, predicate: ::RDF::Vocab::DC.type
-      end
-      rdf_test.rdf.dctype = "Frog"
-      rdf_test.save!
-    end
-
-    after do
-      rdf_test.destroy
-    end
-
-    subject(:rdf_test) { RdfTest.new(id: '/test:99') }
-
-    it "writes rdf with proper subjects" do
-      rdf_test.reload
-      expect(rdf_test.rdf.graph.dump(:ntriples)).to eq "<http://oregondigital.org/ns/99> <http://purl.org/dc/terms/type> \"Frog\" .\n"
-      rdf_test.rdf.dctype == ['Frog']
-    end
-  end
-
-  it "deletes values" do
-    my_datastream.title = "Hamlet"
-    my_datastream.related_url = ["http://psu.edu/"]
-    my_datastream.related_url << "http://projecthydra.org/"
-
-    expect(my_datastream.title).to eq ["Hamlet"]
-    expect(my_datastream.related_url).to include("http://psu.edu/")
-    expect(my_datastream.related_url).to include("http://projecthydra.org/")
-
-    my_datastream.title = "" # empty string can be meaningful, don't assume delete.
-    expect(my_datastream.title).to eq ['']
-
-    my_datastream.title = nil
-    my_datastream.related_url.delete("http://projecthydra.org/")
-
-    expect(my_datastream.title).to eq []
-    expect(my_datastream.related_url).to eq ["http://psu.edu/"]
-  end
-
-  it "deletes multiple values at once" do
-    my_datastream.part = ["MacBeth"]
-    my_datastream.part << "Hamlet"
-    my_datastream.part << "Romeo & Juliet"
-    expect(my_datastream.part).to include "MacBeth"
-    my_datastream.part.subtract(["MacBeth", "Romeo & Juliet"])
-    expect(my_datastream.part).to eq ["Hamlet"]
-    expect(my_datastream.part.first).to eq "Hamlet"
-  end
-  it "ignores values to be deleted that do not exist" do
-    my_datastream.part = ["title1", "title2", "title3"]
-    my_datastream.part.subtract(["title2", "title4", "title6"])
-    expect(my_datastream.part).to contain_exactly "title1", "title3"
-  end
-
-  describe "term proxy methods" do
-    before(:each) do
-      class TitleDatastream < ActiveFedora::NtriplesRDFDatastream
-        property :title, predicate: ::RDF::Vocab::DC.title
-      end
-    end
-    subject(:title_datastream) { TitleDatastream.new }
-    before { title_datastream.title = ["title1", "title2", "title3"] }
-
-    after(:each) do
-      Object.send(:remove_const, :TitleDatastream)
-    end
-
-    it "supports the count method to determine # of values" do
-      expect(title_datastream.title.count).to eq 3
-    end
-    it "iterates over multiple values" do
-      expect(title_datastream.title).to respond_to(:each)
-    end
-    it "evaluates equality predictably" do
-      expect(title_datastream.title).to contain_exactly "title1", "title2", "title3"
-    end
-    it "supports the empty? method" do
-      expect(title_datastream.title).to_not be_empty
-      title_datastream.title.subtract(["title1", "title2", "title3"])
-      expect(title_datastream.title).to be_empty
-    end
-    it "supports the each method" do
-      expect(title_datastream.title.respond_to?(:each)).to eq true
-    end
-  end
-end