active-fedora 6.8.0 → 7.0.0.pre1

data/spec/unit/datastream_spec.rb

@@ -1,28 +1,22 @@
 require 'spec_helper'
 
-require 'active_fedora'
-require 'nokogiri'
-
 describe ActiveFedora::Datastream do
-
+  
   before(:each) do
     @test_object = ActiveFedora::Base.new
     @test_datastream = ActiveFedora::Datastream.new(@test_object.inner_object, 'abcd')
-    @test_datastream.content = 'hi there'
+    @test_datastream.content = "hi there"
   end
 
-  describe '#metadata?' do
-    subject { super().metadata? }
-    it { is_expected.to be_falsey}
-  end
+  its(:metadata?) { should be_false}
 
-  it 'should escape dots in  to_param' do
-    allow(@test_datastream).to receive(:dsid).and_return('foo.bar')
-    expect(@test_datastream.to_param).to eq('foo%2ebar')
+  it "should escape dots in  to_param" do
+    @test_datastream.stub(:dsid).and_return('foo.bar')
+    @test_datastream.to_param.should == 'foo%2ebar'
   end
-
-  it 'should be inspectable' do
-    expect(@test_datastream.inspect).to match /#<ActiveFedora::Datastream @pid=\"\" @dsid=\"abcd\" @controlGroup=\"M\" changed=\"true\" @mimeType=\"\" >/
+  
+  it "should be inspectable" do
+    @test_datastream.inspect.should match /#<ActiveFedora::Datastream @pid=\"\" @dsid=\"abcd\" @controlGroup=\"M\" changed=\"true\" @mimeType=\"\" >/
   end
 
   describe '#validate_content_present' do
@@ -31,65 +25,59 @@ describe ActiveFedora::Datastream do
       @test_datastream.dsLocation = nil
     end
 
-    it 'should expect content on an Inline (X) datastream' do
+    it "should expect content on an Inline (X) datastream" do
       @test_datastream.controlGroup = 'X'
-      @test_datastream.dsLocation = 'http://example.com/test/content/abcd'
-      expect(@test_datastream.validate_content_present).to be_falsey
-      @test_datastream.content = '<foo><xmlelement/></foo>'
-      expect(@test_datastream.validate_content_present).to be_truthy
+      @test_datastream.dsLocation = "http://example.com/test/content/abcd"
+      @test_datastream.validate_content_present.should be_false
+      @test_datastream.content = "<foo><xmlelement/></foo>"
+      @test_datastream.validate_content_present.should be_true
     end
 
-    context 'on a Managed (M) datastream' do
-      before { @test_datastream.controlGroup = 'M' }
-      it 'should be false when neither dsLocation nor content is present' do
-        expect(@test_datastream.validate_content_present).to be_falsey
-      end
-      it 'should be true when dsLocation is present' do
-        @test_datastream.dsLocation = 'http://example.com/test/content/abcd'
-        expect(@test_datastream.validate_content_present).to be_truthy
-      end
-      it 'should be true when content is present' do
-        @test_datastream.content = '<foo><xmlelement/></foo>'
-        expect(@test_datastream.validate_content_present).to be_truthy
-      end
+    it "should expect content on a Managed (M) datastream" do
+      @test_datastream.controlGroup = 'M'
+      @test_datastream.dsLocation = "http://example.com/test/content/abcd"
+      @test_datastream.validate_content_present.should be_false
+      @test_datastream.content = "<foo><xmlelement/></foo>"
+      @test_datastream.validate_content_present.should be_true
+      @test_datastream.should_not be_external
     end
 
-    it 'should expect a dsLocation on an External (E) datastream' do
+    it "should expect a dsLocation on an External (E) datastream" do
       @test_datastream.controlGroup = 'E'
-      @test_datastream.content = '<foo><xmlelement/></foo>'
-      expect(@test_datastream.validate_content_present).to be_falsey
-      @test_datastream.dsLocation = 'http://example.com/test/content/abcd'
-      expect(@test_datastream.validate_content_present).to be_truthy
-      expect(@test_datastream).to be_external
+      @test_datastream.content = "<foo><xmlelement/></foo>"
+      @test_datastream.validate_content_present.should be_false
+      @test_datastream.dsLocation = "http://example.com/test/content/abcd"
+      @test_datastream.validate_content_present.should be_true
+      @test_datastream.should be_external
     end
 
