More sync tests and throw argument error son mismatch types or missing src.

Author: rofinn

src/path.jl

@@ -530,38 +530,61 @@ function sync(src::AbstractPath, dst::AbstractPath; kwargs...)
 end
 
 function sync(f::Function, src::AbstractPath, dst::AbstractPath; delete=false, overwrite=true)
-    # Create an index of all of the source files
-    src_paths = collect(walkpath(src))
-    index = Dict(
-        Tuple(setdiff(p.segments, src.segments)) => i for (i, p) in enumerate(src_paths)
-    )
+    # Throw an error if the source path doesn't exist at all
+    exists(src) || throw(ArgumentError("$src does not exist"))
+
+    # If the top level source is just a file then try to just sync that
+    # without calling walkpath
+    if isfile(src)
+        # If the destination exists then we should make sure it is a file and check
+        # if we should copy the source over.
+        if exists(dst)
+            isfile(dst) || throw(ArgumentError("$dst is not a file"))
+            if overwrite && f(src, dst)
+                cp(src, dst; force=true)
+            end
+        else
+            cp(src, dst)
+        end
+    else
+        isdir(src) || throw(ArgumentError("$src is neither a file or directory."))
+        if exists(dst) && !isdir(dst)
+            throw(ArgumentError("$dst is not a directory while $src is"))
+        end
 
-    if exists(dst)
-        for p in walkpath(dst)
-            k = Tuple(setdiff(p.segments, dst.segments))
+        # Create an index of all of the source files
+        src_paths = collect(walkpath(src))
+        index = Dict(
+            Tuple(setdiff(p.segments, src.segments)) => i for (i, p) in enumerate(src_paths)
+        )
 
-            if haskey(index, k)
-                src_path = src_paths[index[k]]
-                if overwrite && f(src_path, p)
-                    cp(src_path, p; force=true)
-                end
+        if exists(dst)
+            for p in walkpath(dst)
+                k = Tuple(setdiff(p.segments, dst.segments))
+
+                if haskey(index, k)
+                    src_path = src_paths[index[k]]
+                    if overwrite && f(src_path, p)
+                        cp(src_path, p; force=true)
+                    end
 
-                delete!(index, k)
-            elseif delete
-                rm(p; recursive=true)
+                    delete!(index, k)
+                elseif delete
+                    rm(p; recursive=true)
+                end
             end
-        end
 
-        # Finally, copy over files that don't exist at the destination
-        # But we need to iterate through it in a way that respects the original
-        # walkpath order otherwise we may end up trying to copy a file before its parents.
-        index_pairs = collect(pairs(index))
-        index_pairs = index_pairs[sortperm(last.(index_pairs))]
-        for (seg, i) in index_pairs
-            cp(src_paths[i], Path(dst, tuple(dst.segments..., seg...)); force=true)
+            # Finally, copy over files that don't exist at the destination
+            # But we need to iterate through it in a way that respects the original
+            # walkpath order otherwise we may end up trying to copy a file before its parents.
+            index_pairs = collect(pairs(index))
+            index_pairs = index_pairs[sortperm(last.(index_pairs))]
+            for (seg, i) in index_pairs
+                cp(src_paths[i], Path(dst, tuple(dst.segments..., seg...)); force=true)
+            end
+        else
+            cp(src, dst)
         end
-    else
-        cp(src, dst)
     end
 end
 

src/test.jl

@@ -612,57 +612,93 @@ module TestPaths
 
     function test_sync(ps::PathSet)
         @testset "sync" begin
-            # Base cp case
-            sync(ps.foo, ps.qux / "foo")
-            @test exists(ps.qux / "foo" / "baz.txt")
+            @testset "empty destination" begin
+                sync(ps.foo, ps.qux / "foo")
+                @test exists(ps.qux / "foo" / "baz.txt")
 
-            # Test that the copied baz file has a newer modified time
-            baz_t = modified(ps.qux / "foo" / "baz.txt")
-            @test modified(ps.baz) < baz_t
-
-            # Don't cp unchanged files when a new file is added
-            # NOTE: sleep before we make a new file, so it's clear that the
-            # modified time has changed.
-            sleep(1)
-            write(ps.foo / "test.txt", "New File")
-            sync(ps.foo, ps.qux / "foo")
-            @test exists(ps.qux / "foo" / "test.txt")
-            @test read(ps.qux / "foo" / "test.txt", String) == "New File"
-            @test modified(ps.qux / "foo" / "baz.txt") == baz_t
-            @test modified(ps.qux / "foo" / "test.txt") > baz_t
-
-            # Test not deleting a file on sync
-            rm(ps.foo / "test.txt")
-            sync(ps.foo, ps.qux / "foo")
-            @test exists(ps.qux / "foo" / "test.txt")
-
-            # Test passing delete flag
-            sync(ps.foo, ps.qux / "foo"; delete=true)
-            @test !exists(ps.qux / "foo" / "test.txt")
-            rm(ps.qux / "foo"; recursive=true)
+                # Test that the copied baz file has a newer modified time
+                baz_t = modified(ps.qux / "foo" / "baz.txt")
+                @test modified(ps.baz) < baz_t
+            end
+
+            @testset "empty source" begin
+                @test_throws ArgumentError sync(ps.root / "quux", ps.foo)
+            end
 
