active-fedora 6.8.0 → 7.0.0.pre1

data/spec/unit/has_and_belongs_to_many_collection_spec.rb

@@ -1,45 +1,64 @@
 require 'spec_helper'
 
 describe ActiveFedora::Associations::HasAndBelongsToManyAssociation do
-  it 'should call add_relationship' do
-    subject = double('subject', :new_record? => false, :pid => 'subject:a', :internal_uri => 'info:fedora/subject:a', :ids_for_outbound => [])
-    predicate = double(:klass => double.class, :options => {:property => 'predicate'}, :class_name => nil)
-    allow(ActiveFedora::SolrService).to receive(:query).and_return([])
-    ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, predicate)
-    object = double('object', :new_record? => false, :pid => 'object:b', :save => nil)
+  before do 
+    class Book < ActiveFedora::Base
+    end
+    class Page < ActiveFedora::Base
+    end
+  end
 
-    expect(subject).to receive(:add_relationship).with('predicate', object)
+  after do
+    Object.send(:remove_const, :Book)
+    Object.send(:remove_const, :Page)
+  end
 
+  it "should call add_relationship" do
+    subject = Book.new(pid: 'subject:a')
+    subject.stub(:new_record? => false, save: true)
+    predicate = Book.create_reflection(:has_and_belongs_to_many, 'pages', {:property=>'predicate'}, nil)
+    ActiveFedora::SolrService.stub(:query).and_return([])
+    ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, predicate)
+    ac.should_receive(:callback).twice
+    object = Page.new(:pid => 'object:b')
+    object.stub(:new_record? => false, save: true)
+  
+    subject.should_receive(:add_relationship).with('predicate', object)
+ 
     ac << object
 
   end
 
-  it 'should call add_relationship on subject and object when inverse_of given' do
-    subject = double('subject', :new_record? => false, :pid => 'subject:a', :internal_uri => 'info:fedora/subject:a', :ids_for_outbound => [])
-    predicate = double(:klass => double.class, :options => {:property => 'predicate', :inverse_of => 'inverse_predicate'}, :class_name => nil)
-    allow(ActiveFedora::SolrService).to receive(:query).and_return([])
+  it "should call add_relationship on subject and object when inverse_of given" do
+    subject = Book.new(pid: 'subject:a')
+    subject.stub(:new_record? => false, save: true)
+    predicate = Book.create_reflection(:has_and_belongs_to_many, 'pages', {:property=>'predicate', :inverse_of => 'inverse_predicate'}, nil)
+    ActiveFedora::SolrService.stub(:query).and_return([])
     ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, predicate)
-    object = double('object', :new_record? => false, :pid => 'object:b', :save => nil)
-
-    expect(subject).to receive(:add_relationship).with('predicate', object)
-
-    expect(object).to receive(:add_relationship).with('inverse_predicate', subject)
-
+    ac.should_receive(:callback).twice
+    object = Page.new(:pid => 'object:b')
+    object.stub(:new_record? => false, save: true)
+  
+    subject.should_receive(:add_relationship).with('predicate', object)
+ 
+    object.should_receive(:add_relationship).with('inverse_predicate', subject)
+ 
     ac << object
 
   end
 
-  it 'should call solr query multiple times' do
+  it "should call solr query multiple times" do
 
-    subject = double('subject', :new_record? => false, :pid => 'subject:a', :internal_uri => 'info:fedora/subject:a', :ids_for_outbound => [])
-    predicate = double(:klass => double.class, :options => {:property => 'predicate', solr_page_size: 10}, :class_name => nil)
+    subject = Book.new(pid: 'subject:a')
+    subject.stub(:new_record? => false, save: true)
+    predicate = Book.create_reflection(:has_and_belongs_to_many, 'pages', {:property=>'predicate', :solr_page_size => 10}, nil)
     ids = []
     0.upto(15) {|i| ids << i.to_s}
