active-fedora 8.7.0 → 9.0.0.beta1

data/lib/tasks/active_fedora.rake

@@ -1,83 +0,0 @@
-require "active-fedora"
-require "active_support" # This is just to load ActiveSupport::CoreExtensions::String::Inflections
-
-ZIP_FILE = 'https://github.com/projecthydra/hydra-jetty/archive/v5.2.0.zip'
-
-namespace :repo do
-  
-  desc "Delete and re-import the object identified by pid" 
-  task :refresh => [:delete,:load]
-  
-  desc "Delete the object identified by pid. Example: rake repo:delete pid=demo:12"
-  task :delete => :environment do
-    if ENV["pid"].nil? 
-      puts "You must specify a valid pid.  Example: rake repo:delete pid=demo:12"
-    else
-      pid = ENV["pid"]
-      result = ActiveFedora::FixtureLoader.delete(pid)
-      puts "Deleted '#{pid}' from #{ActiveFedora::Base.connection_for_pid(pid).client.url}" if result == 1
-    end
-  end
-  
-  desc "Delete a range of objects in a given namespace.  ie 'rake repo:delete_range namespace=demo start=22 stop=50' will delete demo:22 through demo:50"
-  task :delete_range => :environment do |t, args|
-    namespace = ENV["namespace"]
-    start_point = ENV["start"].to_i
-    stop_point = ENV["stop"].to_i
-    unless start_point <= stop_point 
-      raise StandardError "start point must be less that end point."
-    end
-    puts "Deleting #{stop_point - start_point + 1} objects from #{namespace}:#{start_point.to_s} to #{namespace}:#{stop_point.to_s}"
-    i = start_point
-    while i <= stop_point do
-      pid = namespace + ":" + i.to_s
-      result = ActiveFedora::FixtureLoader.delete(pid)
-      puts "Deleted '#{pid}' from #{ActiveFedora::Base.connection_for_pid(pid).client.url}" if result == 1
-      i += 1
-    end
-  end
-
-  desc "Export the object identified by pid into spec/fixtures. Example:rake repo:export pid=demo:12"
-  task :export => :environment do
-    if ENV["pid"].nil? 
-      puts "You must specify a valid pid.  Example: rake repo:export pid=demo:12"
-    else
-      pid = ENV["pid"]
-      puts "Exporting '#{pid}' from #{ActiveFedora::Base.connection_for_pid(pid).client.url}"
-      if !ENV["dir"].nil?
-        dir = ENV["dir"]
-      else
-        dir = File.join('spec', 'fixtures')
-      end
-      filename = ActiveFedora::FixtureExporter.export_to_path(pid, dir)
-      puts "The object has been saved as #{filename}" if filename
-    end
-  end
-  
-  desc "Load the object located at the provided path or identified by pid. Example: rake repo:load foxml=spec/fixtures/demo_12.foxml.xml"
-  task :load => :environment do
-    if !ENV["foxml"].nil? and File.file?(ENV["foxml"])
-      filename = ENV["foxml"]
-      pid = ActiveFedora::FixtureLoader.import_to_fedora(filename)
-      ActiveFedora::FixtureLoader.index(pid)
-    elsif !ENV["pid"].nil?
-      pid = ENV["pid"]
-      if !ENV["dir"].nil? and File.directory?(ENV["dir"])
-       loader = ActiveFedora::FixtureLoader.new(ENV["dir"])
-      else
-       loader = ActiveFedora::FixtureLoader.new(File.join("spec", "fixtures"))
-      end
-      loader.import_and_index(pid)
-    else
-      puts "You must specify the foxml path or provide its pid.  Example: rake repo:load foxml=spec/fixtures/demo_12.foxml.xml"
-    end
-    puts "Loaded '#{pid}' into #{ActiveFedora::Base.connection_for_pid(pid).client.url}" if pid
-  end
-
-
-end
-
-task :environment do
-  # This task is overridden (chained) in hydra-head.
-end
-

