active-fedora 8.7.0 → 9.0.0.beta1

data/spec/unit/datastream_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-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"
-  end
-
-  its(:metadata?) { should be_falsey}
-
-  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')
-  end
-  
-  it "should be inspectable" do
-    expect(@test_datastream.inspect).to match /#<ActiveFedora::Datastream @pid=\"\" @dsid=\"abcd\" @controlGroup=\"M\" changed=\"true\" @mimeType=\"\" >/
-  end
-
-  it "should have mimeType accessors" do
-    ds1 = ActiveFedora::Datastream.new
-    ds1.mimeType = "text/foo"
-    expect(ds1.mimeType).to eq("text/foo")
-    ds2 = ActiveFedora::Datastream.new
-    ds2.mimeType = "text/bar"
-    expect(ds2.mimeType).to eq("text/bar")
-  end
-
-  describe "#generate_dsid" do
-    subject {ActiveFedora::Datastream.new(@test_object.inner_object) }
-    let(:digital_object) { double(datastreams: {})}
-    it "should create an autoincrementing dsid" do
-      expect(subject.send(:generate_dsid, digital_object, 'FOO')).to eq('FOO1')
-    end
-
-    describe "when some datastreams exist" do
-      let(:digital_object) { double(datastreams: {'FOO56' => double})}
-      it "should start from the highest existing dsid" do
-        expect(subject.send(:generate_dsid, digital_object, 'FOO')).to eq('FOO57')
-      end
-    end
-  end
-
-  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}\" 
-            dsID=\"#{@test_datastream.dsid}\" >
-         <dsLabel></dsLabel>
-         <dsVersionID>#{@test_datastream.dsid}.1</dsVersionID>
-         <dsCreateDate>2011-07-11T16:48:13.536Z</dsCreateDate>
-         <dsState>A</dsState>
-         <dsMIME>text/xml</dsMIME>
-         <dsFormatURI></dsFormatURI>
-         <dsControlGroup>X</dsControlGroup>
-         <dsSize>9999</dsSize>
-         <dsVersionable>true</dsVersionable>
-         <dsInfoType></dsInfoType>
-         <dsLocation>#{@test_object.pid}+#{@test_datastream.dsid}+#{@test_datastream.dsid}.1</dsLocation>
-         <dsLocationType></dsLocationType>
-         <dsChecksumType>DISABLED</dsChecksumType>
-         <dsChecksum>none</dsChecksum>
-         </datastreamProfile>"
-      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)
-    end
-
-    it "should default to an empty string if ds has not been saved" do
-      expect(@test_datastream.size).to be_nil
-    end
-  end
-end

data/spec/unit/datastreams_spec.rb

@@ -1,243 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Datastreams do
-  subject { ActiveFedora::Base.new }
-
-  describe '.has_metadata' do
-    before do
-      class FooHistory < ActiveFedora::Base
-         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')
-    end
-
-    it "should have reasonable defaults" do
-      expect(FooHistory.ds_specs['dsid']).to 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')
-    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 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 datastream"
-    end
-  end
-
-  describe '.has_file_datastream' do
-    before do
-      class FooHistory < ActiveFedora::Base
-         has_file_datastream :name => 'dsid'
-         has_file_datastream 'another'
-      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')
-    end
-  end
-
-  describe "#serialize_datastreams" do
-    it "should touch each datastream" do
-      m1 = double()
-      m2 = double()
-
-      expect(m1).to receive(:serialize!)
-      expect(m2).to receive(:serialize!)
-       allow(subject).to receive_messages(: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' }}
-      mock_ds = double(:controlGroup => 'E')
-      allow(ActiveFedora::Base).to receive_messages(:ds_specs => mock_specs)
-      allow(ActiveFedora).to receive_messages(:config_for_environment => { :url => 'http://localhost'})
-      allow(subject).to receive_messages(:pid => 'test:1', :datastreams => {'e' => mock_ds})
-      expect(mock_ds).to receive(:dsLocation=).with("http://localhost/objects/test:1/methods/xyz")
-      subject.add_disseminator_location_to_datastreams
-    end
-  end
-
-  describe ".name_for_dsid" do
-    it "should use the name" do
-      expect(ActiveFedora::Base.send(:name_for_dsid, 'abc')).to eq('abc')
-    end
-
-    it "should use the name" do
-      expect(ActiveFedora::Base.send(:name_for_dsid, 'ARCHIVAL_XML')).to eq('ARCHIVAL_XML')
-    end
-
-    it "should use the name" do
-      expect(ActiveFedora::Base.send(:name_for_dsid, 'descMetadata')).to eq('descMetadata')
-    end
-
-    it "should hash-erize underscores" do
-      expect(ActiveFedora::Base.send(:name_for_dsid, 'a-b')).to eq('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)
-    end
-  end
-
-  describe "#configure_datastream" do
-    it "should look up the ds_spec" do
-      mock_dsspec = { :type => nil }
-      allow(subject).to receive_messages(:ds_specs => {'abc' => mock_dsspec})
-      subject.configure_datastream(double(:dsid => 'abc'))
-    end
-
-    it "should be ok if there is no ds spec" do
-      mock_dsspec = double()
-      allow(subject).to receive_messages(:ds_specs => {})
-      subject.configure_datastream(double(:dsid => 'abc'))
-    end
-
-    it "should configure RelsExtDatastream" do
-      mock_dsspec = { :type => ActiveFedora::RelsExtDatastream }
-      allow(subject).to receive_messages(:ds_specs => {'abc' => mock_dsspec})
-
-      ds = double(:dsid => 'abc')
-      expect(ds).to receive(:model=).with(subject)
-
-      subject.configure_datastream(ds)
-    end
-
-    it "should run a Proc" do
-      ds = double(:dsid => 'abc')
-      @count = 0
-      mock_dsspec = { :block => lambda { |x| @count += 1 } }
-      allow(subject).to receive_messages(:ds_specs => {'abc' => mock_dsspec})
-
-
-      expect {
-      subject.configure_datastream(ds)
-      }.to change { @count }.by(1)
-    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', {}, {})
-      subject.datastream_from_spec({}, 'dsid')
-    end
-  end
-
-  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)
-    end
-
-    it "should mint a dsid" do
-      ds = ActiveFedora::Datastream.new(subject.inner_object)
-      expect(subject.add_datastream(ds)).to eq('DS1')
-    end
-  end
-
-  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)
-      allow(subject).to receive_messages(: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)
-    end
-  end
-
-  describe "#relsext" do
-    it "should be the RELS-EXT datastream" do
-      m = double
-      allow(subject).to receive_messages(:datastreams => { 'RELS-EXT' => m})
-      expect(subject.rels_ext).to eq(m)
-    end
-
-    it "should make one up otherwise" do
-      allow(subject).to receive_messages(:datastreams => {})
-
-      expect(subject.rels_ext).to be_a_kind_of(ActiveFedora::RelsExtDatastream)
-    end
-  end
-
-  describe "#add_file_datastream" do
-    # tested elsewhere :/
-  end 
-
-  describe "#create_datastream" do
-    it "should mint a DSID" do
-      ds = subject.create_datastream(ActiveFedora::Datastream, nil, {})
-      expect(ds.dsid).to eq('DS1')
-    end
-
-    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
-      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')
-    end
-
-    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')
-    end
-
-    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')
-    end
-
-    it "should not set content for controlGroup 'E'" do
-      ds = subject.create_datastream(ActiveFedora::Datastream, nil, {controlGroup: 'E'})
-      expect(ds.content).to be_nil
-    end
-
-    it "should not set content for controlGroup 'R'" do
-      ds = subject.create_datastream(ActiveFedora::Datastream, nil, {controlGroup: 'R'})
-      expect(ds.content).to be_nil
-    end
-  end
-
-  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
-
-  end
-end