-            # Test a condtion where the index could reorder the walkpath order.
-            tmp_src = ps.root / "tmp-src"
-            mkdir(tmp_src)
-            src_file = tmp_src / "file1"
-            write(src_file, "Hello World!")
-
-            src_folder = tmp_src / "folder1"
-            mkdir(src_folder)
-            src_folder_file = src_folder / "file2"
-            write(src_folder_file, "") # empty file
-
-            src_folder2 = src_folder / "folder2"  # nested folders
-            mkdir(src_folder2)
-            src_folder2_file = src_folder2 / "file3"
-            write(src_folder2_file, "Test")
-
-            tmp_dst = ps.root / "tmp_dst"
-            mkdir(tmp_dst)
-            sync(tmp_src, tmp_dst)
-            @test exists(tmp_dst / "folder1" / "folder2" / "file3")
-            rm(tmp_src; recursive=true)
-            rm(tmp_dst; recursive=true)
+            @testset "new source" begin
+                # Don't cp unchanged files when a new file is added
+                # NOTE: sleep before we make a new file, so it's clear that the
+                # modified time has changed.
+                baz_t = modified(ps.qux / "foo" / "baz.txt")
+                sleep(1)
+                write(ps.foo / "test.txt", "New src")
+                sync(ps.foo, ps.qux / "foo")
+                @test exists(ps.qux / "foo" / "test.txt")
+                @test read(ps.qux / "foo" / "test.txt", String) == "New src"
+                @test modified(ps.qux / "foo" / "baz.txt") == baz_t
+                @test modified(ps.qux / "foo" / "test.txt") > baz_t
+            end
+
+            @testset "new destination" begin
+                # Newer file of the same size is likely the result of an upload which
+                # will always have a newer last modified time.
+                test_t = modified(ps.foo / "test.txt")
+                sleep(1)
+                write(ps.qux / "foo" / "test.txt", "New dst")
+                @test modified(ps.qux / "foo" / "test.txt") > test_t
+                sync(ps.foo, ps.qux / "foo")
+                @test read(ps.qux / "foo" / "test.txt", String) == "New dst"
+                @test modified(ps.qux / "foo" / "test.txt") > test_t
+            end
+
+            @testset "no delete" begin
+                # Test not deleting a file on sync
+                rm(ps.foo / "test.txt")
+                sync(ps.foo, ps.qux / "foo")
+                @test exists(ps.qux / "foo" / "test.txt")
+            end
+
+            @testset "delete" begin
+                # Test passing delete flag
+                sync(ps.foo, ps.qux / "foo"; delete=true)
+                @test !exists(ps.qux / "foo" / "test.txt")
+                rm(ps.qux / "foo"; recursive=true)
+            end
+
+            @testset "mixed types" begin
+                @testset "directory -> file" begin
+                    @test_throws ArgumentError sync(ps.foo, ps.quux)
+                end
+
+                @testset "file -> directory" begin
+                    @test_throws ArgumentError sync(ps.quux, ps.foo)
+                end
+            end
+
+            @testset "walkpath order" begin
+                # Test a condtion where the index could reorder the walkpath order.
+                tmp_src = ps.root / "tmp-src"
+                mkdir(tmp_src)
+                src_file = tmp_src / "file1"
+                write(src_file, "Hello World!")
+
+                src_folder = tmp_src / "folder1"
+                mkdir(src_folder)
+                src_folder_file = src_folder / "file2"
+                write(src_folder_file, "") # empty file
+
+                src_folder2 = src_folder / "folder2"  # nested folders
+                mkdir(src_folder2)
+                src_folder2_file = src_folder2 / "file3"
+                write(src_folder2_file, "Test")
+
+                tmp_dst = ps.root / "tmp_dst"
+                mkdir(tmp_dst)
+                sync(tmp_src, tmp_dst)
+                @test exists(tmp_dst / "folder1" / "folder2" / "file3")
+                rm(tmp_src; recursive=true)
+                rm(tmp_dst; recursive=true)
+            end
         end
     end