active-fedora 6.7.8 → 6.8.0

data/spec/unit/association_proxy_spec.rb

@@ -1,14 +1,12 @@
 require 'spec_helper'
 
 describe ActiveFedora::Associations::AssociationProxy do
-  it "should delegate to_param" do
-  	pending
-    @owner = stub(:new_record? => false)
+  it 'should delegate to_param' do
+    skip
+    @owner = double(:new_record? => false)
     @assoc = ActiveFedora::Associations::AssociationProxy.new(@owner, @reflection)
-    @assoc.should_receive(:find_target).and_return(stub(:to_param => '1234'))
+    expect(@assoc).to receive(:find_target).and_return(double(:to_param => '1234'))
     @assoc.send(:load_target)
-    @assoc.to_param.should == '1234'
-  
+    expect(@assoc.to_param).to eq('1234')
   end
-
 end

data/spec/unit/base_active_model_spec.rb

@@ -1,54 +1,54 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
-  describe "active model methods" do 
-    class BarStream < ActiveFedora::OmDatastream 
+  describe 'active model methods' do
+    class BarStream < ActiveFedora::OmDatastream
       set_terminology do |t|
-        t.root(:path=>"first", :xmlns=>"urn:foobar")
+        t.root(:path => 'first', :xmlns => 'urn:foobar')
         t.duck()
       end
 
       def self.xml_template
-            Nokogiri::XML::Document.parse '<first xmlns="urn:foobar"> 
+            Nokogiri::XML::Document.parse '<first xmlns="urn:foobar">
               <duck></duck>
             </first>'
       end
     end
 
     class BarHistory < ActiveFedora::Base
-      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData" do |m|
-        m.field "fubar", :string
-        m.field "swank", :text
+      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'someData' do |m|
+        m.field 'fubar', :string
+        m.field 'swank', :text
       end
-      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText" do |m|
-        m.field "fubar", :text
+      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'withText' do |m|
+        m.field 'fubar', :text
+      end
+      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'withText2', :label => 'withLabel' do |m|
+        m.field 'fubar', :text
       end
-      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText2", :label=>"withLabel" do |m|
-        m.field "fubar", :text
-      end 
 
-      has_metadata :type=>BarStream, :name=>"xmlish"
+      has_metadata :type => BarStream, :name => 'xmlish'
       delegate :fubar, to: 'withText', multiple: false
       delegate :duck, to: 'xmlish', multiple: false
     end
     before :each do
       @n = BarHistory.new()
     end
-    describe "attributes=" do
-      it "should set attributes" do
-        @n.attributes = {:fubar=>"baz", :duck=>"Quack"}
-        @n.fubar.should == "baz"
-        @n.withText.get_values(:fubar).first.should == 'baz'
-        @n.duck.should == "Quack"
-        @n.xmlish.term_values(:duck).first.should == 'Quack'
+    describe 'attributes=' do
+      it 'should set attributes' do
+        @n.attributes = {:fubar => 'baz', :duck => 'Quack'}
+        expect(@n.fubar).to eq('baz')
+        expect(@n.withText.get_values(:fubar).first).to eq('baz')
+        expect(@n.duck).to eq('Quack')
+        expect(@n.xmlish.term_values(:duck).first).to eq('Quack')
       end
     end
-    describe "update_attributes" do
-      it "should set attributes and save " do
-        @n.update_attributes(:fubar=>"baz", :duck=>"Quack")
+    describe 'update_attributes' do
+      it 'should set attributes and save ' do
+        @n.update_attributes(:fubar => 'baz', :duck => 'Quack')
         @q = BarHistory.find(@n.pid)
-        @q.fubar.should == "baz"
-        @q.duck.should == "Quack"
+        expect(@q.fubar).to eq('baz')
+        expect(@q.duck).to eq('Quack')
       end
       after do
         @n.delete
@@ -57,4 +57,3 @@ describe ActiveFedora::Base do
 
   end
 end
-

data/spec/unit/base_cma_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
-  
+
   before(:each) do
     @test_object = ActiveFedora::Base.new
   end
-  
+
   describe '.save' do
 
-    it "should add hasModel relationship that points to the CModel if @new_object" do
-      @test_object.stub(:update_index)
-      @test_object.should_receive(:refresh)
+    it 'should add hasModel relationship that points to the CModel if @new_object' do
+      allow(@test_object).to receive(:update_index)
+      expect(@test_object).to receive(:refresh)
       @test_object.save
     end
   end

data/spec/unit/base_datastream_management_spec.rb

@@ -1,57 +1,57 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
-  
+
   before(:each) do
     @test_object = ActiveFedora::Base.new
   end
