automateit 0.70923

data/spec/integration/package_manager_spec.rb

@@ -0,0 +1,104 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "/../spec_helper.rb")
+
+PACKAGE_FOUND_ERROR = %q{ERROR: Found the '%s' package installed for %s. You're probably not using this obscure package and should remove it so that this test can run. In the unlikely event that you actually rely on this package, change the spec to test with another unused package.}
+PACKAGE_DRIVER_MISSING_ERROR = %{NOTE: Can't check %s on this platform, #{__FILE__}}
+
+if not INTERPRETER.euid?
+  puts "NOTE: Can't check 'euid' on this platform, #{__FILE__}"
+elsif not INTERPRETER.superuser?
+  puts "NOTE: Must be root to check #{__FILE__}"
+else
+  describe "AutomateIt::PackageManager", :shared => true do
+    before(:all) do
+      @level = Logger::WARN
+      @a = AutomateIt.new(:verbosity => @level)
+      @m = @a.package_manager
+      @fake_package = "not_a_real_package"
+    end
+
+    after(:all) do
+      @d.uninstall(@package, :quiet => true)
+    end
+
+    # Some specs below leave side-effects which others depend on, although
+    # these are clearly documented within the specs. This is necessary
+    # because doing proper setup/teardown for each test would make it run 5x
+    # slower and take over a minute. Although this approach is problematic,
+    # the performance boost is worth it.
+
+    it "should not install an invalid package" do
+      @d.log.silence(Logger::FATAL) do
+        lambda{ @d.install(@fake_package, :quiet => true) }.should raise_error(ArgumentError)
+      end
+    end
+
+    it "should install a package" do
+      @d.install(@package, :quiet => true).should be_true
+      # Leaves behind an installed package
+    end
+
+    it "should not re-install an installed package" do
+      # Expects package to be installed
+      @d.install(@package, :quiet => true).should be_false
+    end
+
+    it "should find an installed package" do
+      # Expects package to be installed
+      @d.installed?(@package).should be_true
+      @d.not_installed?(@package).should be_false
+    end
+
+    it "should not find a package that's not installed" do
+      @d.installed?(@fake_package).should be_false
+      @d.not_installed?(@fake_package).should be_true
+    end
+
+    it "should find group of packages" do
+      @d.installed?(@package, @fake_package, :details => true).should == [false, [@package]]
+      @d.not_installed?(@package, @fake_package, :details => true).should == [false, [@fake_package]]
+      # Leaves behind an installed package
+    end
+
+    it "should uninstall a package" do
+      # Expects package to be installed
+      @d.uninstall(@package, :quiet => true).should be_true
+    end
+
+    it "should not uninstall a package that's not installed" do
+      @d.uninstall(@package, :quiet => true).should be_false
+    end
+  end
+
+  #-----------------------------------------------------------------------
+
+  targets = {
+    :apt => "nomarch", # Obscure package for extracting ARC files from the 80's
+    :yum => "nomarch", # Obscure package for extracting ARC files from the 80's
+    :portage => "arc", # Obscure package for extracting ARC files from the 80's
+    :gem => "s33r", # Alpha-grade package its author deprecated in favor of another
+    :egg => "_sre.py", # Slower reimplementation of ancient Python Regexps
+    ### :cpan => "Acme::please", # Insane gimmick port of intercal's please statements
+  }
+
+  if INTERPRETER.tagged?(:centos)
+    # CentOS lacks "nomarch", so use a less obscure archiver from the early 90's.
+    targets[:yum] = "arj"
+  end
+
+  targets.each_pair do |driver_token, package|
+    driver = INTERPRETER.package_manager[driver_token]
+    if driver.available?
+      describe driver.class.to_s do
+        it_should_behave_like "AutomateIt::PackageManager"
+
+        before(:all) do
+          @d = @m[driver_token]
+          @package = package
+          raise PACKAGE_FOUND_ERROR % [@package, @d.class] if @d.installed?(@package)
+        end
+      end
+    else
+      puts PACKAGE_DRIVER_MISSING_ERROR % driver.class
+    end
+  end
+end

data/spec/integration/platform_manager_spec.rb

@@ -0,0 +1,69 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "/../spec_helper.rb")
+
+# TODO PlatformManager spec -- split entire spec into multiple, driver-specific ones.
+
+begin
+  raise IndexError unless String === INTERPRETER.platform_manager.query("os")
+
+  describe "AutomateIt::PlatformManager" do
+    before(:all) do
+      @a = AutomateIt.new
+      @m = @a.platform_manager
+    end
+
+    it "should query os" do
+      @m.query("os").should be_a_kind_of(String)
+    end
+
+    it "should query arch" do
+      @m.query(:arch).should be_a_kind_of(String)
+    end
+
+    it "should query os and arch" do
+      @m.query("os#arch").should be_a_kind_of(String)
+    end
+
+    begin
+      raise IndexError unless String === INTERPRETER.platform_manager.query("distro")
+
+      it "should query distro" do
+        @m.query("distro").should be_a_kind_of(String)
+      end
+
+      it "should query release" do
+        @m.query(:release).should be_a_kind_of(String)
+      end
+
+      it "should fail on invalid LSB output" do
+        if AutomateIt::PlatformManager::LSB === @m.driver_for(:query, :release)
+          # XXX mocking a shared variable breaks it because the mock doesn't go away
+          m = AutomateIt.new.platform_manager
+          m[:lsb].send(:instance_eval, "@struct.delete(:release)")
+          m[:lsb].class.send(:class_eval, "@@struct_cache.delete(:release)")
+          m[:lsb].should_receive(:_read_lsb_release_output).and_return("not : valid : yaml")
+          callback = lambda{ m[:lsb].setup; m[:lsb].query(:release) }
+          if RUBY_PLATFORM == "java"
+            callback.should raise_error # YAML throws a native, internal error
+          else
+            callback.should raise_error(ArgumentError, /invalid YAML/)
+          end
+        end
+      end
+
+      it "should query combination of os, arch, distro and release" do
+        result = @m.query("os#arch#distro#release")
+        result.should be_a_kind_of(String)
+        elements = result.split(/_/)
+        elements.size.should >= 4
+        for element in elements
+          element.should be_a_kind_of(String)
+          element.size.should > 0
+        end
+      end
+    rescue NotImplementedError, IndexError
+      puts "NOTE: Can't check 'distro' query on this platform, #{__FILE__}"
+    end
+  end
+rescue NotImplementedError, IndexError
+  puts "NOTE: Can't check 'query' on this platform, #{__FILE__}"
+end

data/spec/integration/service_manager_sysv_spec.rb

@@ -0,0 +1,115 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "/../spec_helper.rb")
+
+if not INTERPRETER.euid?
+  puts "NOTE: Can't check 'euid' on this platform, #{__FILE__}"
+elsif not INTERPRETER.superuser?
+  puts "NOTE: Must be root to check #{__FILE__}"
+elsif not INTERPRETER.service_manager[:sysv].available?
+  puts "NOTE: Can't check ServiceManager::SYSV on this platform, #{__FILE__}"
+else
+  describe "AutomateIt::ServiceManager::SYSV" do
+    begin
+      INTERPRETER.service_manager.driver_for(:enabled?, @service_name)
+      @has_enable = true
+    rescue NotImplementedError
+      @has_enable = false
+      puts "NOTE: Can't check 'enabled?' on this platform, #{__FILE__}"
+    end
+
+    before(:all) do
+      @a = AutomateIt.new(:verbosity => Logger::WARN)
+      @m = @a.service_manager
+
+      @service_name = "automateit_service_sysv_test"
+      @service_file = "/etc/init.d/"+@service_name
+      @source_file = File.join(File.dirname(__FILE__), "..", "extras", @service_name)
+
+      FileUtils.cp(@source_file, @service_file)
+      FileUtils.chmod(0755, @service_file)
+    end
+
+    before(:each) do
+      @m.stop(@service_name, :quiet => true) if @m.running?(@service_name)
+    end
+
+    after(:all) do
+      @m.stop(@service_name, :quiet => true) if @m.running?(@service_name)
+      FileUtils.rm(@service_file) if File.exists?(@service_file)
+    end
+
+    it "should start a service" do
+      @m.start(@service_name, :quiet => true).should be_true
+    end
+
+    it "should not start an already running service" do
+      @m.start(@service_name, :quiet => true).should be_true
+      @m.start(@service_name).should be_false
+    end
+
+    it "should stop a service" do
+      @m.start(@service_name, :quiet => true).should be_true
+      @m.stop(@service_name, :quiet => true).should be_true
+    end
+
+    it "should not stop a service that's not running" do
+      @m.stop(@service_name).should be_false
+    end
+
+    it "should identify a non-running service" do
+      @m.running?(@service_name).should be_false
+    end
+
+    it "should identify a running service" do
+      @m.start(@service_name, :quiet => true).should be_true
+      @m.running?(@service_name).should be_true
+    end
+
+    if @has_enable
+      # It's more correct to disable the service using before/after, but the
+      # platform-specific scripts are ridiculously slow, so manually disabling
+      # the service only when necessary significantly speeds the test.
+      @disable_manually = true
+
+      before(:each) do
+        @m.disable(@service_name, :quiet => true) if not @disable_manually
+      end
+
+      after(:all) do
+        @m.disable(@service_name, :quiet => true) if not @disable_manually
+      end
+
+      it "should enable a service" do
+        @m.enable(@service_name, :quiet => true).should be_true
+        # Tear down
+        @m.disable(@service_name, :quiet => true).should be_true if @disable_manually
+      end
+
+      it "should not enable an enabled service" do
+        @m.enable(@service_name, :quiet => true).should be_true
+        @m.enable(@service_name, :quiet => true).should be_false
+        # Tear down
+        @m.disable(@service_name, :quiet => true).should be_true if @disable_manually
+      end
+
+      it "should disable a service" do
+        @m.enable(@service_name, :quiet => true).should be_true
+        @m.disable(@service_name, :quiet => true).should be_true
+      end
+
+      it "should not disable a disabled service" do
+        @m.disable(@service_name, :quiet => true).should be_false
+      end
+
+      it "should identify a disabled service" do
+        @m.enabled?(@service_name).should be_false
+      end
+
+      it "should identify an enabled service" do
+        @m.enable(@service_name, :quiet => true).should be_true
+        @m.enabled?(@service_name).should be_true
+        # Tear down
+        @m.disable(@service_name, :quiet => true).should be_true if @disable_manually
+      end
+    end
+  end
+end