-    query1 = ids.slice(0, 10).map {|i| "_query_:\"{!raw f=id}#{i}\""}.join(' OR ')
-    query2 = ids.slice(10, 10).map {|i| "_query_:\"{!raw f=id}#{i}\""}.join(' OR ')
-    expect(subject).to receive(:ids_for_outbound).and_return(ids)
-    expect(ActiveFedora::SolrService).to receive(:query).with(query1, {:rows => 10}).and_return([])
-    expect(ActiveFedora::SolrService).to receive(:query).with(query2, {:rows => 10}).and_return([])
+    query1 = ids.slice(0,10).map {|i| "_query_:\"{!raw f=id}#{i}\""}.join(" OR ")
+    query2 = ids.slice(10,10).map {|i| "_query_:\"{!raw f=id}#{i}\""}.join(" OR ")
+    subject.should_receive(:ids_for_outbound).and_return(ids)
+    ActiveFedora::SolrService.should_receive(:query).with(query1, {:rows=>10}).and_return([])
+    ActiveFedora::SolrService.should_receive(:query).with(query2, {:rows=>10}).and_return([])
 
     ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, predicate)
     ac.find_target

data/spec/unit/has_many_collection_spec.rb

@@ -1,17 +1,35 @@
 require 'spec_helper'
 
 describe ActiveFedora::Associations::HasManyAssociation do
-  it 'should call add_relationship' do
-    subject = double('subject', :new_record? => false, :pid => 'subject:a', :internal_uri => 'info:fedora/subject:a')
-    predicate = double(:klass => double.class, :options => {:property => 'predicate'}, :class_name => nil)
-    allow(ActiveFedora::SolrService).to receive(:query).and_return([])
-    ac = ActiveFedora::Associations::HasManyAssociation.new(subject, predicate)
-    object = double('object', :new_record? => false, :pid => 'object:b', :save => nil)
+  before do 
+    class Book < ActiveFedora::Base
+    end
+    class Page < ActiveFedora::Base
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :Book)
+    Object.send(:remove_const, :Page)
+  end
 
-    expect(object).to receive(:add_relationship).with('predicate', subject)
+  subject { Book.new(pid: 'subject:a') }
+  before {
+    subject.stub(:new_record? => false, save: true)
+  }
 
+  it "should call add_relationship" do
+    reflection = Book.create_reflection(:has_many, 'pages', {:property=>'predicate'}, Book)
+    ActiveFedora::SolrService.stub(:query).and_return([])
+    ac = ActiveFedora::Associations::HasManyAssociation.new(subject, reflection)
+    ac.should_receive(:callback).twice
+    object = Page.new(:pid => 'object:b')
+    object.stub(:new_record? => false, save: true)
+  
+    object.should_receive(:add_relationship).with('predicate', subject)
+ 
     ac << object
 
   end
-
+  
 end

data/spec/unit/inheritance_spec.rb

@@ -3,31 +3,31 @@ require 'spec_helper'
 describe ActiveFedora::Base do
   before(:each) do
     class Foo < ActiveFedora::Base
-      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'foostream' do|m|
-        m.field 'foostream', :string
+      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"foostream" do|m|
+        m.field "foostream", :string
       end
-      has_metadata :type => ActiveFedora::QualifiedDublinCoreDatastream, :name => 'dcstream'
+      has_metadata :type=>ActiveFedora::QualifiedDublinCoreDatastream, :name=>"dcstream" 
     end
-    class Bar < ActiveFedora::Base
-      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'barstream' do |m|
-        m.field 'barfield', :string
+    class Bar  < ActiveFedora::Base
+      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"barstream" do |m|
+        m.field "barfield", :string
       end
     end
   end
 
   it "doesn't overwrite stream specs" do
     f = Foo.new
-    expect(f.datastreams.size).to eq(3)
+    f.datastreams.size.should == 3
     streams = f.datastreams.values.map{|x| x.class.to_s}.sort