-  
+
   describe '.generate_dsid' do
-    it "should return a dsid that is not currently in use" do
-      dsids = Hash["DS1"=>1, "DS2"=>1]
-      @test_object.should_receive(:datastreams).and_return(dsids)
+    it 'should return a dsid that is not currently in use' do
+      dsids = Hash['DS1' => 1, 'DS2' => 1]
+      expect(@test_object).to receive(:datastreams).and_return(dsids)
       generated_id = @test_object.generate_dsid
-      generated_id.should_not be_nil
-      generated_id.should == "DS3"
+      expect(generated_id).not_to be_nil
+      expect(generated_id).to eq('DS3')
     end
-    it "should accept a prefix argument, default to using DS as prefix" do
-      @test_object.generate_dsid("FOO").should == "FOO1"  
+    it 'should accept a prefix argument, default to using DS as prefix' do
+      expect(@test_object.generate_dsid('FOO')).to eq('FOO1')
     end
 
-    it "if delete a datastream it should still use next index for a prefix" do
-      dsids = Hash["DS2"=>1]
-      @test_object.should_receive(:datastreams).and_return(dsids)
+    it 'if delete a datastream it should still use next index for a prefix' do
+      dsids = Hash['DS2' => 1]
+      expect(@test_object).to receive(:datastreams).and_return(dsids)
       generated_id = @test_object.generate_dsid
-      generated_id.should_not be_nil
-      generated_id.should == "DS3"
+      expect(generated_id).not_to be_nil
+      expect(generated_id).to eq('DS3')
     end
   end
   describe '.add_datastream' do
-    it "should not call Datastream.save" do
+    it 'should not call Datastream.save' do
       ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'ds_to_add')
-      ds.should_receive(:save).never
+      expect(ds).to receive(:save).never
       @test_object.add_datastream(ds)
     end
-    it "should add the datastream to the datastreams_in_memory array" do
+    it 'should add the datastream to the datastreams_in_memory array' do
       ds = ActiveFedora::Datastream.new(@test_object.inner_object, 'ds_to_add')
-      @test_object.datastreams.should_not have_key(ds.dsid)
+      expect(@test_object.datastreams).not_to have_key(ds.dsid)
       @test_object.add_datastream(ds)
-      @test_object.datastreams.should have_key(ds.dsid)
+      expect(@test_object.datastreams).to have_key(ds.dsid)
     end
-    it "should auto-assign dsids using auto-incremented integers if dsid is nil or an empty string" do 
+    it 'should auto-assign dsids using auto-incremented integers if dsid is nil or an empty string' do
       ds = ActiveFedora::Datastream.new(@test_object.inner_object, nil)
-      ds.dsid.should == nil
+      expect(ds.dsid).to be_nil
       ds_emptystringid = ActiveFedora::Datastream.new(@test_object.inner_object, '')
       @test_object.stub(:generate_dsid => 'foo')
      # ds.should_receive(:dsid=).with("foo")
-      @test_object.add_datastream(ds).should == 'foo'
-      @test_object.add_datastream(ds_emptystringid).should == 'foo'
+      expect(@test_object.add_datastream(ds)).to eq('foo')
+      expect(@test_object.add_datastream(ds_emptystringid)).to eq('foo')
     end
-    it "should accept a prefix option and apply it to automatically assigned dsids" do
+    it 'should accept a prefix option and apply it to automatically assigned dsids' do
       ds = ActiveFedora::Datastream.new(@test_object.inner_object, nil)
-      ds.dsid.should == nil
-      @test_object.stub(:generate_dsid => "FOO")
-      @test_object.add_datastream(ds, :prefix => "FOO").should == 'FOO'
+      expect(ds.dsid).to be_nil
+      @test_object.stub(:generate_dsid => 'FOO')
+      expect(@test_object.add_datastream(ds, :prefix => 'FOO')).to eq('FOO')
     end
   end
 end

data/spec/unit/base_delegate_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe ActiveFedora::Base do
   before :all do
-      class BarStream2 < ActiveFedora::OmDatastream 
+      class BarStream2 < ActiveFedora::OmDatastream
         set_terminology do |t|
-          t.root(:path=>"animals", :xmlns=>"urn:zoobar")
+          t.root(:path => 'animals', :xmlns => 'urn:zoobar')
           t.waterfowl do
-            t.ducks do 
+            t.ducks do
               t.duck
             end
           end
@@ -17,7 +17,7 @@ describe ActiveFedora::Base do
         end
 
         def self.xml_template