-    it 'should expect a dsLocation on a Redirect (R) datastream' do
+    it "should expect a dsLocation on a Redirect (R) datastream" do
       @test_datastream.controlGroup = 'R'
-      @test_datastream.content = '<foo><xmlelement/></foo>'
-      expect(@test_datastream.validate_content_present).to be_falsey
-      @test_datastream.dsLocation = 'http://example.com/test/content/abcd'
-      expect(@test_datastream.validate_content_present).to be_truthy
+      @test_datastream.content = "<foo><xmlelement/></foo>"
+      @test_datastream.validate_content_present.should be_false
+      @test_datastream.dsLocation = "http://example.com/test/content/abcd"
+      @test_datastream.validate_content_present.should be_true
     end
   end
-
-  it 'should have mimeType accessors' do
+  
+  it "should have mimeType accessors" do
     ds1 = ActiveFedora::Datastream.new
-    ds1.mimeType = 'text/foo'
-    expect(ds1.mimeType).to eq('text/foo')
+    ds1.mimeType = "text/foo"
+    ds1.mimeType.should == "text/foo"
     ds2 = ActiveFedora::Datastream.new
-    ds2.mimeType = 'text/bar'
-    expect(ds2.mimeType).to eq('text/bar')
+    ds2.mimeType = "text/bar"
+    ds2.mimeType.should == "text/bar"
   end
 
-  describe '.size' do
-    it 'should lazily load the datastream size attribute from the fedora repository' do
+  describe ".size" do
+    it "should lazily load the datastream size attribute from the fedora repository" do
       ds_profile = <<-EOS
-        <datastreamProfile
-            xmlns=\"http://www.fedora.info/definitions/1/0/management/\"
-            xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"
-            xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"
-            xsi:schemaLocation=\"http://www.fedora.info/definitions/1/0/management/ http://www.fedora.info/definitions/1/0/datastreamProfile.xsd\"
-            pid=\"#{@test_object.pid}\"
+        <datastreamProfile 
+            xmlns=\"http://www.fedora.info/definitions/1/0/management/\"  
+            xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" 
+            xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" 
+            xsi:schemaLocation=\"http://www.fedora.info/definitions/1/0/management/ http://www.fedora.info/definitions/1/0/datastreamProfile.xsd\" 
+            pid=\"#{@test_object.pid}\" 
             dsID=\"#{@test_datastream.dsid}\" >
          <dsLabel></dsLabel>
          <dsVersionID>#{@test_datastream.dsid}.1</dsVersionID>
@@ -109,13 +97,13 @@ describe ActiveFedora::Datastream do
       EOS
 
       mock_repo = Rubydora::Repository.new
-      allow(@test_object.inner_object).to receive(:repository).and_return(mock_repo)
-      expect(mock_repo.api).to receive(:datastream).with(:dsid => 'abcd', :pid => @test_object.pid).and_return(ds_profile)
-      expect(@test_datastream.size).to eq(9999)
+      @test_object.inner_object.stub(:repository).and_return(mock_repo)
+      mock_repo.api.should_receive(:datastream).with(:dsid => 'abcd', :pid => @test_object.pid).and_return(ds_profile)
+      @test_datastream.size.should == 9999
     end
 
-    it 'should default to an empty string if ds has not been saved' do
-      expect(@test_datastream.size).to be_nil
+    it "should default to an empty string if ds has not been saved" do
+      @test_datastream.size.should be_nil
     end
   end
 end

data/spec/unit/datastreams_spec.rb

@@ -6,21 +6,31 @@ describe ActiveFedora::Datastreams do
   describe '.has_metadata' do
     before do
       class FooHistory < ActiveFedora::Base
-         has_metadata :name => 'dsid'
+         has_metadata :name => 'dsid', type: ActiveFedora::SimpleDatastream
          has_metadata 'complex_ds', :versionable => true, :autocreate => true, :type => 'Z', :label => 'My Label', :control_group => 'Z'
       end
     end
 
-    it 'should have a ds_specs entry' do
-      expect(FooHistory.ds_specs).to have_key('dsid')
+    it "should have a ds_specs entry" do
+      FooHistory.ds_specs.should have_key('dsid')
     end
 
