add tests

Author: tmillr

lua/plenary/path.lua

@@ -534,8 +534,17 @@ function Path:rename(opts)
   -- The behavior here may differ, as an error will be thrown regardless.
 
   local self_lstat, new_lstat, status, errmsg
+  vim.validate { opts = { opts, "t" } }
+  vim.validate {
+    ["opts.new_name"] = {
+      opts.new_name,
+      function(val)
+        return Path.is_path(val) or (type(val) == "string" and val ~= "")
+      end,
+      "string or Path object",
+    },
+  }
   opts = opts or {}
-  assert(opts.new_name and opts.new_name ~= "", "Please provide the new name!")
   self_lstat, errmsg = uv.fs_lstat(self.filename)
 
   -- Cannot rename a non-existing path (lstat is needed here, `Path:exists()`
@@ -544,6 +553,10 @@ function Path:rename(opts)
 
   local new_path = Path:new(opts.new_name)
   new_lstat, errmsg = uv.fs_lstat(new_path.filename)
+  local same_inode = false
+  if new_lstat then
+    same_inode = self_lstat.ino == new_lstat.ino and self_lstat.dev == new_lstat.dev and self_lstat.gen == new_lstat.gen
+  end
 
   -- The following allows changing only case (e.g. fname -> Fname) on
   -- case-insensitive file systems, otherwise throwing if `new_name` exists as
@@ -558,19 +571,14 @@ function Path:rename(opts)
   -- idk for certain what happens b/c it needs to be tested on a case-sensitive
   -- fs, but it should simply result in a successful no-op according to the
   -- `rename(2)` docs, at least on Linux anyway).
-  assert(not new_lstat or (self_lstat.ino == new_lstat.ino), "File or directory already exists!")
+  assert(not new_lstat or same_inode, "File or directory already exists!")
 
-  status, errmsg = uv.fs_rename(self:absolute(), new_path:absolute())
+  status, errmsg = uv.fs_rename(tostring(self), tostring(new_path))
   assert(status, ("%s: Rename failed!"):format(errmsg))
 
   -- NOTE: `uv.fs_rename()` _can_ return success even if no rename actually
-  -- occurred (see rename(2)), and this is not an error. So we're not changing
-  -- `self.filename` if it didn't.
-  if not uv.fs_lstat(self.filename) then
-    self = Path:new(new_path.filename)
-  end
-
-  return self
+  -- occurred (see rename(2)), and this is not an error.
+  return Path:new(new_path)
 end
 
 --- Copy files or folders with defaults akin to GNU's `cp`.

tests/plenary/path_spec.lua

@@ -415,7 +415,6 @@ describe("Path", function()
     end)
   end)
 
-  -- TODO: tests new behavior, allows rename to self
   describe("rename", function()
     local env = new_env()
     after_each(env.cleanup)
@@ -497,7 +496,7 @@ describe("Path", function()
     -- BUG: introduced in f71ee45 (#90)
     it("should consider bad symlink as existing, and throw", function()
       local before, after, non_existing = env.new_path { touch = true }, env.new_path(), env.new_path()
-      vim.loop.fs_symlink(non_existing.filename, after.filename)
+      assert(vim.loop.fs_symlink(non_existing.filename, after.filename))
       assert.is.True(not not vim.loop.fs_lstat(after.filename))
       assert.errors(function()
         before:rename { new_name = after }
@@ -511,9 +510,38 @@ describe("Path", function()
       assert.is.False(before:exists())
       assert.is.True(after:exists())
       assert.is.True(Path.is_path(new))
+      assert.is.True(new:exists())
       assert.are.equal(before.filename, before_filename)
-      assert.are.Not.equal(new, after)
-      assert.are.Not.equal(new, before)
+      assert.are.equal(after.filename, new.filename)
+    end)
+
+    it("should allow changing only case of filename, regardless of fs case-sensitivity", function()
+      local before = env.new_path { filename = ".__some_file" }
+      assert.is.False(before:exists())
+      before:touch()
+      local before_filename_realpath = assert(vim.loop.fs_realpath(before.filename))
+      local after = env.new_path { filename = before.filename:upper() }
+      assert.does.Not.error(function()
+        before:rename { new_name = after }
+      end)
+      assert.are.equal(
+        before_filename_realpath:sub(1, #before_filename_realpath - #before.filename) .. after.filename,
+        assert(vim.loop.fs_realpath(after.filename))
+      )
+    end)
+
+    it("rename to hardlink of the same file should be a successful no-op", function()
+      local before, after = env.new_path { touch = true }, env.new_path {}
+      assert(vim.loop.fs_link(before.filename, after.filename))
+      assert.is.True(after:exists())
+      local new
+      assert.does.Not.error(function()
+        new = before:rename { new_name = after }
+      end)
+      assert.is.True(before:exists())
+      assert.is.True(after:exists())
+      assert.is.True(Path.is_path(new))
+      assert.are.equal(new.filename, after.filename)
     end)
   end)