active-fedora 7.0.4 → 7.1.0

data/spec/unit/rdf_configurable_spec.rb

@@ -1,37 +0,0 @@
-require "spec_helper"
-describe ActiveFedora::Rdf::Configurable do
-  before do
-    class DummyConfigurable
-      extend ActiveFedora::Rdf::Configurable
-    end
-  end
-  after do
-    Object.send(:remove_const, "DummyConfigurable")
-  end
-
-  describe '#configure' do
-    before do
-      DummyConfigurable.configure :base_uri => "http://example.org/base", :type => RDF.Class, :rdf_label => RDF::DC.title
-    end
-
-    it 'should set a base uri' do
-      expect(DummyConfigurable.base_uri).to eq "http://example.org/base"
-    end
-
-    it 'should set an rdf_label' do
-      expect(DummyConfigurable.rdf_label).to eq RDF::DC.title
-    end
-
-    it 'should set a type' do
-      expect(DummyConfigurable.type).to eq RDF.Class
-    end
-  end
-
-  describe '#rdf_type' do
-    it "should set the type the old way" do
-      DummyConfigurable.should_receive(:configure).with(:type => RDF.Class).and_call_original
-      DummyConfigurable.rdf_type(RDF.Class)
-      expect(DummyConfigurable.type).to eq RDF.Class
-    end
-  end
-end

data/spec/unit/rdf_list_nested_attributes_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Rdf::List do
-  before :each do
-    class MADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
-      property :MADSScheme
-      property :isMemberOfMADSScheme
-      property :authoritativeLabel
-      property :elementList
-      property :elementValue
-      property :Topic
-      property :TopicElement
-      property :TemporalElement
-      property :hasExactExternalAuthority
-    end
-
-    class TopicElement < ActiveFedora::Rdf::Resource
-      configure :type => MADS.TopicElement
-      property :elementValue, :predicate => MADS.elementValue
-    end
-    class TemporalElement < ActiveFedora::Rdf::Resource
-      configure :type => MADS.TemporalElement
-      property :elementValue, :predicate => MADS.elementValue
-    end
-    class ElementList < ActiveFedora::Rdf::List
-      property :topicElement, :predicate => MADS.TopicElement, :class_name => 'TopicElement'
-      property :temporalElement, :predicate => MADS.TemporalElement, :class_name => 'TemporalElement'
-      accepts_nested_attributes_for :topicElement, :temporalElement
-    end
-
-    class Topic < ActiveFedora::Rdf::Resource
-      configure :type => MADS.Topic
-      configure :base_uri => "http://example.org/id_namespace#"
-      property :name, :predicate => MADS.authoritativeLabel
-      property :elementList, :predicate => MADS.elementList, :class_name => 'ElementList'
-      property :externalAuthority, :predicate => MADS.hasExactExternalAuthority
-
-      accepts_nested_attributes_for :elementList
-    end
-  end
-  after(:each) do
-    Object.send(:remove_const, :Topic)
-    Object.send(:remove_const, :ElementList)
-    Object.send(:remove_const, :TopicElement)
-    Object.send(:remove_const, :TemporalElement)
-    Object.send(:remove_const, :MADS)
-  end
-
-  describe "nested_attributes" do
-    it "should insert new nodes into RdfLists (rather than calling .build)" do
-      params = {
-        topic: {
-          name: "Baseball",
-          externalAuthority: "http://id.loc.gov/authorities/subjects/sh85012026",
-          elementList_attributes: [
-            topicElement_attributes: [{ elementValue: "Baseball" }, elementValue: "Football"],
-          ]
-        }
-      }
-
-      topic = Topic.new
-      topic.attributes = params[:topic]
-      topic.elementList.first.size.should == 2
-      topic.elementList.first[0].should be_kind_of(TopicElement)
-      topic.elementList.first[0].elementValue.should == ["Baseball"]
-      topic.elementList.first[1].should be_kind_of(TopicElement)
-      topic.elementList.first[1].elementValue.should == ["Football"]
-
-      # only one rdf:rest rdf:nil
-      topic.query([nil, RDF.rest, RDF.nil]).size.should == 1
-    end
-    it "should insert new nodes of varying types into RdfLists (rather than calling .build)" do
-      # It's Not clear what the syntax should be when an RDF list contains multiple types of sub-nodes.
-      # This is a guess, which currently works.
-      params = {
-        topic: {
-          name: "Baseball",
-          externalAuthority: "http://id.loc.gov/authorities/subjects/sh85012026",
-          elementList_attributes: [
-            topicElement_attributes: [{ elementValue: "Baseball" }, elementValue: "Football"],
-            temporalElement_attributes: [{elementValue: "1960"}, {elementValue:"Twentieth Century"}],
-          ]
-        }
-      }
-
-      topic = Topic.new
-      topic.attributes = params[:topic]
-      topic.elementList.first.size.should == 4
-      topic.elementList.first[0].should be_kind_of(TopicElement)
-      topic.elementList.first[0].elementValue.should == ["Baseball"]
-      topic.elementList.first[1].should be_kind_of(TopicElement)
-      topic.elementList.first[1].elementValue.should == ["Football"]
-      topic.elementList.first[2].should be_kind_of(TemporalElement)
-      topic.elementList.first[2].elementValue.should == ["1960"]
-      topic.elementList.first[3].should be_kind_of(TemporalElement)
-      topic.elementList.first[3].elementValue.should == ["Twentieth Century"]
-    end
-  end
-end