-    it 'should have reasonable defaults' do
-      expect(FooHistory.ds_specs['dsid']).to include(:autocreate => false)
+    it "should have reasonable defaults" do
+      FooHistory.ds_specs['dsid'].should include(:autocreate => false)
     end
 
-    it 'should let you override defaults' do
-      expect(FooHistory.ds_specs['complex_ds']).to include(:versionable => true, :autocreate => true, :type => 'Z', :label => 'My Label', :control_group => 'Z')
+    it "should let you override defaults" do
+      FooHistory.ds_specs['complex_ds'].should include(:versionable => true, :autocreate => true, :type => 'Z', :label => 'My Label', :control_group => 'Z')
+    end
+
+    it "should raise an error if you don't give a type" do
+      expect{ FooHistory.has_metadata "bob" }.to raise_error ArgumentError,
+        "You must provide a :type property for the metadata datastream 'bob'"
+    end
+
+    it "should raise an error if you don't give a dsid" do
+      expect{ FooHistory.has_metadata type: ActiveFedora::SimpleDatastream }.to raise_error ArgumentError,
+        "You must provide a name (dsid) for the metadata datastream"
     end
   end
 
@@ -32,90 +42,86 @@ describe ActiveFedora::Datastreams do
       end
     end
 
-    it 'should have reasonable defaults' do
-      expect(FooHistory.ds_specs['dsid']).to include(:type => ActiveFedora::Datastream, :label => 'File Datastream', :control_group => 'M')
-      expect(FooHistory.ds_specs['another']).to include(:type => ActiveFedora::Datastream, :label => 'File Datastream', :control_group => 'M')
+    it "should have reasonable defaults" do
+      FooHistory.ds_specs['dsid'].should include(:type => ActiveFedora::Datastream, :label => 'File Datastream', :control_group => 'M')
+      FooHistory.ds_specs['another'].should include(:type => ActiveFedora::Datastream, :label => 'File Datastream', :control_group => 'M')
     end
   end
 
-  describe '#serialize_datastreams' do
-    it 'should touch each datastream' do
+  describe "#serialize_datastreams" do
+    it "should touch each datastream" do
       m1 = double()
       m2 = double()
 
-      expect(m1).to receive(:serialize!)
-      expect(m2).to receive(:serialize!)
+      m1.should_receive(:serialize!)
+      m2.should_receive(:serialize!)
        subject.stub(:datastreams => { :m1 => m1, :m2 => m2})
        subject.serialize_datastreams
     end
   end
 
-  describe '#add_disseminator_location_to_datastreams' do
-    it 'should infer dsLocations for E datastreams without hitting Fedora' do
-
-      mock_specs = {:e => { :disseminator => 'xyz' }}
+  describe "#add_disseminator_location_to_datastreams" do
+    it "should infer dsLocations for E datastreams without hitting Fedora" do
+      
+      mock_specs = {'e' => { :disseminator => 'xyz' }}
       mock_ds = double(:controlGroup => 'E')
       ActiveFedora::Base.stub(:ds_specs => mock_specs)
       ActiveFedora.stub(:config_for_environment => { :url => 'http://localhost'})
-      subject.stub(:pid => 'test:1', :datastreams => {:e => mock_ds})
-      expect(mock_ds).to receive(:dsLocation=).with('http://localhost/objects/test:1/methods/xyz')
+      subject.stub(:pid => 'test:1', :datastreams => {'e' => mock_ds})
+      mock_ds.should_receive(:dsLocation=).with("http://localhost/objects/test:1/methods/xyz")
       subject.add_disseminator_location_to_datastreams
     end
   end
 
-  describe '#corresponding_datastream_name' do
-    before(:each) do
-      subject.stub(:datastreams => { 'abc' => double(), 'a_b_c' => double(), 'a-b' => double()})
+  describe ".name_for_dsid" do
+    it "should use the name" do
+      ActiveFedora::Base.send(:name_for_dsid, 'abc').should == 'abc'
     end
 
-    it 'should use the name, if it exists' do
-      expect(subject.corresponding_datastream_name('abc')).to eq('abc')
+    it "should use the name" do
+      ActiveFedora::Base.send(:name_for_dsid, 'ARCHIVAL_XML').should == 'ARCHIVAL_XML'
     end
 
