druid-tools 0.4.1 → 1.0.0

data/README.md

@@ -1,9 +1,35 @@
+[![Build Status](https://travis-ci.org/sul-dlss/druid-tools.svg?branch=delete-records)](https://travis-ci.org/sul-dlss/druid-tools)
+[![Coverage Status](https://coveralls.io/repos/github/sul-dlss/druid-tools/badge.svg?branch=master)](https://coveralls.io/github/sul-dlss/druid-tools?branch=master)
+[![Dependency Status](https://gemnasium.com/badges/github.com/sul-dlss/druid-tools.svg)](https://gemnasium.com/github.com/sul-dlss/druid-tools)
+[![Gem Version](https://badge.fury.io/rb/druid-tools.svg)](https://badge.fury.io/rb/druid-tools)
+
 # Druid::Tools
 
 Tools to manipulate DRUID trees and content directories
 
+Note that druid syntax is defined in consul (and druids are issued by the SURI service).  See https://consul.stanford.edu/pages/viewpage.action?title=SURI+2.0+Specification&spaceKey=chimera
+
+Druid format:
+
+    bbdddbbdddd (two letters two digits two letters 4 digits)
+
+Letters must be lowercase, and must not include A, E, I, O, U or L.  (capitals for easier distinction here)
+We often use vowels in our test data, and this code base has allowed vowels historically (though not
+uppercase).  We now recommend setting the strict argument to true whenever using this code to build
+DruidTools::Druid objects or to validate druid identifier strings.
+
 ## Usage
 
+### with strict argument
+
+```ruby
+d = DruidTools::Druid.new('druid:ab123cd4567', '/dor/workspace', true) # no aeioul
+=> ArgumentError: Invalid DRUID: 'druid:ab123cd4567'
+d = DruidTools::Druid.new('druid:bb123cd4567', '/dor/workspace', true)
+d.druid
+=> "druid:bb123cd4567"
+```
+
 ### Get attributes and paths
 
 ```ruby
@@ -27,6 +53,13 @@ d = DruidTools::Druid.valid?('druid:ab123cd4567')
 => true
 d = DruidTools::Druid.valid?('blah')
 => false
+d = DruidTools::Druid.valid?('druid:ab123cd4567', true) # strict validation: no aeioul
+=> false
+d = DruidTools::Druid.valid?('druid:ab123cd4567', false)
+=> true
+d = DruidTools::Druid.valid?('druid:bb123cd4567', true)
+=> true
+
 ```
 
 ### Manipulate directories and symlinks
@@ -80,9 +113,9 @@ d.find_content('this/file/does/not/exist.jpg')
 ### Pruning: removes leaves of tree up to non-empty branches
 
 ```ruby
-d1 = DruidTools::Druid.new 'druid:cd456ef7890', '/workspace'
+d1 = DruidTools::Druid.new('druid:cd456ef7890', '/workspace')
 d1.mkdir
-d2 = DruidTools::Druid.new 'druid:cd456gh1234', '/workspace'
+d2 = DruidTools::Druid.new('druid:cd456gh1234', '/workspace')
 d2.mkdir
 
 # /workspace/cd/456/gh/1234/cd456gh1234 pruned down to /workspace/cd/456
@@ -93,22 +126,9 @@ d2.prune!
 ### Stacks and Purl compatible Druid.  All files at the leaf directories
 
 ```ruby
-pd = DruidTools::PurlDruid.new 'druid:ab123cd4567', '/purl'
+pd = DruidTools::PurlDruid.new('druid:ab123cd4567', '/purl')
 pd.path
 => "/purl/ab/123/cd/4567"
 pd.content_dir
 => "/purl/ab/123/cd/4567"
 ```
-
-### History
-
-- <b>0.3.0</b> - Added #prune method. Added AccessDruid for stacks and purl access
-- <b>0.2.6</b> - Fixed VERSION warning message, and documentation cleanup
-- <b>0.2.5</b> - Added glob pattern as DruidTools::Druid.glob
-- <b>0.2.4</b> - Allow non-String as .new parameter and added InvalidDruidError
-- <b>0.2.3</b> - Fine tune behavior of find_filelist_parent
-- <b>0.2.2</b> - Added find_filelist_parent method allowing search for a set of files
-- <b>0.2.1</b> - Do not error out during symlink creation if it already exists
-- <b>0.2.0</b> - Added DruidTools::Druid.valid?
-- <b>0.1.0</b> - Additional support for alternate content locations
-- <b>0.0.1</b> - Initial Release

data/Rakefile

@@ -4,4 +4,7 @@ require "bundler/gem_tasks"
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+task :default => [:spec, :rubocop]

data/VERSION

@@ -1 +1 @@
-0.4.1
+1.0.0

data/druid-tools.gemspec

@@ -15,7 +15,10 @@ Gem::Specification.new do |gem|
   gem.name          = 'druid-tools'
   gem.require_paths = ['lib']
   gem.version       = File.read('VERSION').strip
-  
+
   gem.add_development_dependency 'rake', '>= 10.1.0'
   gem.add_development_dependency 'rspec', '~> 3.0'
+  gem.add_development_dependency 'coveralls'
+  gem.add_development_dependency 'rubocop', '~> 0.50.0' # avoid code churn due to rubocop changes
+  gem.add_development_dependency 'rubocop-rspec', '~> 1.18.0' # avoid code churn due to rubocop-rspec changes
 end

data/lib/druid_tools/druid.rb

@@ -6,11 +6,17 @@ module DruidTools
     @@deletes_directory_name = '.deletes'
     attr_accessor :druid, :base
 
+    # See https://consul.stanford.edu/pages/viewpage.action?title=SURI+2.0+Specification&spaceKey=chimera
+    # character class matching allowed letters in a druid suitable for use in regex (no aeioul)
+    STRICT_LET = '[b-df-hjkmnp-tv-z]'.freeze
+
     class << self
       attr_accessor :prefix
 
+      # @param [boolean] true if validation should be more restrictive about allowed letters (no aeioul)
       # @return [Regexp] matches druid:aa111aa1111 or aa111aa1111
-      def pattern
+      def pattern(strict=false)
+        return /\A(?:#{self.prefix}:)?(#{STRICT_LET}{2})(\d{3})(#{STRICT_LET}{2})(\d{4})\z/ if strict
         /\A(?:#{self.prefix}:)?([a-z]{2})(\d{3})([a-z]{2})(\d{4})\z/
       end
 
@@ -19,10 +25,16 @@ module DruidTools
         "{#{self.prefix}:,}[a-z][a-z][0-9][0-9][0-9][a-z][a-z][0-9][0-9][0-9][0-9]"
       end
 
+      # @return [String] suitable for use in [Dir#glob]
+      def strict_glob
+        "{#{self.prefix}:,}#{STRICT_LET}#{STRICT_LET}[0-9][0-9][0-9]#{STRICT_LET}#{STRICT_LET}[0-9][0-9][0-9][0-9]"
+      end
+
       # @param [String] druid id
+      # @param [boolean] true if validation should be more restrictive about allowed letters (no aeioul)
       # @return [Boolean] true if druid matches pattern; otherwise false
-      def valid?(druid)
-        return druid =~ pattern ? true : false
+      def valid?(druid, strict=false)
+        druid =~ pattern(strict) ? true : false
       end
 
     end
@@ -41,13 +53,14 @@ module DruidTools
     end
 
     # @param druid [String] A valid druid
+    # @param [boolean] true if validation should be more restrictive about allowed letters (no aeioul)
     # @param base [String] The directory used by #path
-    def initialize(druid, base='.')
+    def initialize(druid, base='.', strict=false)
       druid = druid.to_s unless druid.is_a? String
-      unless self.class.valid?(druid)
+      unless self.class.valid?(druid, strict)
         raise ArgumentError, "Invalid DRUID: '#{druid}'"
       end
-      druid = [self.class.prefix,druid].join(':') unless druid =~ /^#{self.class.prefix}:/
+      druid = [self.class.prefix, druid].join(':') unless druid =~ /^#{self.class.prefix}:/
       @base = base
       @druid = druid
     end

data/spec/druid_spec.rb

@@ -0,0 +1,470 @@
+describe DruidTools::Druid do
+  let(:fixture_dir) { File.expand_path("../fixtures", __FILE__) }
+  let(:druid_str) { 'druid:cd456ef7890' }
+  let(:tree_1) { File.join(fixture_dir, 'cd/456/ef/7890/cd456ef7890') }
+  let(:strictly_valid_druid_str) { 'druid:cd456gh1234' }
+  let(:tree_2) { File.join(fixture_dir, 'cd/456/gh/1234/cd456gh1234') }
+
+  after(:each) do
+    FileUtils.rm_rf(File.join(fixture_dir, 'cd'))
+  end
+
+  context '.valid?' do
+    # also tests .pattern
+    it "correctly validates druid strings" do
+      tests = [
+        # Expected     Input druid
+        [true,         'druid:aa000bb0001'],
+        [true,         'aa000bb0001'],
+        [false,        'Aa000bb0001'],
+        [false,        "xxx\naa000bb0001"],
+        [false,        'aaa000bb0001'],
+        [false,        'druidX:aa000bb0001'],
+        [false,        ':aa000bb0001'],
+        [true,         'aa123bb1234'],
+        [false,        'aa12bb1234'],
+        [false,        'aa1234bb1234'],
+        [false,        'aa123bb123'],
+        [false,        'aa123bb12345'],
+        [false,        'a123bb1234'],
+        [false,        'aaa123bb1234'],
+        [false,        'aa123b1234'],
+        [false,        'aa123bbb1234'],
+        [false,        'druid:az918AZ9381'.upcase],
+        [true,         'druid:az918AZ9381'.downcase],
+        [true,         'druid:zz943vx1492']
+      ]
+      tests.each do |exp, dru|
+        expect(DruidTools::Druid.valid?(dru)).to eq(exp)
+        expect(DruidTools::Druid.valid?(dru, false)).to eq(exp)
+      end
+    end
+    context 'strict' do
+      it "correctly validates druid strings" do
+        tests = [
+          # Expected     Input druid
+          [false,        'aa000aa0000'],
+          [false,        'ee000ee0000'],
+          [false,        'ii000ii0000'],
+          [false,        'oo000oo0000'],
+          [false,        'uu000uu0000'],
+          [false,        'll000ll0000'],
+          [false,        'aa000bb0001'],
+          [true,         'druid:dd000bb0001'],
+          [false,        'druid:aa000bb0001'],
+          [true,         'dd000bb0001'],
+          [false,        'Dd000bb0001'],
+          [false,        "xxx\ndd000bb0001"],
+          [false,        'ddd000bb0001'],
+          [false,        'druidX:dd000bb0001'],
+          [false,        ':dd000bb0001'],
+          [true,         'cc123bb1234'],
+          [false,        'aa123bb1234'],
+          [false,        'dd12bb1234'],
+          [false,        'dd1234bb1234'],
+          [false,        'dd123bb123'],
+          [false,        'dd123bb12345'],
+          [false,        'd123bb1234'],
+          [false,        'ddd123bb1234'],
+          [false,        'dd123b1234'],
+          [false,        'dd123bbb1234'],
+          [false,        'druid:bz918BZ9381'.upcase],
+          [true,         'druid:bz918BZ9381'.downcase],
+          [false,        'druid:az918AZ9381'.downcase],
+          [true,         'druid:zz943vx1492']
+        ]
+        tests.each do |exp, dru|
+          expect(DruidTools::Druid.valid?(dru, true)).to eq(exp)
+        end
+      end
+    end
+  end
+
+  it "#druid provides the full druid including the prefix" do
+    expect(DruidTools::Druid.new('druid:cd456ef7890', fixture_dir).druid).to eq('druid:cd456ef7890')
+    expect(DruidTools::Druid.new('cd456ef7890', fixture_dir).druid).to eq('druid:cd456ef7890')
+  end
+
+  it "#id extracts the ID from the stem" do
+    expect(DruidTools::Druid.new('druid:cd456ef7890', fixture_dir).id).to eq('cd456ef7890')
+    expect(DruidTools::Druid.new('cd456ef7890', fixture_dir).id).to eq('cd456ef7890')
+  end
+
+  context '#new' do
+    it "raises exception if the druid is invalid" do
+      expect { DruidTools::Druid.new('nondruid:cd456ef7890', fixture_dir) }.to raise_error(ArgumentError)
+      expect { DruidTools::Druid.new('druid:cd4567ef890', fixture_dir) }.to raise_error(ArgumentError)
+    end
+    it "takes strict argument" do
+      DruidTools::Druid.new(strictly_valid_druid_str, fixture_dir, true)
+      expect { DruidTools::Druid.new(druid_str, fixture_dir, true) }.to raise_error(ArgumentError)
+    end
+  end
+
+  it "#tree builds a druid tree from a druid" do
+    druid = DruidTools::Druid.new(druid_str, fixture_dir)
+    expect(druid.tree).to eq(['cd', '456', 'ef', '7890', 'cd456ef7890'])
+    expect(druid.path).to eq(tree_1)
+  end
+
+  it "#mkdir, #rmdir create and destroy druid directories" do
+    expect(File.exists?(tree_1)).to eq false
+    expect(File.exists?(tree_2)).to eq false
+
+    druid_1 = DruidTools::Druid.new(druid_str, fixture_dir)
+    druid_2 = DruidTools::Druid.new(strictly_valid_druid_str, fixture_dir)
+
+    druid_1.mkdir
+    expect(File.exists?(tree_1)).to eq true
+    expect(File.exists?(tree_2)).to eq false
+
+    druid_2.mkdir
+    expect(File.exists?(tree_1)).to eq true
+    expect(File.exists?(tree_2)).to eq true
+
+    druid_2.rmdir
+    expect(File.exists?(tree_1)).to eq true
+    expect(File.exists?(tree_2)).to eq false
+
+    druid_1.rmdir
+    expect(File.exists?(tree_1)).to eq false
+    expect(File.exists?(tree_2)).to eq false
+    expect(File.exists?(File.join(fixture_dir, 'cd'))).to eq false
+  end
+
+  describe "alternate prefixes" do
+    before :all do
+      DruidTools::Druid.prefix = 'sulair'
+    end
+
+    after :all do
+      DruidTools::Druid.prefix = 'druid'
+    end
+
+    it "handles alternate prefixes" do
+      expect { DruidTools::Druid.new('druid:cd456ef7890', fixture_dir) }.to raise_error(ArgumentError)
+      expect(DruidTools::Druid.new('sulair:cd456ef7890', fixture_dir).id).to eq('cd456ef7890')
+      expect(DruidTools::Druid.new('cd456ef7890', fixture_dir).druid).to eq('sulair:cd456ef7890')
+    end
+  end
+
+  describe "content directories" do
+    it "knows where its content goes" do
+      druid = DruidTools::Druid.new(druid_str, fixture_dir)
+      expect(druid.content_dir(false)).to eq(File.join(tree_1, 'content'))
+      expect(druid.metadata_dir(false)).to eq(File.join(tree_1, 'metadata'))
+      expect(druid.temp_dir(false)).to eq(File.join(tree_1, 'temp'))
+
+      expect(File.exists?(File.join(tree_1, 'content'))).to eq false
+      expect(File.exists?(File.join(tree_1, 'metadata'))).to eq false
+      expect(File.exists?(File.join(tree_1, 'temp'))).to eq false
+    end
+
+    it "creates its content directories on the fly" do
+      druid = DruidTools::Druid.new(druid_str, fixture_dir)
+      expect(druid.content_dir).to eq(File.join(tree_1, 'content'))
+      expect(druid.metadata_dir).to eq(File.join(tree_1, 'metadata'))
+      expect(druid.temp_dir).to eq(File.join(tree_1, 'temp'))
+
+      expect(File.exists?(File.join(tree_1, 'content'))).to eq true
+      expect(File.exists?(File.join(tree_1, 'metadata'))).to eq true
+      expect(File.exists?(File.join(tree_1, 'temp'))).to eq true
+    end
+
+    it "matches glob" do
+      druid = DruidTools::Druid.new(druid_str, fixture_dir)
+      druid.mkdir
+      expect(Dir.glob(File.join(File.dirname(druid.path), DruidTools::Druid::glob)).size).to eq(1)
+    end
+    it "matches strict_glob" do
+      druid = DruidTools::Druid.new(druid_str, fixture_dir)
+      druid.mkdir
+      expect(Dir.glob(File.join(File.dirname(druid.path), DruidTools::Druid::strict_glob)).size).to eq(0)
+      druid = DruidTools::Druid.new(strictly_valid_druid_str, fixture_dir)
+      druid.mkdir
+      expect(Dir.glob(File.join(File.dirname(druid.path), DruidTools::Druid::strict_glob)).size).to eq(1)
+    end
+  end
+
+  describe "content discovery" do
+    let(:druid) { DruidTools::Druid.new(druid_str, fixture_dir) }
+    let(:filelist) { %w(1 2 3 4).collect { |num| "someFile#{num}" } }
+
+    it "finds content in content directories" do
+      location = druid.content_dir
+      File.open(File.join(location, 'someContent'), 'w') { |f| f.write 'This is the content' }
+      expect(druid.find_content('someContent')).to eq(File.join(location, 'someContent'))
+    end
+
+    it "finds content in the root directory" do
+      location = druid.path(nil, true)
+      File.open(File.join(location, 'someContent'), 'w') { |f| f.write 'This is the content' }
+      expect(druid.find_content('someContent')).to eq(File.join(location, 'someContent'))
+    end
+
+    it "finds content in the leaf directory" do
+      location = File.expand_path('..', druid.path(nil, true))
+      File.open(File.join(location, 'someContent'), 'w') { |f| f.write 'This is the content' }
+      expect(druid.find_content('someContent')).to eq(File.join(location, 'someContent'))
+    end
+
+    it "does not find content in the wrong content directory" do
+      location = druid.metadata_dir
+      File.open(File.join(location, 'someContent'), 'w') { |f| f.write 'This is the content' }
+      expect(druid.find_content('someContent')).to be_nil
+    end
+
+    it "does not find content in a higher-up directory" do
+      location = File.expand_path('../..', druid.path(nil, true))
+      File.open(File.join(location, 'someContent'), 'w') { |f| f.write 'This is the content' }
+      expect(druid.find_content('someContent')).to be_nil
+    end
+
+    it "finds a filelist in the content directory" do
+      location = Pathname(druid.content_dir)
+      filelist.each do |filename|
+        location.join(filename).open('w') { |f| f.write "This is #{filename}" }
+      end
+      expect(druid.find_filelist_parent('content', filelist)).to eq(location)
+    end
+
+    it "finds a filelist in the root directory" do
+      location = Pathname(druid.path(nil, true))
+      filelist.each do |filename|
+        location.join(filename).open('w') { |f| f.write "This is #{filename}" }
+      end
+      expect(druid.find_filelist_parent('content', filelist)).to eq(location)
+    end
+
+    it "finds a filelist in the leaf directory" do
+      location = Pathname(File.expand_path('..', druid.path(nil, true)))
+      filelist.each do |filename|
+        location.join(filename).open('w') { |f| f.write "This is #{filename}" }
+      end
+      expect(druid.find_filelist_parent('content', filelist)).to eq(location)
+    end
+
+    it "raises an exception if the first file in the filelist is not found" do
+      location = Pathname(druid.content_dir)
+      expect{druid.find_filelist_parent('content', filelist)}.to raise_exception(/content dir not found for 'someFile1' when searching/)
+    end
+
+    it "raises an exception if any other file in the filelist is not found" do
+      location = Pathname(druid.content_dir)
+      location.join(filelist.first).open('w') { |f| f.write "This is #{filelist.first}" }
+      expect{druid.find_filelist_parent('content', filelist)}.to raise_exception(/File 'someFile2' not found/)
+    end
+  end
+
+  describe "#mkdir error handling" do
+    it "raises SameContentExistsError if the directory already exists" do
+      druid_obj = DruidTools::Druid.new(strictly_valid_druid_str, fixture_dir)
+      druid_obj.mkdir
+      expect { druid_obj.mkdir }.to raise_error(DruidTools::SameContentExistsError)
+    end
+
+    it "raises DifferentContentExistsError if a link already exists in the workspace for this druid" do
+      source_dir = '/tmp/content_dir'
+      FileUtils.mkdir_p(source_dir)
+      dr = DruidTools::Druid.new(strictly_valid_druid_str, fixture_dir)
+      dr.mkdir_with_final_link(source_dir)
+      expect { dr.mkdir }.to raise_error(DruidTools::DifferentContentExistsError)
+    end
+  end
+
+  describe "#mkdir_with_final_link" do
+    let(:source_dir) { '/tmp/content_dir' }
+    let(:druid_obj){ DruidTools::Druid.new(strictly_valid_druid_str, fixture_dir) }
+
+    before(:each) do
+      FileUtils.mkdir_p(source_dir)
+    end
+
+    it "creates a druid tree in the workspace with the final directory being a link to the passed in source" do
+      druid_obj.mkdir_with_final_link(source_dir)
+      expect(File).to be_symlink(druid_obj.path)
+      expect(File.readlink(tree_2)).to eq(source_dir)
+    end
+
+    it "does not error out if the link to source already exists" do
+      druid_obj.mkdir_with_final_link(source_dir)
+      expect(File).to be_symlink(druid_obj.path)
+      expect(File.readlink(tree_2)).to eq(source_dir)
+    end
+
+    it "raises DifferentContentExistsError if a directory already exists in the workspace for this druid" do
+      druid_obj.mkdir(fixture_dir)
+      expect { druid_obj.mkdir_with_final_link(source_dir) }.to raise_error(DruidTools::DifferentContentExistsError)
+    end
+  end
+
+  describe "#prune!" do
+    let(:workspace) { Dir.mktmpdir }
+    let(:dr1) { DruidTools::Druid.new(druid_str, workspace) }
+    let(:dr2) { DruidTools::Druid.new(strictly_valid_druid_str, workspace) }
+    let(:pathname1) { dr1.pathname }
+
+    after(:each) do
+      FileUtils.remove_entry workspace
+    end
+
+    it "throws error on misconfig when base dir cannot be created" do
+      dir = '/some/dir/that/does/not/exist' # we don't have permissions to create
+      dr0 = DruidTools::Druid.new(druid_str, dir)
+      expect {dr0.prune!}.to raise_error(StandardError)
+      expect(File).to_not exist(dir)
+    end
+
+    it "does not throw error when base can be created" do
+      subdir = File.join(Dir.mktmpdir, 'some', 'nonexistant', 'subdir')      # but this one *can* be created
+      dr2 = DruidTools::Druid.new(strictly_valid_druid_str, subdir)
+      expect {dr2.prune!}.not_to raise_error()
+      expect(File).to exist(subdir)
+    end
+
+    context "shared ancestor" do
+
+      before(:each) do
+        #Nil the create records for this context because we're in a known read only one
+        dr1.mkdir
+        dr2.mkdir
+        dr1.prune!
+      end
+
+      it "deletes the outermost directory" do
+        expect(File).to_not exist(dr1.path)
+      end
+
+      it "deletes empty ancestor directories" do
+        expect(File).to_not exist(pathname1.parent)
+        expect(File).to_not exist(pathname1.parent.parent)
+      end
+
+      it "stops at ancestor directories that have children" do
+        # 'cd/456' should still exist because of druid2
+        shared_ancestor = pathname1.parent.parent.parent
+        expect(shared_ancestor.to_s).to match(/cd\/456$/)
+        expect(File).to exist(shared_ancestor)
+      end
+    end
+
+    it "removes all directories up to the base path when there are no common ancestors" do
+      #Make sure a delete record is not present
+      expect(dr1.deletes_record_exists?).to be_falsey
+
+      #Nil the create records for this test
+      dr1.mkdir
+      dr1.prune!
+      expect(File).to_not exist(File.join(workspace, 'cd'))
+      expect(File).to exist(workspace)
+
+      #Make sure a delete record was created
+      expect(dr1.deletes_dir_exists?).to be_truthy
+      expect(dr1.deletes_record_exists?).to be_truthy
+    end
+
+    it "removes directories with symlinks" do
+      #Make sure a delete record is not present
+      expect(dr2.deletes_record_exists?).to be_falsey
+
+      #Nil the create records for this test
+      source_dir = File.join workspace, 'src_dir'
+      FileUtils.mkdir_p(source_dir)
+      dr2.mkdir_with_final_link(source_dir)
+      dr2.prune!
+      expect(File).to_not exist(dr2.path)
+      expect(File).to_not exist(File.join(workspace, 'cd'))
+
+      #Make sure a delete record was created
+      expect(dr2.deletes_dir_exists?).to be_truthy
+      expect(dr2.deletes_record_exists?).to be_truthy
+    end
+
+    describe "logging deleted druids" do
+
+      #Purge any paths or delete records created in the test
+      after :each do
+        #Remove the .deletes dir to clean up
+        dr2.deletes_delete_record if dr2.deletes_record_exists?
+        FileUtils.rm_rf dr2.deletes_dir_pathname
+      end
+
+      it "returns the path to the .deletes directory as a Pathname" do
+        expect(dr2.deletes_dir_pathname.class).to eq(Pathname)
+      end
+
+      it "returns the path to the delete record for a druid as a Pathname" do
+        expect(dr2.deletes_record_pathname.class).to eq(Pathname)
+      end
+
+      it "returns the path to the delete record for a druid as top_level/.deletes/druid" do
+        expect(dr2.deletes_record_pathname.to_s).to eq("#{dr2.base}/.deletes/#{dr2.id}")
+      end
+
+      it "returns false when the .deletes dir is not present on the file system" do
+        expect(dr2.deletes_dir_exists?).to be_falsey
+      end
+
+      it "creates the .deletes dir and detect it exists" do
+
+        #Clean the .deletes dir if present
+        FileUtils.rm_rf dr2.deletes_dir_pathname
+
+        #Test for exists? and create
+        expect(dr2.deletes_dir_exists?).to be_falsey
+        dr2.create_deletes_dir
+        expect(dr2.deletes_dir_exists?).to be_truthy
+      end
+
+      it "returns false when the .deletes dir does not have a deleted record for a druid" do
+        expect(dr2.deletes_record_exists?).to be_falsey
+      end
+
+      it "creates a deleted record with a parent directory that has no .deletes directory and no deleted for the file and successfully create a delete record there" do
+        #Expect there not to be a .deletes dir or file (the file expectation is redundant I know)
+        expect(dr2.deletes_dir_exists?).to be_falsey
+        expect(dr2.deletes_record_exists?).to be_falsey
+
+        #Create the delete record
+        dr2.creates_delete_record
+
+        #Check to ensure items were created
+        expect(dr2.deletes_dir_exists?).to be_truthy
+        expect(dr2.deletes_record_exists?).to be_truthy
+      end
+
+      it "creates a delete record with a parent directory that has a .deletes directory that does not contain a delete record for this druid" do
+        #Expect there not to be a .deletes dir or file (the file expectation is redundant I know)
+        expect(dr2.deletes_dir_exists?).to be_falsey
+        expect(dr2.deletes_record_exists?).to be_falsey
+
+        #Creates the deletes dir and check
+        dr2.create_deletes_dir
+        expect(dr2.deletes_dir_exists?).to be_truthy
+        expect(dr2.deletes_record_exists?).to be_falsey
+
+        #Create the delete record
+        dr2.creates_delete_record
+
+        #Check to ensure items were created
+        expect(dr2.deletes_dir_exists?).to be_truthy
+        expect(dr2.deletes_record_exists?).to be_truthy
+      end
+
+      it "creates a delete record with a parent directory that does not have a .deletes directory and contains an older delete record" do
+        #Expect there not to be a .deletes dir or file (the file expectation is redundant I know)
+        expect(dr2.deletes_dir_exists?).to be_falsey
+        expect(dr2.deletes_record_exists?).to be_falsey
+
+        dr2.creates_delete_record
+        time = Time.now
+        expect(File.mtime(dr2.deletes_record_pathname)).to be <= time
+        sleep(1) #force a one second pause in case the machine is fast, since mtime only goes down to the second
+
+        dr2.creates_delete_record
+        #Should have a new newer deleted record
+        expect(File.mtime(dr2.deletes_record_pathname)).to be > time
+      end
+    end
+  end
+end