data/spec/fixtures/sharded_fedora.yml

@@ -1,11 +0,0 @@
-test:
-- user: fedoraAdmin
-  password: fedoraAdmin
-  url: http://127.0.0.1:8983/fedora1 
-- user: fedoraAdmin
-  password: fedoraAdmin
-  url: http://127.0.0.1:8983/fedora2 
-- user: fedoraAdmin
-  password: fedoraAdmin
-  url: http://127.0.0.1:8983/fedora3 
-

data/spec/integration/auditable_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::Auditable do
-
-  before(:all) do
-    class AuditableModel < ActiveFedora::Base
-      include ActiveFedora::Auditable
-    end
-    @test_object = AuditableModel.create
-    @test_object.reload
-  end
-  after(:all) do
-    @test_object.delete
-  end
-  it "should have the correct number of audit records" do
-    expect(@test_object.audit_trail.records.length).to eq(1)
-  end
-  it "should return all the data from each audit record" do
-    record = @test_object.audit_trail.records.last
-    expect(record.id).to eq("AUDREC1")
-    expect(record.process_type).to eq("Fedora API-M")
-    expect(record.action).to eq("addDatastream")
-    expect(record.component_id).to eq("RELS-EXT")
-    expect(record.responsibility).to eq("fedoraAdmin")
-    expect(DateTime.parse(record.date)).to eq DateTime.parse(@test_object.modified_date)
-    expect(record.justification).to eq("")
-  end
-  
-end