-    it 'should hash-erize underscores' do
-      expect(subject.corresponding_datastream_name('a_b')).to eq('a-b')
+    it "should use the name" do
+      ActiveFedora::Base.send(:name_for_dsid, 'descMetadata').should == 'descMetadata'
     end
 
-    it 'should return nil if nothing matches' do
-      expect(subject.corresponding_datastream_name('xyz')).to be_nil
+    it "should hash-erize underscores" do
+      ActiveFedora::Base.send(:name_for_dsid, 'a-b').should == 'a_b'
     end
   end
-
-  describe '#datastreams' do
-    it 'should return the datastream hash proxy' do
-      allow(subject).to receive(:load_datastreams)
-      expect(subject.datastreams).to be_a_kind_of(ActiveFedora::DatastreamHash)
-    end
-
-    it 'should round-trip to/from YAML' do
-      expect(YAML.load(subject.datastreams.to_yaml).inspect).to eq(subject.datastreams.inspect)
+ 
+  describe "#datastreams" do
+    it "should return the datastream hash proxy" do
+      subject.stub(:load_datastreams)
+      subject.datastreams.should be_a_kind_of(ActiveFedora::DatastreamHash)
     end
   end
 
-  describe '#configure_datastream' do
-    it 'should look up the ds_spec' do
+  describe "#configure_datastream" do
+    it "should look up the ds_spec" do
       mock_dsspec = { :type => nil }
       subject.stub(:ds_specs => {'abc' => mock_dsspec})
       subject.configure_datastream(double(:dsid => 'abc'))
     end
 
-    it 'should be ok if there is no ds spec' do
+    it "should be ok if there is no ds spec" do
       mock_dsspec = double()
       subject.stub(:ds_specs => {})
       subject.configure_datastream(double(:dsid => 'abc'))
     end
 
-    it 'should configure RelsExtDatastream' do
+    it "should configure RelsExtDatastream" do
       mock_dsspec = { :type => ActiveFedora::RelsExtDatastream }
       subject.stub(:ds_specs => {'abc' => mock_dsspec})
 
       ds = double(:dsid => 'abc')
-      expect(ds).to receive(:model=).with(subject)
+      ds.should_receive(:model=).with(subject)
 
       subject.configure_datastream(ds)
     end
 
-    it 'should run a Proc' do
+    it "should run a Proc" do
       ds = double(:dsid => 'abc')
       @count = 0
       mock_dsspec = { :block => lambda { |x| @count += 1 } }
@@ -128,110 +134,104 @@ describe ActiveFedora::Datastreams do
     end
   end
 
-  describe '#datastream_from_spec' do
-    it 'should fetch the rubydora datastream' do
-      expect(subject.inner_object).to receive(:datastream_object_for).with('dsid', {}, {})
+  describe "#datastream_from_spec" do
+    it "should fetch the rubydora datastream" do
+      subject.inner_object.should_receive(:datastream_object_for).with('dsid', {})
       subject.datastream_from_spec({}, 'dsid')
     end
   end
 
-  describe '#load_datastreams' do
-    it 'should load and configure persisted datastreams and should add any datastreams left over in the ds specs' do
-      skip
-    end
-  end
-
-  describe '#add_datastream' do
-    it 'should add the datastream to the object' do
+  describe "#add_datastream" do
+    it "should add the datastream to the object" do
       ds = double(:dsid => 'Abc')
       subject.add_datastream(ds)
-      expect(subject.datastreams['Abc']).to eq(ds)
+      subject.datastreams['Abc'].should == ds
     end
 
-    it 'should mint a dsid' do
+    it "should mint a dsid" do
       ds = ActiveFedora::Datastream.new
-      expect(subject.add_datastream(ds)).to eq('DS1')
+      subject.add_datastream(ds).should == 'DS1'
     end
   end
 
-  describe '#metadata_streams' do
-    it 'should only be metadata datastreams' do
+  describe "#metadata_streams" do
+    it "should only be metadata datastreams" do
       ds1 = double(:metadata? => true)
       ds2 = double(:metadata? => true)
       ds3 = double(:metadata? => true)
       relsextds = ActiveFedora::RelsExtDatastream.new
       file_ds = double(:metadata? => false)
       subject.stub(:datastreams => {:a => ds1, :b => ds2, :c => ds3, :d => relsextds, :e => file_ds})