-    expect(streams.pop).to eq('ActiveFedora::SimpleDatastream')
-    expect(streams.pop).to eq('ActiveFedora::RelsExtDatastream')
-    expect(streams.pop).to eq('ActiveFedora::QualifiedDublinCoreDatastream')
+    streams.pop.should == "ActiveFedora::SimpleDatastream"
+    streams.pop.should == "ActiveFedora::RelsExtDatastream"
+    streams.pop.should == "ActiveFedora::QualifiedDublinCoreDatastream"
   end
 
-  it 'should work for multiple types' do
+  it "should work for multiple types" do
     b = Foo.new
     f = Bar.new
-    expect(b.class.ds_specs).not_to eq(f.class.ds_specs)
+    b.class.ds_specs.should_not == f.class.ds_specs
   end
   after do
     Object.send(:remove_const, :Bar)
@@ -35,3 +35,4 @@ describe ActiveFedora::Base do
   end
 
 end
+  

data/spec/unit/model_spec.rb

@@ -1,64 +1,58 @@
 require 'spec_helper'
 
-module SpecModelM
-  class Basic < ActiveFedora::Base
-  end
-  class CamelCased
-    include ActiveFedora::Model
-    def name
-      self.class.to_s
+describe ActiveFedora::Model do
+  
+  before(:all) do
+    module SpecModel
+      class Basic < ActiveFedora::Base
+      end
     end
+    @model_query = "has_model_s:#{solr_uri("info:fedora/afmodel:SpecModel_Basic")}"
   end
-end
-
-describe ActiveFedora::Model do
-
+  
+  after(:all) do
+    Object.send(:remove_const, :SpecModel)
+  end
+  
   describe '.solr_query_handler' do
     after do
-      SpecModelM::Basic.solr_query_handler = 'standard' # reset to default
+      # reset to default
+      SpecModel::Basic.solr_query_handler = 'standard'
     end
-    it 'should have a default' do
-      expect(SpecModelM::Basic.solr_query_handler).to eq('standard')
+    it "should have a default" do
+      SpecModel::Basic.solr_query_handler.should == 'standard'
     end
-    it 'should be settable' do
-      SpecModelM::Basic.solr_query_handler = 'search'
-      expect(SpecModelM::Basic.solr_query_handler).to eq('search')
+    it "should be settable" do
+      SpecModel::Basic.solr_query_handler = 'search'
+      SpecModel::Basic.solr_query_handler.should == 'search'
     end
   end
-
-  describe 'URI translation' do
-    before :each do
-      @camel = SpecModelM::CamelCased.new
-    end
-    it '#to_class_uri' do
-      expect(@camel.to_class_uri).to eq 'info:fedora/afmodel:SpecModelM_CamelCased'
-    end
-
-    context 'with the namespace declared in the model' do
-      it '#to_class_uri' do
-        expect(@camel).to receive(:pid_namespace).and_return('test-cModel')
-        expect(@camel.to_class_uri).to eq 'info:fedora/test-cModel:SpecModelM_CamelCased'
+  
+  describe "URI translation" do
+    before :all do
+      module SpecModel
+        class CamelCased
+          include ActiveFedora::Model
+        end
       end
     end
-
-    context 'with the suffix declared in the model' do
-      it '#to_class_uri' do
-        expect(@camel).to receive(:pid_suffix).and_return('-TEST-SUFFIX')
-        expect(@camel.to_class_uri).to eq 'info:fedora/afmodel:SpecModelM_CamelCased-TEST-SUFFIX'
-      end
+    
+    after :all do
+      SpecModel.send(:remove_const, :CamelCased)
     end