data/spec/unit/has_and_belongs_to_many_collection_spec.rb

@@ -1,96 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Associations::HasAndBelongsToManyAssociation do
-  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
-
-  it "should call add_relationship" do
-    subject = Book.new(pid: 'subject:a')
-    allow(subject).to receive_messages(:new_record? => false, save: true)
-    predicate = Book.create_reflection(:has_and_belongs_to_many, 'pages', {:property=>'predicate'}, nil)
-    allow(ActiveFedora::SolrService).to receive(:query).and_return([])
-    ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, predicate)
-    expect(ac).to receive(:callback).twice
-    object = Page.new(:pid => 'object:b')
-    allow(object).to receive_messages(:new_record? => false, save: true)
-  
-    expect(subject).to receive(:add_relationship).with('predicate', object)
- 
-    ac << object
-
-  end
-
-  it "should call add_relationship on subject and object when inverse_of given" do
-    subject = Book.new(pid: 'subject:a')
-    allow(subject).to receive_messages(:new_record? => false, save: true)
-    predicate = Book.create_reflection(:has_and_belongs_to_many, 'pages', {:property=>'predicate', :inverse_of => 'inverse_predicate'}, nil)
-    allow(ActiveFedora::SolrService).to receive(:query).and_return([])
-    ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, predicate)
-    expect(ac).to receive(:callback).twice
-    object = Page.new(:pid => 'object:b')
-    allow(object).to receive_messages(:new_record? => false, save: true)
-  
-    expect(subject).to receive(:add_relationship).with('predicate', object)
- 
-    expect(object).to receive(:add_relationship).with('inverse_predicate', subject)
- 
-    ac << object
-
-  end
-
-  it "should call solr query multiple times" do
-
-    subject = Book.new(pid: 'subject:a')
-    allow(subject).to receive_messages(: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([])
-
-    ac = ActiveFedora::Associations::HasAndBelongsToManyAssociation.new(subject, predicate)
-    ac.find_target
-  end
-
-  context "class with association" do
-    before do
-      class Collection < ActiveFedora::Base
-        has_and_belongs_to_many :members, :property => :has_collection_member, :class_name => "ActiveFedora::Base" , :after_remove => :remove_member
-        def remove_member (m)
-        end
-      end
-
-      class Thing < ActiveFedora::Base
-        has_many :collections, property: :has_collection_member, :class_name => "ActiveFedora::Base"
-      end
-    end
-
-    after do
-      Collection.destroy_all
-      Thing.destroy_all
-      Object.send(:remove_const, :Collection)
-      Object.send(:remove_const, :Thing)
-    end
-
-    let(:thing) {Thing.create()}
-    let(:collection) {Collection.create().tap {|c| c.members << thing}}
-
-    it "should call destroy" do
-      expect { collection.destroy }.to_not raise_error
-    end
-
-  end
-
-end

data/spec/unit/has_many_collection_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Associations::HasManyAssociation do
-  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
-
-  subject { Book.new(pid: 'subject:a') }
-  before {
-    allow(subject).to receive_messages(:new_record? => false, save: true)
-  }
-
-  it "should call add_relationship" do
-    reflection = Book.create_reflection(:has_many, 'pages', {:property=>'predicate'}, Book)
-    allow(ActiveFedora::SolrService).to receive(:query).and_return([])
-    ac = ActiveFedora::Associations::HasManyAssociation.new(subject, reflection)
-    expect(ac).to receive(:callback).twice
-    object = Page.new(:pid => 'object:b')
-    allow(object).to receive_messages(:new_record? => false, save: true)
-  
-    expect(object).to receive(:add_relationship).with('predicate', subject)
- 
-    ac << object
-
-  end
-  
-end