data/spec/integration/datastream_collections_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-
-describe ActiveFedora::DatastreamCollections do
-  before(:all) do
-    class MockAFBaseDatastream < ActiveFedora::Base
-      include ActiveFedora::DatastreamCollections
-      has_datastream :name=>"thumbnail",:prefix => "THUMB", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M'
-      has_datastream :name=>"high", :type=>ActiveFedora::Datastream, :mimeType=>"image/jpeg", :controlGroup=>'M' 
-    end
-  end
-
-  #
-  # Named datastream specs
-  #
-  describe '#add_named_datastream' do
-    it 'should add a datastream with the given name to the object in fedora' do
-      @test_object2 = MockAFBaseDatastream.new
-      f = File.open(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"), 'rb')
-      f2 = File.open(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ), 'rb')
-      allow(f2).to receive(:original_filename).and_return("dino.jpg")
-      allow(f).to receive(:content_type).and_return("image/jpeg")
-      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:blob=>f, :label=>"testDS"})
-      @test_object2.add_named_datastream("high",{:content_type=>"image/jpeg",:blob=>f2})
-      ds = @test_object2.thumbnail.first
-      ds2 = @test_object2.high.first
-      @test_object2.save
-      @test_object2 = MockAFBaseDatastream.find(@test_object2.pid)
-      expect(@test_object2.named_datastreams.keys.size).to eq(2)
-      expect(@test_object2.named_datastreams.keys.include?("thumbnail")).to eq(true)
-      expect(@test_object2.named_datastreams.keys.include?("high")).to eq(true)
-      expect(@test_object2.named_datastreams["thumbnail"].size).to eq(1)
-      expect(@test_object2.named_datastreams["high"].size).to eq(1)
-      t2_thumb1 = @test_object2.named_datastreams["thumbnail"].first
-      expect(t2_thumb1.dsid).to eq(ds.dsid)
-      expect(t2_thumb1.mimeType).to eq(ds.mimeType)
-      expect(t2_thumb1.pid).to eq(ds.pid)
-      expect(t2_thumb1.dsLabel).to eq(ds.dsLabel)
-      expect(t2_thumb1.controlGroup).to eq(ds.controlGroup)
-      t2_high1 = @test_object2.named_datastreams["high"].first
-      expect(t2_high1.dsid).to eq(ds2.dsid)
-      expect(t2_high1.mimeType).to eq(ds2.mimeType)
-      expect(t2_high1.pid).to eq(ds2.pid)
-      expect(t2_high1.dsLabel).to eq(ds2.dsLabel)
-      expect(t2_high1.controlGroup).to eq(ds2.controlGroup)
-    end
-  end
-  
-  describe '#add_named_file_datastream' do
-    it 'should add a file datastream with the given name to the object in fedora' do
-      @test_object2 = MockAFBaseDatastream.new
-      f = File.open(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"), 'rb')
-      allow(f).to receive(:content_type).and_return("image/jpeg")
-      @test_object2.add_named_file_datastream("thumbnail",f)
-      ds = @test_object2.thumbnail.first
-      @test_object2.save
-      @test_object2 = MockAFBaseDatastream.find(@test_object2.pid)
-      expect(@test_object2.named_datastreams["thumbnail"].size).to eq(1)
-      t2_thumb1 = @test_object2.named_datastreams["thumbnail"].first
-      expect(t2_thumb1.dsid).to eq("THUMB1")
-      expect(t2_thumb1.mimeType).to eq("image/jpeg")
-      expect(t2_thumb1.pid).to eq(@test_object2.pid)
-      expect(t2_thumb1.dsLabel).to eq("minivan.jpg")
-      expect(t2_thumb1.controlGroup).to eq("M")
-    end
-  end
-  
-  describe '#update_named_datastream' do
-    it 'should update a named datastream to have a new file' do
-      @test_object2 = MockAFBaseDatastream.new
-      f = File.open(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"), 'rb')
-      minivan = f.read
-      f.rewind
-      f2 = File.open(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ), 'rb')
-      dino = f2.read
-      f2.rewind
-      allow(f).to receive(:content_type).and_return("image/jpeg")
-      allow(f).to receive(:original_filename).and_return("minivan.jpg")
-      allow(f2).to receive(:content_type).and_return("image/jpeg")
-      allow(f2).to receive(:original_filename).and_return("dino.jpg")
-      #check raise exception if dsid not supplied
-      @test_object2.add_named_datastream("thumbnail",{:file=>f})
-      @test_object2.save
-      @test_object2 = MockAFBaseDatastream.find(@test_object2.pid)
-      
-      expect(@test_object2.thumbnail.size).to eq(1)
-      @test_object2.thumbnail_ids == ["THUMB1"]
-      ds = @test_object2.thumbnail.first
-      expect(ds.dsid).to eq("THUMB1")
-      expect(ds.mimeType).to eq("image/jpeg")
-      expect(ds.pid).to eq(@test_object2.pid)
-      expect(ds.dsLabel).to eq("minivan.jpg")
-      expect(ds.controlGroup).to eq("M")
-
-      expect(ds.content).to eq(minivan) 
-      @test_object2.update_named_datastream("thumbnail",{:file=>f2,:dsid=>"THUMB1"})
-      @test_object2.save
-      @test_object2 = MockAFBaseDatastream.find(@test_object2.pid)
-      expect(@test_object2.thumbnail.size).to eq(1)
-      @test_object2.thumbnail_ids == ["THUMB1"]
-      ds2 = @test_object2.thumbnail.first
-      expect(ds2.dsid).to eq("THUMB1")
-      expect(ds2.mimeType).to eq("image/jpeg")
-      expect(ds2.pid).to eq(@test_object2.pid)
-      expect(ds2.dsLabel).to eq("dino.jpg")
-      expect(ds2.controlGroup).to eq("M")
-      expect(ds2.content == dino).to be_truthy
-    end
-  end
-  
-  describe '#named_datastreams_ids' do
-    it 'should return a hash of datastream name to an array of dsids' do
-      @test_object2 = MockAFBaseDatastream.new
-      f = File.open(File.join( File.dirname(__FILE__), "../fixtures/minivan.jpg"), 'rb')
-      f2 = File.open(File.join( File.dirname(__FILE__), "../fixtures/dino.jpg" ), 'rb')
-      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:blob=>f})
-      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:blob=>f2})
-      @test_object2.save
-      @test_object2 = MockAFBaseDatastream.find(@test_object2.pid)
-      named_datastreams_ids = @test_object2.named_datastreams_ids
-
-      expect(named_datastreams_ids.keys.sort).to eq(['high', 'thumbnail'])
-      expect(named_datastreams_ids['high']).to eq([])
-      expect(named_datastreams_ids['thumbnail'].sort).to eq(["THUMB1", "THUMB2"])
-    end
-  end
-
-end