-              Nokogiri::XML::Document.parse '<animals xmlns="urn:zoobar"> 
+              Nokogiri::XML::Document.parse '<animals xmlns="urn:zoobar">
                 <waterfowl>
                   <ducks>
                     <duck/>
@@ -33,28 +33,28 @@ describe ActiveFedora::Base do
     Object.send(:remove_const, :BarStream2)
   end
 
-  describe "first level delegation" do 
+  describe 'first level delegation' do
     before :all do
       class BarHistory2 < ActiveFedora::Base
-        has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData" do |m|
-          m.field "fubar", :string
-          m.field "bandana", :string
-          m.field "swank", :text
+        has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'someData' do |m|
+          m.field 'fubar', :string
+          m.field 'bandana', :string
+          m.field 'swank', :text
         end
-        has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText" do |m|
-          m.field "fubar", :text
+        has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'withText' do |m|
+          m.field 'fubar', :text
         end
-        has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"withText2", :label=>"withLabel" do |m|
-          m.field "fubar", :text
-        end 
-
-        has_metadata :type=>BarStream2, :name=>"xmlish"
-        delegate :fubar, :to=>'withText', :unique=>true
-        delegate :donkey, :to=>'xmlish', :unique=>true
-        delegate :cow, :to=>'xmlish'  # for testing the default value of multiple
-        delegate :pig, :to=>'xmlish', multiple: false
-        delegate :horse, :to=>'xmlish', multiple: true
-        delegate :duck, :to=>'xmlish', :at=>[:waterfowl, :ducks], multiple: true
+        has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'withText2', :label => 'withLabel' do |m|
+          m.field 'fubar', :text
+        end
+
+        has_metadata :type => BarStream2, :name => 'xmlish'
+        delegate :fubar, :to => 'withText', :unique => true
+        delegate :donkey, :to => 'xmlish', :unique => true
+        delegate :cow, :to => 'xmlish'  # for testing the default value of multiple
+        delegate :pig, :to => 'xmlish', multiple: false
+        delegate :horse, :to => 'xmlish', multiple: true
+        delegate :duck, :to => 'xmlish', :at => [:waterfowl, :ducks], multiple: true
       end
     end
 
@@ -64,58 +64,58 @@ describe ActiveFedora::Base do
 
     subject { BarHistory2.new() }
 
-    it "should reveal the unique properties" do
-      BarHistory2.unique?(:fubar).should be_true
-      BarHistory2.unique?(:cow).should be_false
+    it 'should reveal the unique properties' do
+      expect(BarHistory2.unique?(:fubar)).to be_truthy
+      expect(BarHistory2.unique?(:cow)).to be_falsey
     end
 
-    it "should save a delegated property uniquely" do
-      subject.fubar="Quack"
-      subject.fubar.should == "Quack"
-      subject.withText.get_values(:fubar).first.should == 'Quack'
-      subject.donkey="Bray"
-      subject.donkey.should == "Bray"
-      subject.xmlish.term_values(:donkey).first.should == 'Bray'
+    it 'should save a delegated property uniquely' do
+      subject.fubar = 'Quack'
+      expect(subject.fubar).to eq('Quack')
+      expect(subject.withText.get_values(:fubar).first).to eq('Quack')
+      subject.donkey = 'Bray'
+      expect(subject.donkey).to eq('Bray')
+      expect(subject.xmlish.term_values(:donkey).first).to eq('Bray')
 
-      subject.pig="Oink"
-      subject.pig.should == "Oink"
+      subject.pig = 'Oink'
+      expect(subject.pig).to eq('Oink')
     end
 
-    it "should allow passing parameters to the delegate accessor" do
-      subject.cow=["one", "two"]
-      subject.cow(1).should == ['two']
+    it 'should allow passing parameters to the delegate accessor' do
+      subject.cow = ['one', 'two']
+      expect(subject.cow(1)).to eq(['two'])
     end
 
 
-    it "should return an array if not marked as unique" do
+    it 'should return an array if not marked as unique' do
       ### Metadata datastream does not appear to support multiple value setting
-      subject.cow=["one", "two"]
-      subject.cow.should == ["one", "two"]
+      subject.cow = ['one', 'two']
+      expect(subject.cow).to eq(['one', 'two'])
 
-      subject.horse=["neigh", "whinny"]
-      subject.horse.should == ["neigh", "whinny"]
+      subject.horse = ['neigh', 'whinny']
+      expect(subject.horse).to eq(['neigh', 'whinny'])
     end
 
-    it "should be able to delegate deeply into the terminology" do
-      subject.duck=["Quack", "Peep"]
-      subject.duck.should == ["Quack", "Peep"]
+    it 'should be able to delegate deeply into the terminology' do
+      subject.duck = ['Quack', 'Peep']
+      expect(subject.duck).to eq(['Quack', 'Peep'])
     end
 