data/spec/integration/shell_manager_spec.rb

@@ -0,0 +1,471 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "/../spec_helper.rb")
+
+describe AutomateIt::ShellManager, :shared => true do
+  before(:all) do
+    @a = AutomateIt.new(:verbosity => Logger::WARN)
+    @m = @a.shell_manager
+  end
+end
+
+describe AutomateIt::ShellManager, " with sh and which" do
+  it_should_behave_like "AutomateIt::ShellManager"
+
+  begin
+    INTERPRETER.which("true")
+    INTERPRETER.which("false")
+
+    it "should run shell commands and detect their exit status (sh)" do
+      @m.sh("true").should be_true
+      @m.sh("false").should be_false
+    end
+  rescue NotImplementedError
+    puts "NOTE: Can't check 'sh' on this platform, #{__FILE__}"
+  end
+
+  unless INTERPRETER.shell_manager.available?(:which)
+    puts "NOTE: Can't use 'which' on this platform in #{__FILE__}"
+  else
+    it "should find which program is in the path (which)" do
+      @m.which("sh").match(/.\/sh$/).nil?.should be_false
+    end
+
+    it "should not find programs that aren't in the path (which)" do
+      @m.which("not_a_real_program").should be_nil
+    end
+
+    it "should throw exception if command isn't in path (which!)" do
+      lambda{ @m.which!("not_a_real_program") }.should raise_error(ArgumentError, /not_a_real_program/)
+    end
+  end
+end
+
+describe AutomateIt::ShellManager, " in general" do
+  it_should_behave_like "AutomateIt::ShellManager"
+
+  it "should change directories (cd)" do
+    before = Dir.pwd
+    target = Pathname.new("/").expand_path.to_s
+    @m.cd(target)
+    Dir.pwd.should == target
+    @m.cd(before)
+    Dir.pwd.should == before
+  end
+
+  it "should change directories using a block (cd)" do
+    before = Dir.pwd
+    target = Pathname.new("/").expand_path.to_s
+    @m.cd(target) do
+      Dir.pwd.should == target
+    end
+    Dir.pwd.should == before
+  end
+
+  it "should locate the current directory (pwd)" do
+    @m.pwd.should == Dir.pwd
+  end
+
+  it "should create a directory when needed (mkdir)" do
+    @m.mktempdircd do
+      target = "foo"
+      File.directory?(target).should be_false
+
+      @m.mkdir(target).should == [target]
+      File.directory?(target).should be_true
+
+      @m.mkdir(target).should be_false
+    end
+  end
+
+  it "should create nested directories when needed (mkdir_p)" do
+    @m.mktempdircd do
+      target = "foo/bar/baz"
+      File.directory?(target).should be_false
+
+      @m.mkdir_p(target).should == [target]
+      File.directory?(target).should be_true
+
+      @m.mkdir_p(target).should be_false
+    end
+  end
+
+  it "should remove directory when needed (rmdir)" do
+    @m.mktempdircd do
+      target = "foo"
+      @m.mkdir(target).should == [target]
+
+      @m.rmdir(target).should == [target]
+      File.directory?(target).should be_false
+    end
+  end
+
+  it "should install a file to a file (install)" do
+    @m.mktempdircd do
+      source = "foo"
+      target = "bar"
+      mode1 = 0640 if @m.provides_mode?
+      mode2 = 0100640
+
+      @a.render(:text => "Hello", :to => source)
+      File.exists?(source).should be_true
+      File.exists?(target).should be_false
+
+      @a.install(source, target, mode1).should == source
+      File.exists?(target).should be_true
+      File.stat(target).mode.should == mode2 if @m.provides_mode?
+
+      @a.install(source, target, mode1).should be_false
+    end
+  end
+
+  it "should copy a file to file (cp)" do
+    @m.mktempdircd do
+      source = "foo"
+      target = "bar"
+
+      @a.render(:text => "Hello", :to => source)
+      File.exists?(source).should be_true
+      File.exists?(target).should be_false
+
+      @a.cp(source, target).should == source
+      File.exists?(target).should be_true
+
+      @a.cp(source, target).should be_false
+    end
+  end
+
+  it "should copy a file to a directory (cp)" do
+    @m.mktempdircd do
+      source = "foo"
+      target = "bar"
+
+      @a.render(:text => "Hello", :to => source)
+      @a.mkdir(target)
+      File.exists?(source).should be_true
+      File.exists?(target).should be_true
+
+      @a.cp(source, target).should == source
+      File.exists?("bar/foo").should be_true
+
+      @a.cp(source, target).should be_false
+    end
+  end
+
+  it "should copy files to a directory (cp)" do
+    @m.mktempdircd do
+      source1 = "foo"
+      source2 = "bar"
+      target = "baz"
+
+      @a.render(:text => "Hello", :to => source1)
+      @a.render(:text => "Hello", :to => source2)
+      @a.mkdir(target)
+
+      @a.cp([source1, source2], target).should == [source1, source2]
+      File.exists?("baz/foo").should be_true
+      File.exists?("baz/bar").should be_true
+
+      @a.cp([source1, source2], target).should be_false
+    end
+  end
+
+  it "should copy directory to a directory (cp)" do
+    @m.mktempdircd do
+      source_dir = "feh"
+      source_file1 = "feh/file1"
+      source_file2 = "feh/file2"
+      target_dir = "meh"
+
+      @a.mkdir(source_dir)
+      @a.render(:text => "Hello", :to => source_file1)
+      @a.render(:text => "Hello", :to => source_file2)
+      @a.mkdir(target_dir)
+
+      @a.cp(source_dir, target_dir).should == source_dir
+      File.exists?("meh/feh/file1").should be_true
+      File.exists?("meh/feh/file2").should be_true
+
+      @a.cp(source_dir, target_dir).should be_false
+    end
+  end
+
+  # TODO implement umask spec
+
+  # TODO implement gap
+
+  it "should move files (mv)" do
+    @m.mktempdircd do
+      file1 = "foo"
+      file2 = "bar"
+      @m.touch(file1)
+      File.exists?(file1).should be_true
+
+      @m.mv(file1, file2).should == file1
+      File.exists?(file1).should be_false
+      File.exists?(file2).should be_true
+
+      @m.mv(file1, file2).should be_false
+    end
+  end
+
+  it "should delete files (rm)" do
+    @m.mktempdircd do
+      file1 = "foo"
+      file2 = "bar"
+      @m.touch(file1)
+      @m.touch(file2)
+      File.exists?(file1).should be_true
+      File.exists?(file2).should be_true
+
+      @m.rm([file1, file2]) == [file1, file2]
+      File.exists?(file1).should be_false
+      File.exists?(file2).should be_false
+    end
+  end
+
+  it "should delete recursively (rm_r)" do
+    @m.mktempdircd do
+      dir = "foo/bar"
+      file = dir+"/baz"
+      @m.mkdir_p(dir)
+      @m.touch(file)
+      File.exists?(file).should be_true
+      File.exists?(dir).should be_true
+
+      @m.rm_r(dir) == [dir, file]
+      File.exists?(file).should be_false
+      File.exists?(dir).should be_false
+    end
+  end
+
+  it "should delete recursively and forcefully (rm_rf)" do
+    @m.mktempdircd do
+      dir = "foo/bar"
+      file = dir+"/baz"
+      @m.mkdir_p(dir)
+      @m.touch(file)
+      File.exists?(file).should be_true
+      File.exists?(dir).should be_true
+
+      @m.rm_rf(dir) == [file, dir]
+      File.exists?(file).should be_false
+      File.exists?(dir).should be_false
+    end
+  end
+
+  unless INTERPRETER.shell_manager.provides_mode?
+    puts "NOTE: Can't check permission modes on this platform, #{__FILE__}"
+  else
+    it "should change the permissions of files (chmod)" do
+      @m.mktempdircd do
+        target = "foo"
+        mode = 0654
+        @m.touch(target)
+        (File.stat(target).mode ^ (mode | 0100000)).zero?.should be_false
+
+        @m.chmod(mode, target).should == target
+        (File.stat(target).mode ^ (mode | 0100000)).zero?.should be_true
+
+        @m.chmod(mode, target).should be_false
+      end
+    end
+
+    it "should change the permissions of files recursively (chmod_R)" do
+      @m.mktempdircd do
+        mode = 0754
+        dir = "foo/bar"
+        file = dir+"/baz"
+        @m.mkdir_p(dir)
+        @m.touch(file)
+        File.exists?(file).should be_true
+        File.exists?(dir).should be_true
+        (File.stat(file).mode ^ (mode | 0100000)).zero?.should be_false
+        (File.stat(dir).mode ^ (mode | 040000)).zero?.should be_false
+
+        @m.chmod_R(mode, dir).should == dir
+        (File.stat(file).mode ^ (mode | 0100000)).zero?.should be_true
+        (File.stat(dir).mode ^ (mode | 04000)).zero?.should be_false
+
+        @m.chmod_R(mode, dir).should be_false
+      end
+    end
+  end
+
+  it "should create files and change their timestamps (touch)" do
+    @m.mktempdircd do
+      target = "foo"
+      File.exists?(target).should be_false
+
+      @m.touch(target)
+      File.exists?(target).should be_true
+      before = File.mtime(target)
+
+      @m.touch(target)
+      after = File.mtime(target)
+      before.should <= after
+    end
+  end
+end
+
+describe AutomateIt::ShellManager, " when managing permissions" do
+  if not INTERPRETER.euid?
+    puts "NOTE: Can't check 'euid' on this platform, #{__FILE__}"
+  elsif not INTERPRETER.shell_manager.provides_ownership?
+    puts "NOTE: Can't check ownership on this platform, #{__FILE__}"
+  elsif INTERPRETER.superuser?
+    it_should_behave_like "AutomateIt::ShellManager"
+
+    before(:all) do
+      @pwent, @grent = find_mortal_pwent_and_grent
+      @user =  @pwent.name
+      @uid = @pwent.uid
+      @group = @grent.name
+      @gid = @grent.gid
+    end
+
+    # Return a pwent and grent of a non-root user
+    def find_mortal_pwent_and_grent
+      while true
+        pwent = Etc.getpwent
+        # Root is usually 0, but Darwin's users can have negative UIDs
+        break if pwent.uid > 0
+      end
+      Etc.endpwent
+      grent = Etc.getgrgid(pwent.gid)
+      return [pwent, grent]
+    end
+
+    it "should change the ownership of files (chown)" do
+      @m.mktempdircd do
+        target = "foo"
+
+        @m.touch(target)
+        stat = File.stat(target)
+        (stat.uid == @uid).should be_false
+        (stat.gid == @gid).should be_false
+
+        @m.chown(@user, @group, target).should == target
+        stat = File.stat(target)
+        (stat.uid == @uid).should be_true
+        (stat.gid == @gid).should be_true
+
+        @m.chown(@uid, @group, target).should be_false
+      end
+    end
+
+    it "should change the ownership of files recursively (chown_R)" do
+      @m.mktempdircd do
+        dir = "foo/bar"
+        file = dir+"/baz"
+
+        @m.mkdir_p(dir)
+        @m.touch(file)
+        File.exists?(file).should be_true
+        File.exists?(dir).should be_true
+        stat = File.stat(file)
+        (stat.uid == @uid).should be_false
+        (stat.gid == @gid).should be_false
+        stat = File.stat(dir)
+        (stat.uid == @uid).should be_false
+        (stat.gid == @gid).should be_false
+
+        @m.chown_R(@uid, @group, dir).should == dir
+        stat = File.stat(file)
+        (stat.uid == @uid).should be_true
+        (stat.gid == @gid).should be_true
+        stat = File.stat(dir)
+        (stat.uid == @uid).should be_true
+        (stat.gid == @gid).should be_true
+
+        @m.chown_R(@uid, @group, dir).should be_false
+      end
+    end
+
+    it "should translate :owner to :user for Cfengine refugees" do
+      @m.mktempdircd do
+        dir = "foo/bar"
+        file = dir+"/baz"
+
+        @m.mkdir_p(dir)
+        @m.touch(file)
+
+        @m.chperm(dir, :recursive => true, :owner => @user, :group => @group).should == dir
+
+        stat = File.stat(file)
+        (stat.uid == @uid).should be_true
+        (stat.gid == @gid).should be_true
+        stat = File.stat(dir)
+        (stat.uid == @uid).should be_true
+        (stat.gid == @gid).should be_true
+      end
+    end
+  else
+    puts "NOTE: Must be root to check 'chown' in #{__FILE__}"
+  end
+end
+
+describe AutomateIt::ShellManager, " when managing hard links" do
+  if not INTERPRETER.shell_manager.available?(:ln)
+    puts "NOTE: Can't check hard links on this platform, #{__FILE__}"
+  else
+    it_should_behave_like "AutomateIt::ShellManager"
+
+    it "should create hard links when needed (ln)" do
+      @m.mktempdircd do
+        source = "foo"
+        target = "bar"
+        @m.touch(source)
+        File.exists?(source).should be_true
+        File.exists?(target).should be_false
+
+        @m.ln(source, target).should == source
+        File.stat(target).nlink.should > 1
+
+        @m.ln(source, target).should be_false
+      end
+    end
+  end
+end
+
+describe AutomateIt::ShellManager, " when managing symbolic links" do
+  if not INTERPRETER.shell_manager.available?(:ln_s)
+    puts "NOTE: Can't check symbolic links on this platform, #{__FILE__}"
+  else
+    it_should_behave_like "AutomateIt::ShellManager"
+
+    it "should create symlinks when needed (ln_s)" do
+      @m.mktempdircd do
+        source = "foo"
+        target = "bar"
+        @m.touch(source)
+        File.exists?(source).should be_true
+        File.exists?(target).should be_false
+
+        @m.ln_s(source, target).should == source
+        File.symlink?(target).should be_true
+        Pathname.new(target).realpath == Pathname.new(source).realpath
+
+        @m.ln_s(source, target).should be_false
+      end
+    end
+
+    it "should create symlinks that replace existing entry (ln_sf)" do
+      @m.mktempdircd do
+        source = "foo"
+        intermediate = "baz"
+        target = "bar"
+        @m.touch(source)
+        @m.touch(intermediate)
+        File.exists?(source).should be_true
+        File.exists?(intermediate).should be_true
+        File.exists?(target).should be_false
+
+        @m.ln_s(intermediate, target).should == intermediate
+        File.symlink?(target).should be_true
+
+        @m.ln_sf(source, target).should == source
+        File.symlink?(target).should be_true
+        Pathname.new(target).realpath == Pathname.new(source).realpath
+      end
+    end
+  end
+end