data/spec/integration/datastream_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper'
-
-require 'active_fedora'
-require "rexml/document"
-
-describe ActiveFedora::Datastream do
-
-  before(:all) do
-    class MockAFBase < ActiveFedora::Base
-      has_metadata :name => "descMetadata", :type => ActiveFedora::QualifiedDublinCoreDatastream, :autocreate => true
-    end
-  end
-  
-  before(:each) do
-    @test_object = MockAFBase.new
-    @test_object.save
-  end
-  
-  after(:each) do
-    @test_object.delete
-  end
-
-  it "should be able to access Datastreams using datastreams method" do
-    descMetadata = @test_object.datastreams["descMetadata"]
-    expect(descMetadata).to be_a_kind_of(ActiveFedora::Datastream)
-    expect(descMetadata.dsid).to eql("descMetadata")
-  end
-
-  it "should be able to access Datastream content using content method" do    
-    descMetadata = @test_object.datastreams["descMetadata"].content
-    expect(descMetadata).not_to be_nil
-  end
-  
-  it "should be able to update XML Datastream content and save to Fedora" do    
-    xml_content = Nokogiri::XML::Document.parse(@test_object.datastreams["descMetadata"].content)
-    title = Nokogiri::XML::Element.new "title", xml_content
-    title.content = "Test Title"
-    xml_content.root.add_child title
-    
-    allow(@test_object.datastreams["descMetadata"]).to receive(:before_save)
-    @test_object.datastreams["descMetadata"].content = xml_content.to_s
-    @test_object.datastreams["descMetadata"].save
-    
-    found = Nokogiri::XML::Document.parse(@test_object.class.find(@test_object.pid).datastreams['descMetadata'].content)
-    expect(found.xpath('//dc/title/text()').first.inner_text).to eq(title.content)
-  end
-  
-  it "should be able to update Blob Datastream content and save to Fedora" do    
-    dsid = "ds#{Time.now.to_i}"
-    ds = ActiveFedora::Datastream.new(@test_object.inner_object, dsid)
-    ds.content = fixture('dino.jpg')
-    expect(@test_object.add_datastream(ds)).to be_truthy
-    @test_object.save
-    expect(@test_object.datastreams[dsid]).not_to be_changed
-    to = ActiveFedora::Base.find(@test_object.pid) 
-    expect(to).not_to be_nil 
-    expect(to.datastreams[dsid]).not_to be_nil
-    expect(to.datastreams[dsid].content).to eq(fixture('dino.jpg').read)
-  end
-  
-  it "should be able to set the versionable attribute" do
-    dsid = "ds#{Time.now.to_i}"
-    v1 = "<version1>data</version1>"
-    v2 = "<version2>data</version2>"
-    ds = ActiveFedora::Datastream.new(@test_object.inner_object, dsid)
-    ds.content = v1
-    ds.versionable = false
-    expect(@test_object.add_datastream(ds)).to be_truthy
-    @test_object.save
-    to = ActiveFedora::Base.find(@test_object.pid)
-    ds = to.datastreams[dsid]
-    expect(ds.versionable).to be_falsey
-    ds.versionable = true
-    to.save
-    ds.content = v2
-    to.save
-    versions = ds.versions
-    expect(versions.length).to eq(2)
-    # order of versions not guaranteed
-    if versions[0].content == v2
-      expect(versions[1].content).to eq(v1)
-      expect(versions[0].asOfDateTime).to be >= versions[1].asOfDateTime
-    else
-      expect(versions[0].content).to eq(v1)
-      expect(versions[1].content).to eq(v2)   
-      expect(versions[1].asOfDateTime).to be >= versions[0].asOfDateTime
-    end
-    expect(ds.content).to eq(v2)
-  end
-end