data/spec/unit/rdf_list_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Rdf::List do
-  before :each do
-    class MADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
-      property :complexSubject
-      property :authoritativeLabel
-      property :elementList
-      property :elementValue
-      property :TopicElement
-      property :TemporalElement
-    end
-    class DemoList < ActiveFedora::RdfxmlRDFDatastream
-      property :elementList, :predicate => MADS.elementList, :class_name => 'DemoList::List'
-      class List < ActiveFedora::Rdf::List
-        property :topicElement, :predicate => MADS.TopicElement, :class_name => 'DemoList::List::TopicElement'
-        property :temporalElement, :predicate => MADS.TemporalElement, :class_name => 'DemoList::List::TemporalElement'
-
-        class TopicElement < ActiveFedora::Rdf::Resource
-          configure :type => MADS.TopicElement
-          property :elementValue, :predicate => MADS.elementValue
-        end
-        class TemporalElement < ActiveFedora::Rdf::Resource
-          configure :type => MADS.TemporalElement
-          property :elementValue, :predicate => MADS.elementValue
-        end
-      end
-    end
-  end
-  after(:each) do
-    Object.send(:remove_const, :DemoList)
-    Object.send(:remove_const, :MADS)
-  end
-
-  describe "a new list" do
-    let (:ds) { DemoList.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMetadata')}
-    subject { ds.elementList.build}
-
-    it "should insert at the end" do
-      subject.should be_kind_of DemoList::List
-      subject.size.should == 0
-      subject[1] = DemoList::List::TopicElement.new
-      subject.size.should == 2
-    end
-
-    it "should insert at the head" do
-      subject.should be_kind_of DemoList::List
-      subject.size.should == 0
-      subject[0] = DemoList::List::TopicElement.new
-      subject.size.should == 1
-    end
-
-    describe "that has 4 elements" do
-      before do
-        subject[3] = DemoList::List::TopicElement.new
-        subject.size.should == 4
-      end
-      it "should insert in the middle" do
-        subject[1] = DemoList::List::TopicElement.new
-        subject.size.should == 4
-      end
-    end
-
-    describe "return updated xml" do
-      it "should be built" do
-        subject[0] = RDF::URI.new "http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"
-        subject[1] = DemoList::List::TopicElement.new
-        subject[1].elementValue = "Relations with Mexican Americans"
-        subject[2] = RDF::URI.new "http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"
-        subject[3] = DemoList::List::TemporalElement.new
-        subject[3].elementValue = "20th century"
-        ds.elementList = subject
-        doc = Nokogiri::XML(ds.content)
-        ns = {rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#", mads: "http://www.loc.gov/mads/rdf/v1#"}
-        expect(doc.xpath('/rdf:RDF/rdf:Description/@rdf:about', ns).map(&:value)).to eq ["info:fedora/foo"]
-        expect(doc.xpath('//rdf:Description/mads:elementList/@rdf:parseType', ns).map(&:value)).to eq ["Collection"]
-        expect(doc.xpath('//rdf:Description/mads:elementList/*[position() = 1]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"]
-        expect(doc.xpath('//rdf:Description/mads:elementList/*[position() = 2]/mads:elementValue', ns).map(&:text)).to eq ["Relations with Mexican Americans"]
-        expect(doc.xpath('//rdf:Description/mads:elementList/*[position() = 3]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"]
-        expect(doc.xpath('//rdf:Description/mads:elementList/*[position() = 4]/mads:elementValue', ns).map(&:text)).to eq ["20th century"]
-      end
-    end
-  end
-
-  describe "an empty list" do
-    subject { DemoList.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMd').elementList.build } 
-    it "should have to_ary" do
-      subject.to_ary.should == []
-    end
-  end
-
-  describe "a list that has a constructed element" do
-    let(:ds) { DemoList.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMd') }
-    let(:list) { ds.elementList.build } 
-    let!(:topic) { list.topicElement.build }
-
-    it "should have to_ary" do
-      list.to_ary.size.should == 1
-      list.to_ary.first.class.should == DemoList::List::TopicElement
-    end
-
-    it "should be able to be cleared" do
-      list.topicElement.build
-      list.topicElement.build
-      list.topicElement.build
-      list.size.should == 4
-      list.clear
-      list.size.should == 0
-    end
-  end
-
-  describe "a list with content" do
-    subject do
-      subject = DemoList.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMetadata')
-      subject.content =<<END
-  <rdf:RDF
-      xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:mads="http://www.loc.gov/mads/rdf/v1#">
-
-        <mads:ComplexSubject rdf:about="info:fedora/foo">
-          <mads:elementList rdf:parseType="Collection">
-            <rdf:Description rdf:about="http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"/>
-            <mads:TopicElement>
-              <mads:elementValue>Relations with Mexican Americans</mads:elementValue>
-            </mads:TopicElement>
-            <rdf:Description rdf:about="http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"/>
-            <mads:TemporalElement>
-              <mads:elementValue>20th century</mads:elementValue>
-            </mads:TemporalElement>
-          </mads:elementList>
-        </mads:ComplexSubject>
-      </rdf:RDF>
-END
-
-      subject
-    end
-    it "should have a subject" do
-      subject.rdf_subject.to_s.should == "info:fedora/foo"
-    end
-
-    let (:list) { subject.elementList.first }
-
-    it "should have fields" do
-      list.first.rdf_subject.should == "http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"
-      list[1].should be_kind_of DemoList::List::TopicElement
-      list[1].elementValue.should == ["Relations with Mexican Americans"]
-      list[2].rdf_subject.should == "http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"
-      list[3].should be_kind_of DemoList::List::TemporalElement
-      list[3].elementValue.should == ["20th century"]
-    end
-
-    it "should have each" do
-      foo = []
-      list.each { |n| foo << n.class }
-      foo.should == [ActiveFedora::Rdf::Resource, DemoList::List::TopicElement, ActiveFedora::Rdf::Resource, DemoList::List::TemporalElement]
-    end
-
-    it "should have to_ary" do
-      ary = list.to_ary
-      ary.size.should == 4
-      ary[1].elementValue.should == ['Relations with Mexican Americans']
-    end
-
-    it "should have size" do
-      list.size.should == 4
-    end
-
-    it "should update fields" do
-      list[3].elementValue = ["1900s"]
-      doc = Nokogiri::XML(subject.content)
-      ns = {rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#", mads: "http://www.loc.gov/mads/rdf/v1#"}
-      expect(doc.xpath('/rdf:RDF/mads:ComplexSubject/@rdf:about', ns).map(&:value)).to eq ["info:fedora/foo"]
-      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/@rdf:parseType', ns).map(&:value)).to eq ["Collection"]
-      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 1]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"]
-      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 2]/mads:elementValue', ns).map(&:text)).to eq ["Relations with Mexican Americans"]
-      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 3]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"]
-      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 4]/mads:elementValue', ns).map(&:text)).to eq ["1900s"]
-    end
-  end
-end
-

data/spec/unit/rdf_properties_spec.rb

@@ -1,81 +0,0 @@
-require "spec_helper"
-describe ActiveFedora::Rdf::Properties do
-  before do
-    class DummyProperties
-      extend ActiveFedora::Rdf::Properties
-    end
-  end
-
-  after do
-    Object.send(:remove_const, "DummyProperties")
-  end
-
-  describe '#map_predicates' do
-    before do
-      DummyProperties.map_predicates do |map|
-        map.title(:in => RDF::DC, :class_name => RDF::Literal) do |index|
-          index.as :facetable, :searchable
-        end
-      end
-    end
-
-    it 'should set a property' do
-      expect(DummyProperties.properties).to include :title
-    end
-
-    it "should set index behaviors" do
-      expect(DummyProperties.properties[:title][:behaviors]).to eq [:facetable, :searchable]
-    end
-
-    it "should set a class name" do
-      expect(DummyProperties.properties[:title][:class_name]).to eq RDF::Literal
-    end
-  end
-
-  describe '#property' do
-    it 'should set a property' do
-      DummyProperties.property :title, :predicate => RDF::DC.title
-      expect(DummyProperties.properties).to include :title
-    end
-
-    it 'should set index behaviors' do
-      DummyProperties.property :title, :predicate => RDF::DC.title do |index|
-        index.as :facetable, :searchable
-      end
-      expect(DummyProperties.properties[:title][:behaviors]).to eq [:facetable, :searchable]
-    end
-
-    it 'should set class name' do
-      DummyProperties.property :title, :predicate => RDF::DC.title, :class_name => RDF::Literal
-      expect(DummyProperties.properties[:title][:class_name]).to eq RDF::Literal
-    end
-
-    it "should constantize string class names" do
-      DummyProperties.property :title, :predicate => RDF::DC.title, :class_name => "RDF::Literal"
-      expect(DummyProperties.properties[:title][:class_name]).to eq RDF::Literal
-    end
-
-    it "should keep strings which it can't constantize as strings" do
-      DummyProperties.property :title, :predicate => RDF::DC.title, :class_name => "FakeClassName"
-      expect(DummyProperties.properties[:title][:class_name]).to eq "FakeClassName"
-    end
-
-  end
-
-  context "when using a subclass" do
-    before do
-      DummyProperties.property :title, :predicate => RDF::DC.title
-      class DummySubClass < DummyProperties
-        property :source, :predicate => RDF::DC11[:source]
-      end
-    end
-
-    after do
-      Object.send(:remove_const, "DummySubClass")
-    end
-
-    it 'should carry properties from superclass' do
-      expect(DummySubClass.properties.keys).to eq ["title", "source"]
-    end
-  end
-end

data/spec/unit/rdf_repositories_spec.rb

@@ -1,28 +0,0 @@
-require "spec_helper"
-describe ActiveFedora::Rdf::Repositories do
-  subject {ActiveFedora::Rdf::Repositories}
-
-  after(:each) do
-    subject.clear_repositories!
-    subject.add_repository :default, RDF::Repository.new
-    subject.add_repository :vocabs, RDF::Repository.new
-  end
-
-  describe '#add_repositories' do
-    it 'should accept a new repository' do
-      subject.add_repository :name, RDF::Repository.new
-      expect(subject.repositories).to include :name
-    end
-    it 'should throw an error if passed something that is not a repository' do
-      expect{subject.add_repository :name, :not_a_repo}.to raise_error
-    end
-  end
-
-  describe '#clear_repositories!' do
-    it 'should empty the repositories list' do
-      subject.clear_repositories!
-      expect(subject.repositories).to be_empty
-    end
-  end
-
-end

data/spec/unit/rdf_resource_spec.rb

@@ -1,345 +0,0 @@
-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
-
-    it "should raise an error when setting to an invalid uri" do
-      expect{ subject.set_subject!('not_a_uri') }.to raise_error "could not make a valid RDF::URI from not_a_uri"
-    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