-      expect(subject.metadata_streams).to include(ds1, ds2, ds3)
-      expect(subject.metadata_streams).not_to include(relsextds)
-      expect(subject.metadata_streams).not_to include(file_ds)
+      subject.metadata_streams.should include(ds1, ds2, ds3)
+      subject.metadata_streams.should_not include(relsextds)
+      subject.metadata_streams.should_not include(file_ds)
     end
   end
 
-  describe '#generate_dsid' do
-    it 'should create an autoincrementing dsid' do
-      expect(subject.generate_dsid('FOO')).to eq('FOO1')
+  describe "#generate_dsid" do
+    it "should create an autoincrementing dsid" do
+      subject.generate_dsid('FOO').should == 'FOO1'
     end
 
-    it 'should start from the highest existin dsid' do
+    it "should start from the highest existin dsid" do
       subject.stub(:datastreams => {'FOO56' => double()})
-      expect(subject.generate_dsid('FOO')).to eq('FOO57')
+      subject.generate_dsid('FOO').should == 'FOO57'
     end
   end
 
-  describe '#relsext' do
-    it 'should be the RELS-EXT datastream' do
+  describe "#relsext" do
+    it "should be the RELS-EXT datastream" do
       m = double
       subject.stub(:datastreams => { 'RELS-EXT' => m})
-      expect(subject.rels_ext).to eq(m)
+      subject.rels_ext.should == m
     end
 
-    it 'should make one up otherwise' do
+    it "should make one up otherwise" do
       subject.stub(:datastreams => {})
 
-      expect(subject.rels_ext).to be_a_kind_of(ActiveFedora::RelsExtDatastream)
+      subject.rels_ext.should be_a_kind_of(ActiveFedora::RelsExtDatastream)
     end
   end
 
-  describe '#add_file_datastream' do
+  describe "#add_file_datastream" do
     # tested elsewhere :/
-  end
+  end 
 
-  describe '#create_datastream' do
-    it 'should mint a DSID' do
+  describe "#create_datastream" do
+    it "should mint a DSID" do
       ds = subject.create_datastream(ActiveFedora::Datastream, nil, {})
-      expect(ds.dsid).to eq('DS1')
+      ds.dsid.should == 'DS1'
     end
 
-    it 'should raise an argument error if the supplied dsid is nonsense' do
+    it "should raise an argument error if the supplied dsid is nonsense" do
       expect { subject.create_datastream(ActiveFedora::Datastream, 0) }.to raise_error(ArgumentError)
     end
 
-    it 'should try to get a mime type from the blob' do
+    it "should try to get a mime type from the blob" do
       mock_file = double(:content_type => 'x-application/asdf')
       ds = subject.create_datastream(ActiveFedora::Datastream, nil, {:blob => mock_file})
-      expect(ds.mimeType).to eq('x-application/asdf')
+      ds.mimeType.should == 'x-application/asdf'
     end
 
-    it 'should provide a default mime type' do
+    it "should provide a default mime type" do
       mock_file = double()
       ds = subject.create_datastream(ActiveFedora::Datastream, nil, {:blob => mock_file})
-      expect(ds.mimeType).to eq('application/octet-stream')
+      ds.mimeType.should == 'application/octet-stream'
     end
 
-    it 'should use the filename as a default label' do
+    it "should use the filename as a default label" do
      mock_file = double(:path => '/asdf/fdsa')
       ds = subject.create_datastream(ActiveFedora::Datastream, nil, {:blob => mock_file})
-      expect(ds.dsLabel).to eq('fdsa')
+      ds.dsLabel.should == 'fdsa'
     end
   end
 
-  describe '#additional_attributes_for_external_and_redirect_control_groups' do
+  describe "#additional_attributes_for_external_and_redirect_control_groups" do
     before(:all) do
       @behavior = ActiveFedora::Datastreams.deprecation_behavior
       ActiveFedora::Datastreams.deprecation_behavior = :silence
     end
-
+  
      after :all do
       ActiveFedora::Datastreams.deprecation_behavior = @behavior
     end