-
-    describe '.classname_from_uri' do
-      it 'should turn an afmodel URI into a Model class name' do
-        expect(ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:SpecModelM_CamelCased')).to eq(['SpecModelM::CamelCased', 'afmodel'])
+    subject {SpecModel::CamelCased}
+  
+    describe ".classname_from_uri" do 
+      it "should turn an afmodel URI into a Model class name" do
+        ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:SpecModel_CamelCased').should == ['SpecModel::CamelCased', 'afmodel']
       end
-      it 'should not change plurality' do
-        expect(ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:MyMetadata')).to eq(['MyMetadata', 'afmodel'])
+      it "should not change plurality" do
+        ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:MyMetadata').should == ['MyMetadata', 'afmodel']
       end
-      it 'should capitalize the first letter' do
-        expect(ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:image')).to eq(['Image', 'afmodel'])
+      it "should capitalize the first letter" do
+        ActiveFedora::Model.classname_from_uri('info:fedora/afmodel:image').should == ['Image', 'afmodel']
       end
     end
   end
-
+  
 end

data/spec/unit/nom_datastream_spec.rb

@@ -1,40 +1,40 @@
 require 'spec_helper'
 
 describe ActiveFedora::NomDatastream do
-  describe 'test' do
+  describe "test" do
     subject {
       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
+      end 
 
       MyNomDatastream.from_xml '<root><a>123</a><b><c>asdf</c></b></root>'
     }
 
-    it 'should work' do
-      expect(subject.a).to include('123')
+    it "should work" do
+      subject.a.should include("123")
     end
 
-    it 'should to_solr' do
-      expect(subject.to_solr['a_s']).to include('123')
-      expect(subject.to_solr['b_s']).to include('asdf')
+    it "should to_solr" do
+      subject.to_solr['a_s'].should include('123')
+      subject.to_solr['b_s'].should include('asdf')
     end
 
-    it 'should be a managed datastream' do
-      expect(subject.controlGroup).to eq('M')
+    it "should be a managed datastream" do
+      subject.controlGroup.should == 'M'
     end
   end
 
-  describe 'with options for .set_terminology' do
+  describe "with options for .set_terminology" do
     subject {
       class TerminologyOptions < ActiveFedora::NomDatastream
         set_terminology({
           :namespaces => {
-            'dc' => 'http://purl.org/dc/elements/1.1/',
-            'dcterms' => 'http://purl.org/dc/terms/'
+            '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 }
@@ -53,8 +53,8 @@ describe ActiveFedora::NomDatastream do
       )
     }
 
-    it 'should scope #a attribute to only the dc namespace' do
-      expect(subject.a).to eq(['123'])
+    it "should scope #a attribute to only the dc namespace" do
+      subject.a.should == ["123"]
     end
 
   end

data/spec/unit/ntriples_datastream_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe ActiveFedora::NtriplesRDFDatastream do
-  describe 'an instance with content' do
-    before do
+  describe "an instance with content" do
+    before do 
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates do |map|
           map.created(:in => RDF::DC)
@@ -11,84 +11,84 @@ describe ActiveFedora::NtriplesRDFDatastream do
           map.creator(:in => RDF::DC)
           map.educationLevel(:in => RDF::DC)
           map.based_near(:in => RDF::FOAF)
-          map.related_url(:to => 'seeAlso', :in => RDF::RDFS)
+          map.related_url(:to => "seeAlso", :in => RDF::RDFS)
         end
       end
-      @subject = MyDatastream.new(double('inner object', :pid => 'test:1', :new_record? => true), 'descMetadata')
+      @subject = MyDatastream.new(double('inner object', :pid=>'test:1', :new_record? =>true), 'descMetadata')
       @subject.content = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
     end
     after do
       Object.send(:remove_const, :MyDatastream)
     end
-    it 'should have a subject' do
-      expect(@subject.rdf_subject).to eq('info:fedora/test:1')
+    it "should have a subject" do
+      @subject.rdf_subject.should == "info:fedora/test:1"
     end
-    it 'should have controlGroup' do
-      expect(@subject.controlGroup).to eq('M')
+    it "should have controlGroup" do
+      @subject.controlGroup.should == 'M'
     end
-    it 'should have mimeType' do
-      expect(@subject.mimeType).to eq('text/plain')
+    it "should have mimeType" do
+      @subject.mimeType.should == 'text/plain'
     end
-    it 'should have dsid' do
-      expect(@subject.dsid).to eq('descMetadata')
+    it "should have dsid" do
+      @subject.dsid.should == 'descMetadata'
     end
-    it 'should have fields' do
-      expect(@subject.created).to eq(['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).to eq(['http://google.com/'])
+    it "should have fields" do
+      @subject.created.should == ["2010-12-31"]
+      @subject.title.should == ["Title of work"]
+      @subject.publisher.should == ["Penn State"]
+      @subject.based_near.should == ["New York, NY, US"]
+      @subject.related_url.should == ["http://google.com/"]
     end
 
-    it 'should be 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'])
+    it "should be able to call enumerable methods on the fields" do
+      @subject.title.join(', ').should == "Title of work"
+      @subject.title.count.should == 1 
+      @subject.title.size.should == 1 
+      @subject.title[0].should == "Title of work" 
+      @subject.title.to_a.should == ["Title of work"]
       val = []
       @subject.title.each_with_index {|v, i| val << "#{i}. #{v}"}
-      expect(val).to eq(['0. Title of work'])
+      val.should == ["0. Title of work"]
     end
 
-    it 'should return fields that are not TermProxies' do
-      expect(@subject.created).to be_kind_of Array
+    it "should return fields that are not TermProxies" do
+      @subject.created.should be_kind_of Array
     end
-    it 'should have method missing' do
-      expect{@subject.frank}.to raise_exception NoMethodError
+    it "should have method missing" do
+      lambda{@subject.frank}.should raise_exception NoMethodError
     end
 
-    it 'should set fields' do
+    it "should set fields" do
       @subject.publisher = "St. Martin's Press"
-      expect(@subject.publisher).to eq(["St. Martin's Press"])
+      @subject.publisher.should == ["St. Martin's Press"]
     end
-    it 'should set rdf literal fields' do
-      @subject.creator = RDF.Literal('Geoff Ryman')
-      expect(@subject.creator).to eq(['Geoff Ryman'])
+    it "should set rdf literal fields" do
+      @subject.creator = RDF.Literal("Geoff Ryman")
+      @subject.creator.should == ["Geoff Ryman"]
     end
-    it 'should append fields' do
+    it "should append fields" do
       @subject.publisher << "St. Martin's Press"
-      expect(@subject.publisher).to eq(['Penn State', "St. Martin's Press"])
+      @subject.publisher.should == ["Penn State", "St. Martin's Press"]
     end
-    it 'should delete fields' do
-      @subject.related_url.delete(RDF::URI('http://google.com/'))
-      expect(@subject.related_url).to eq([])
+    it "should delete fields" do
+      @subject.related_url.delete(RDF::URI("http://google.com/"))
+      @subject.related_url.should == []
     end
   end
 
-  describe 'some dummy instances' do
+  describe "some dummy instances" do
     before do
       @one = ActiveFedora::RDFDatastream.new('fakepid', 'myFoobar')
       @two = ActiveFedora::RDFDatastream.new('fakepid', 'myQuix')
     end
-    it 'should generate predictable prexies' do
-      expect(@one .prefix('baz')).to eq(:my_foobar__baz)
-      expect(@two.prefix('baz')).to eq(:my_quix__baz)
+    it "should generate predictable prexies" do
+      @one .prefix("baz").should == :my_foobar__baz
+      @two.prefix("baz").should == :my_quix__baz
     end
   end
 
-  describe 'an instance with a custom subject' do
-    before do
+  describe "an instance with a custom subject" do
+    before do 
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         rdf_subject { |ds| "info:fedora/#{ds.pid}/content" }
         map_predicates do |map|
@@ -96,7 +96,7 @@ describe ActiveFedora::NtriplesRDFDatastream do
           map.title(:in => RDF::DC)
           map.publisher(:in => RDF::DC)
           map.based_near(:in => RDF::FOAF)
-          map.related_url(:to => 'seeAlso', :in => RDF::RDFS)
+          map.related_url(:to => "seeAlso", :in => RDF::RDFS)
         end
       end
       @subject = MyDatastream.new(@inner_object, 'mixed_rdf')
@@ -109,16 +109,16 @@ describe ActiveFedora::NtriplesRDFDatastream do
       Object.send(:remove_const, :MyDatastream)
     end
 
-    it 'should have fields' do
-      expect(@subject.title).to eq(['Title of datastream'])
+    it "should have fields" do
+      @subject.title.should == ["Title of datastream"]
     end
 
-    it 'should have a custom subject' do
-      expect(@subject.rdf_subject).to eq('info:fedora/test:1/content')
+    it "should have a custom subject" do
+      @subject.rdf_subject.should == 'info:fedora/test:1/content'
     end
   end
 
-  describe 'a new instance' do
+  describe "a new instance" do
     before(:each) do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates do |map|
@@ -131,35 +131,35 @@ describe ActiveFedora::NtriplesRDFDatastream do
     after(:each) do
       Object.send(:remove_const, :MyDatastream)
     end
-    it 'should support 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)
+    it "should support to_s method" do
+      @subject.publisher.to_s.should == [].to_s
+      @subject.publisher = "Bob"
+      @subject.publisher.to_s.should == ["Bob"].to_s
+      @subject.publisher << "Jim"
+      @subject.publisher.to_s.should == ["Bob", "Jim"].to_s
     end
  end
 
-  describe 'solr integration' do
+  describe "solr integration" do
     before(:all) do
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates do |map|
-          map.created(:in => RDF::DC) do |index|
+          map.created(:in => RDF::DC) do |index| 
             index.as :sortable, :displayable
             index.type :date
           end
           map.title(:in => RDF::DC) do |index|
             index.as :stored_searchable, :sortable
-            index.type :text
+            index.type :text 
           end
-          map.publisher(:in => RDF::DC) do |index|
+          map.publisher(:in => RDF::DC) do |index| 
             index.as :facetable, :sortable, :stored_searchable
           end
           map.based_near(:in => RDF::FOAF) do |index|
-            index.as :facetable, :stored_searchable
+            index.as :facetable, :stored_searchable 
             index.type :text
           end
-          map.related_url(:to => 'seeAlso', :in => RDF::RDFS) do |index|
+          map.related_url(:to => "seeAlso", :in => RDF::RDFS) do |index|
             index.as :stored_searchable
           end
           map.rights(:in => RDF::DC)
@@ -171,88 +171,93 @@ describe ActiveFedora::NtriplesRDFDatastream do
     after(:all) do
       Object.send(:remove_const, :MyDatastream)
     end
-    before(:each) do
+    before(:each) do  
       @subject.stub(:pid => 'test:1')
     end
-    it 'should provide .to_solr and return a SolrDocument' do
-      expect(@subject).to respond_to(:to_solr)
-      expect(@subject.to_solr).to be_kind_of(Hash)
+    it "should provide .to_solr and return a SolrDocument" do
+      @subject.should respond_to(:to_solr)
+      @subject.to_solr.should be_kind_of(Hash)
     end
-    it 'should optionally allow 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)
+
+    it "should have a solr_name method" do
+      expect(MyDatastream.primary_solr_name('descMetadata', :based_near)).to eq 'desc_metadata__based_near_sim'
+      expect(MyDatastream.primary_solr_name('props', :title)).to eq 'props__title_tesim'
     end
-    it 'should iterate through @fields hash' do
+
+    it "should optionally allow you to provide the Solr::Document to add fields to and return that document when done" do
+      doc = Hash.new
+      @subject.to_solr(doc).should == doc
+    end
+    it "should iterate through @fields hash" do
       solr_doc = @subject.to_solr
-      expect(solr_doc[ActiveFedora::SolrService.solr_name('solr_rdf__publisher', type: :string)]).to eq(['publisher1'])
-      expect(solr_doc[ActiveFedora::SolrService.solr_name('solr_rdf__publisher', :sortable)]).to eq('publisher1')
-      expect(solr_doc[ActiveFedora::SolrService.solr_name('solr_rdf__publisher', :facetable)]).to eq(['publisher1'])
-      expect(solr_doc[ActiveFedora::SolrService.solr_name('solr_rdf__based_near', type: :string)]).to eq(['coverage1', 'coverage2'])
-      expect(solr_doc[ActiveFedora::SolrService.solr_name('solr_rdf__based_near', :facetable)]).to eq(['coverage1', 'coverage2'])
-      expect(solr_doc[ActiveFedora::SolrService.solr_name('solr_rdf__created', :sortable, type: :date)]).to eq('2009-10-10T00:00:00Z')
-      expect(solr_doc[ActiveFedora::SolrService.solr_name('solr_rdf__created', :displayable)]).to eq(['2009-10-10'])
-      expect(solr_doc[ActiveFedora::SolrService.solr_name('solr_rdf__title', type: :string)]).to eq(['fake-title'])
-      expect(solr_doc[ActiveFedora::SolrService.solr_name('solr_rdf__title', :sortable)]).to eq('fake-title')
-      expect(solr_doc[ActiveFedora::SolrService.solr_name('solr_rdf__related_url', type: :string)]).to eq(['http://example.org/'])
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", type: :string)].should == ["publisher1"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :sortable)].should == "publisher1"
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :facetable)].should == ["publisher1"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", type: :string)].should == ["coverage1", "coverage2"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", :facetable)].should == ["coverage1", "coverage2"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__created", :sortable, type: :date)].should == "2009-10-10T00:00:00Z"
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__created", :displayable)].should == ["2009-10-10"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__title", type: :string)].should == ["fake-title"]
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__title", :sortable)].should == "fake-title"
+      solr_doc[ActiveFedora::SolrService.solr_name("solr_rdf__related_url", type: :string)].should == ["http://example.org/"]
     end
 
-    describe 'with an actual object' do
+    describe "with an actual object" do
       before(:each) do
         class Foo < ActiveFedora::Base
-          has_metadata :name => 'descMetadata', :type => MyDatastream
-          delegate :created, :to => :descMetadata, multiple: true
-          delegate :title, :to => :descMetadata, multiple: true
-          delegate :publisher, :to => :descMetadata, multiple: true
-          delegate :based_near, :to => :descMetadata, multiple: true
-          delegate :related_url, :to => :descMetadata, multiple: true
-          delegate :rights, :to => :descMetadata, multiple: true
+          has_metadata :name => "descMetadata", :type => MyDatastream
+          has_attributes :created, :title, :publisher, :based_near, :related_url, :rights, datastream: :descMetadata, multiple: true
         end
         @obj = MyDatastream.new(@inner_object, 'solr_rdf')
         repository = double()
           @obj.stub(:repository => repository, :pid => 'test:1')
-          allow(repository).to receive(:modify_datastream)
-          allow(repository).to receive(:add_datastream)
-        @obj.created = '2012-03-04'
-        @obj.title = 'Of Mice and Men, The Sequel'
+          repository.stub(:modify_datastream)
+          repository.stub(:add_datastream)
+        @obj.created = "2012-03-04"
+        @obj.title = "Of Mice and Men, The Sequel"
         @obj.publisher = "Bob's Blogtastic Publishing"
-        @obj.based_near = ['Tacoma, WA', 'Renton, WA']
-        @obj.related_url = 'http://example.org/blogtastic/'
+        @obj.based_near = ["Tacoma, WA", "Renton, WA"]
+        @obj.related_url = "http://example.org/blogtastic/"
         @obj.rights = "Totally open, y'all"
         @obj.save
       end
+      after do
+        Object.send(:remove_const, :Foo)
+      end
+
 
-      describe '.fields()' do
-        it 'should return the right fields' do
-          expect(@obj.send(:fields).keys).to eq(['created', 'title', 'publisher', 'based_near', 'related_url'])
+      describe ".fields()" do
+        it "should return the right fields" do
+          @obj.send(:fields).keys.should == ["created", "title", "publisher", "based_near", "related_url"]
         end
-        it 'should return the right values' do
+        it "should return the right values" do
           fields = @obj.send(:fields)
-          expect(fields[:related_url][:values]).to eq(['http://example.org/blogtastic/'])
-          expect(fields[:based_near][:values]).to eq(['Tacoma, WA', 'Renton, WA'])
+          fields[:related_url][:values].should == ["http://example.org/blogtastic/"]
+          fields[:based_near][:values].should == ["Tacoma, WA", "Renton, WA"]
         end
-        it 'should return the right type information' do
+        it "should return the right type information" do
           fields = @obj.send(:fields)
-          expect(fields[:created][:type]).to eq(:date)
+          fields[:created][:type].should == :date
         end
       end
-      describe '.to_solr()' do
-        it 'should return the right fields' do
-          expect(@obj.to_solr.keys).to include(ActiveFedora::SolrService.solr_name('solr_rdf__related_url', type: :string),
-                ActiveFedora::SolrService.solr_name('solr_rdf__publisher', type: :string),
-                ActiveFedora::SolrService.solr_name('solr_rdf__publisher', :sortable),
-                ActiveFedora::SolrService.solr_name('solr_rdf__publisher', :facetable),
-                ActiveFedora::SolrService.solr_name('solr_rdf__created', :sortable, type: :date),
-                ActiveFedora::SolrService.solr_name('solr_rdf__created', :displayable),
-                ActiveFedora::SolrService.solr_name('solr_rdf__title', type: :string),
-                ActiveFedora::SolrService.solr_name('solr_rdf__title', :sortable),
-                ActiveFedora::SolrService.solr_name('solr_rdf__based_near', type: :string),
-                ActiveFedora::SolrService.solr_name('solr_rdf__based_near', :facetable))
+      describe ".to_solr()" do
+        it "should return the right fields" do
+          @obj.to_solr.keys.should include(ActiveFedora::SolrService.solr_name("solr_rdf__related_url", type: :string),
+                ActiveFedora::SolrService.solr_name("solr_rdf__publisher", type: :string),
+                ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :sortable),
+                ActiveFedora::SolrService.solr_name("solr_rdf__publisher", :facetable), 
+                ActiveFedora::SolrService.solr_name("solr_rdf__created", :sortable, type: :date),
+                ActiveFedora::SolrService.solr_name("solr_rdf__created", :displayable), 
+                ActiveFedora::SolrService.solr_name("solr_rdf__title", type: :string),
+                ActiveFedora::SolrService.solr_name("solr_rdf__title", :sortable),
+                ActiveFedora::SolrService.solr_name("solr_rdf__based_near", type: :string),
+                ActiveFedora::SolrService.solr_name("solr_rdf__based_near", :facetable))
 
         end
 
-        it 'should return the right values' do
-          expect(@obj.to_solr[ActiveFedora::SolrService.solr_name('solr_rdf__related_url', type: :string)]).to eq(['http://example.org/blogtastic/'])
-          expect(@obj.to_solr[ActiveFedora::SolrService.solr_name('solr_rdf__based_near', type: :string)]).to eq(['Tacoma, WA', 'Renton, WA'])
+        it "should return the right values" do
+          @obj.to_solr[ActiveFedora::SolrService.solr_name("solr_rdf__related_url", type: :string)].should == ["http://example.org/blogtastic/"]
+          @obj.to_solr[ActiveFedora::SolrService.solr_name("solr_rdf__based_near", type: :string)].should == ["Tacoma, WA","Renton, WA"]
         end
       end
     end