data/spec/integration/datastreams_spec.rb

@@ -1,173 +0,0 @@
-require 'spec_helper'
-
-require 'active_fedora'
-require "rexml/document"
-
-describe ActiveFedora::Datastreams do
-  describe "serializing datastreams" do
-    before :all do
-      class TestingMetadataSerializing < ActiveFedora::Base
-        has_metadata name: "nokogiri_autocreate_on", autocreate: true, type: ActiveFedora::OmDatastream
-        has_metadata name: "nokogiri_autocreate_off", autocreate: false, type: ActiveFedora::OmDatastream
-      end
-    end
-
-    after :all do
-      Object.send(:remove_const, :TestingMetadataSerializing)
-    end
-
-    subject { TestingMetadataSerializing.new }
-
-    it "should work" do
-      subject.save(validate: false)
-      expect(subject.nokogiri_autocreate_on).not_to be_new
-      expect(subject.nokogiri_autocreate_off).to be_new
-    end
-  end
-
-
-  describe "#has_metadata" do
-    before :all do
-      class HasMetadata < ActiveFedora::Base
-        has_metadata name: "with_versions", autocreate: true, label: "Versioned DS", type: ActiveFedora::SimpleDatastream
-        has_metadata name: "without_versions", autocreate: true, versionable: false, type: ActiveFedora::SimpleDatastream
-      end
-    end
-    after :all do
-      Object.send(:remove_const, :HasMetadata)
-    end
-    before do
-      @base = ActiveFedora::Base.new(pid:"test:has_metadata_base")
-      @base.add_datastream(@base.create_datastream(ActiveFedora::Datastream, "testDS", dsLabel: "Test DS"))
-      @base.datastreams["testDS"].content = "blah blah blah"
-      @base.save
-      @test = HasMetadata.new(pid:"test:has_metadata_model")
-      @test.save
-    end
-    
-    after do
-      @base.delete
-      @test.delete
-    end
-    
-    it "should create datastreams from the spec on new objects" do
-      expect(@test.without_versions.versionable).to be_falsey
-      expect(@test.with_versions.versionable).to be_truthy
-      expect(@test.with_versions.dsLabel).to eql "Versioned DS"
-      @test.without_versions.content= "blah blah blah"
-      @test.save
-      expect(HasMetadata.find(@test.pid).without_versions.versionable).to be_falsey
-    end
-    
-    it "should use ds_specs and preserve existing datastreams on migrated objects" do
-      test_obj = HasMetadata.find(@base.pid, cast: false)
-      expect(test_obj.datastreams["testDS"].dsLabel).to eql "Test DS"
-      expect(test_obj.datastreams["testDS"].new?).to be_falsey
-      expect(test_obj.with_versions.dsLabel).to eql "Versioned DS"
-      expect(test_obj.without_versions.versionable).to be_falsey
-      expect(test_obj.with_versions.new?).to be_truthy
-    end
-    
-  end
-  
-  describe "#has_file_datastream" do
-    before :all do
-      class HasFile < ActiveFedora::Base
-        has_file_datastream name: "file_ds", versionable: false
-        has_file_datastream name: "file_ds2", versionable: false, autocreate: false
-      end
-    end
-    after :all do
-      Object.send(:remove_const, :HasFile)
-    end
-    before do
-      @base = ActiveFedora::Base.new(pid:"test:ds_versionable_base")
-      @base.save
-      @base2 = ActiveFedora::Base.new(pid:"test:ds_versionable_base2")
-      @base2.add_datastream(@base2.create_datastream(ActiveFedora::Datastream,"file_ds", versionable:true,dsLabel:"Pre-existing DS"))
-      @base2.datastreams["file_ds"].content = "blah blah blah"
-      @base2.save
-      @has_file = HasFile.new(pid:"test:ds_versionable_has_file")
-      @has_file.save
-    end
-    
-    after do
-      @base.delete
-      @base2.delete
-      @has_file.delete
-    end
-    
-    it "should create datastreams from the spec on new objects" do
-      expect(@has_file.file_ds.versionable).to be_falsey
-      @has_file.file_ds.content = "blah blah blah"
-      expect(@has_file.file_ds.changed?).to be_truthy
-      expect(@has_file.file_ds2.changed?).to be_falsey # no autocreate
-      expect(@has_file.file_ds2.new?).to be_truthy
-      @has_file.save
-      expect(@has_file.file_ds.versionable).to be_falsey
-      test_obj = HasFile.find(@has_file.pid)
-      expect(test_obj.file_ds.versionable).to be_falsey
-      expect(test_obj.rels_ext.changed?).to be_falsey
-      expect(test_obj.file_ds.changed?).to be_falsey
-      expect(test_obj.file_ds2.changed?).to be_falsey
-      expect(test_obj.file_ds2.new?).to be_truthy
-    end
-    
-    it "should use ds_specs on migrated objects" do
-      test_obj = HasFile.find(@base.pid, cast: false)
-      expect(test_obj.file_ds.versionable).to be_falsey
-      expect(test_obj.file_ds.new?).to be_truthy
-      test_obj.file_ds.content = "blah blah blah"
-      test_obj.save
-      expect(test_obj.file_ds.versionable).to be_falsey
-      # look it up again to check datastream profile
-      test_obj = HasFile.find(@base.pid, cast: false)
-      expect(test_obj.file_ds.versionable).to be_falsey
-      expect(test_obj.file_ds.dsLabel).to eql "File Datastream"
-      test_obj = HasFile.find(@base2.pid, cast: false)
-      expect(test_obj.file_ds.versionable).to be_truthy
-      expect(test_obj.file_ds.dsLabel).to eql "Pre-existing DS"
-    end
-  end
-
-  describe "#create_datastream" do
-    before do
-      @base = ActiveFedora::Base.new(pid:"test:create_datastream")
-      @base.save
-      @ds_location = ActiveFedora.solr_config[:url] + "/admin/file/?file=schema.xml"
-      open(@ds_location) do |f|
-        @ds_content = f.read
-      end
-    end
-    
-    after do
-      @base.delete
-    end
-    # external file datastreams require changes to XACML policies, but http URIs should work
-    it "should create external datastreams" do
-      # we should be albe to reliably download the solr schema
-      ds_opts = {mimeType:'text/xml',controlGroup:'E',dsLabel:'Some metadata',
-                 dsLocation:@ds_location}
-      ds = @base.create_datastream('ActiveFedora::Datastream', 'someMetadata', ds_opts)
-      @base.add_datastream(ds)
-      @base.save
-      expect(@base.datastreams.keys.include?('someMetadata')).to be_truthy
-      test_obj = ActiveFedora::Base.find(@base.pid)
-      expect(test_obj.datastreams['someMetadata'].content).to eql @ds_content
-      expect(test_obj.datastreams['someMetadata'].controlGroup).to eql 'E'
-    end
-
-    # file:// URIs require changes to XACML policies, but http URIs should work
-    it "should create managed datastreams from a given URL" do
-      ds_opts = {mimeType:'text/xml',controlGroup:'M',dsLabel:'Some metadata',
-                 dsLocation:@ds_location}
-      ds = @base.create_datastream('ActiveFedora::Datastream', 'someMetadata', ds_opts)
-      @base.add_datastream(ds)
-      @base.save
-      expect(@base.datastreams.keys.include?('someMetadata')).to be_truthy
-      test_obj = ActiveFedora::Base.find(@base.pid)
-      expect(test_obj.datastreams['someMetadata'].content).to eql @ds_content
-      expect(test_obj.datastreams['someMetadata'].controlGroup).to eql 'M'
-    end
-  end
-end