-    it "should be able to track change status" do
-      subject.fubar_changed?.should be_false
-      subject.fubar = "Meow"
-      subject.fubar_changed?.should be_true
+    it 'should be able to track change status' do
+      expect(subject.fubar_changed?).to be_falsey
+      subject.fubar = 'Meow'
+      expect(subject.fubar_changed?).to be_truthy
     end
 
-    describe "array getters and setters" do
-      it "should accept symbol keys" do
-        subject[:duck]= ["Cluck", "Gobble"]
-        subject[:duck].should == ["Cluck", "Gobble"]
+    describe 'array getters and setters' do
+      it 'should accept symbol keys' do
+        subject[:duck] = ['Cluck', 'Gobble']
+        expect(subject[:duck]).to eq(['Cluck', 'Gobble'])
       end
 
-      it "should accept string keys" do
-        subject['duck']= ["Cluck", "Gobble"]
-        subject['duck'].should == ["Cluck", "Gobble"]
+      it 'should accept string keys' do
+        subject['duck'] = ['Cluck', 'Gobble']
+        expect(subject['duck']).to eq(['Cluck', 'Gobble'])
       end
 
       it "should raise an error on the reader when the field isn't delegated" do
@@ -123,16 +123,16 @@ describe ActiveFedora::Base do
       end
 
       it "should raise an error on the setter when the field isn't delegated" do
-        expect {subject['goose']="honk" }.to raise_error ActiveFedora::UnknownAttributeError, "BarHistory2 does not have an attribute `goose'"
+        expect {subject['goose'] = 'honk' }.to raise_error ActiveFedora::UnknownAttributeError, "BarHistory2 does not have an attribute `goose'"
       end
     end
 
   end
 
-  describe "with a superclass" do
+  describe 'with a superclass' do
     before :all do
       class BarHistory2 < ActiveFedora::Base
-        has_metadata 'xmlish', :type=>BarStream2
+        has_metadata 'xmlish', :type => BarStream2
         delegate_to 'xmlish', [:donkey, :cow], multiple: true
       end
       class BarHistory3 < BarHistory2
@@ -146,19 +146,19 @@ describe ActiveFedora::Base do
 
     subject { BarHistory3.new }
 
-    it "should be able to delegate deeply into the terminology" do
-      subject.donkey=["Bray", "Hee-haw"]
-      subject.donkey.should == ["Bray", "Hee-haw"]
+    it 'should be able to delegate deeply into the terminology' do
+      subject.donkey = ['Bray', 'Hee-haw']
+      expect(subject.donkey).to eq(['Bray', 'Hee-haw'])
     end
 
-    it "should be able to track change status" do
-      subject.cow_changed?.should be_false
-      subject.cow = ["Moo"]
-      subject.cow_changed?.should be_true
-    end 
+    it 'should be able to track change status' do
+      expect(subject.cow_changed?).to be_falsey
+      subject.cow = ['Moo']
+      expect(subject.cow_changed?).to be_truthy
+    end
   end
 
-  describe "with a RDF datastream" do
+  describe 'with a RDF datastream' do
     before :all do
       class BarRdfDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates do |map|
@@ -167,7 +167,7 @@ describe ActiveFedora::Base do
         end
       end
       class BarHistory4 < ActiveFedora::Base
-        has_metadata 'rdfish', :type=>BarRdfDatastream
+        has_metadata 'rdfish', :type => BarRdfDatastream
         delegate_to 'rdfish', [:title, :description], multiple: true
       end
     end
@@ -179,21 +179,19 @@ describe ActiveFedora::Base do
 
     subject { BarHistory4.new }
 
-    describe "with a multivalued field" do
-      it "should be able to track change status" do
-        subject.title_changed?.should be_false
-        subject.title = ["Title1", "Title2"]
-        subject.title_changed?.should be_true
+    describe 'with a multivalued field' do
+      it 'should be able to track change status' do
+        expect(subject.title_changed?).to be_falsey
+        subject.title = ['Title1', 'Title2']
+        expect(subject.title_changed?).to be_truthy
       end
     end
-    describe "with a single-valued field" do
-      it "should be able to track change status" do
-        subject.description_changed?.should be_false
-        subject.description = "A brief description"
-        subject.description_changed?.should be_true
+    describe 'with a single-valued field' do
+      it 'should be able to track change status' do
+        expect(subject.description_changed?).to be_falsey
+        subject.description = 'A brief description'
+        expect(subject.description_changed?).to be_truthy
       end
     end
-  end 
+  end
 end
-
-