fs: Allow sync of a file and a directory with the same name

When sorting fs.DirEntries we sort by DirEntry type and
when synchronizing files let the directories be before objects,
so when the destintation fs doesn't support duplicate names,
we will only lose duplicated object instead of whole directory.

The enables synchronisation to work with a file and a directory of the same name
which is reasonably common on bucket based remotes.

fs/march/march_test.go

@@ -3,10 +3,12 @@
 package march
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 
 	"github.com/ncw/rclone/fs"
+	"github.com/ncw/rclone/fstest/mockdir"
 	"github.com/ncw/rclone/fstest/mockobject"
 	"github.com/stretchr/testify/assert"
 )
@@ -38,11 +40,13 @@ func TestNewMatchEntries(t *testing.T) {
 
 func TestMatchListings(t *testing.T) {
 	var (
-		a = mockobject.Object("a")
-		A = mockobject.Object("A")
-		b = mockobject.Object("b")
-		c = mockobject.Object("c")
-		d = mockobject.Object("d")
+		a    = mockobject.Object("a")
+		A    = mockobject.Object("A")
+		b    = mockobject.Object("b")
+		c    = mockobject.Object("c")
+		d    = mockobject.Object("d")
+		dirA = mockdir.New("A")
+		dirb = mockdir.New("b")
 	)
 
 	for _, test := range []struct {
@@ -147,25 +151,88 @@ func TestMatchListings(t *testing.T) {
 			},
 			transforms: []matchTransformFn{strings.ToLower},
 		},
+		{
+			what: "File and directory are not duplicates - srcOnly",
+			input: fs.DirEntries{
+				dirA, nil,
+				A, nil,
+			},
+			srcOnly: fs.DirEntries{
+				dirA,
+				A,
+			},
+		},
+		{
+			what: "File and directory are not duplicates - matches",
+			input: fs.DirEntries{
+				dirA, dirA,
+				A, A,
+			},
+			matches: []matchPair{
+				{dirA, dirA},
+				{A, A},
+			},
+		},
+		{
+			what: "Sync with directory #1",
+			input: fs.DirEntries{
+				dirA, nil,
+				A, nil,
+				b, b,
+				nil, c,
+				nil, d,
+			},
+			srcOnly: fs.DirEntries{
+				dirA,
+				A,
+			},
+			dstOnly: fs.DirEntries{
+				c, d,
+			},
+			matches: []matchPair{
+				{b, b},
+			},
+		},
+		{
+			what: "Sync with 2 directories",
+			input: fs.DirEntries{
+				dirA, dirA,
+				A, nil,
+				nil, dirb,
+				nil, b,
+			},
+			srcOnly: fs.DirEntries{
+				A,
+			},
+			dstOnly: fs.DirEntries{
+				dirb,
+				b,
+			},
+			matches: []matchPair{
+				{dirA, dirA},
+			},
+		},
 	} {
-		var srcList, dstList fs.DirEntries
-		for i := 0; i < len(test.input); i += 2 {
-			src, dst := test.input[i], test.input[i+1]
-			if src != nil {
-				srcList = append(srcList, src)
+		t.Run(fmt.Sprintf("TestMatchListings-%s", test.what), func(t *testing.T) {
+			var srcList, dstList fs.DirEntries
+			for i := 0; i < len(test.input); i += 2 {
+				src, dst := test.input[i], test.input[i+1]
+				if src != nil {
+					srcList = append(srcList, src)
+				}
+				if dst != nil {
+					dstList = append(dstList, dst)
+				}
 			}
-			if dst != nil {
-				dstList = append(dstList, dst)
-			}
-		}
-		srcOnly, dstOnly, matches := matchListings(srcList, dstList, test.transforms)
-		assert.Equal(t, test.srcOnly, srcOnly, test.what)
-		assert.Equal(t, test.dstOnly, dstOnly, test.what)
-		assert.Equal(t, test.matches, matches, test.what)
-		// now swap src and dst
-		dstOnly, srcOnly, matches = matchListings(dstList, srcList, test.transforms)
-		assert.Equal(t, test.srcOnly, srcOnly, test.what)
-		assert.Equal(t, test.dstOnly, dstOnly, test.what)
-		assert.Equal(t, test.matches, matches, test.what)
+			srcOnly, dstOnly, matches := matchListings(srcList, dstList, test.transforms)
+			assert.Equal(t, test.srcOnly, srcOnly, test.what, "srcOnly differ")
+			assert.Equal(t, test.dstOnly, dstOnly, test.what, "dstOnly differ")
+			assert.Equal(t, test.matches, matches, test.what, "matches differ")
+			// now swap src and dst
+			dstOnly, srcOnly, matches = matchListings(dstList, srcList, test.transforms)
+			assert.Equal(t, test.srcOnly, srcOnly, test.what, "srcOnly differ")
+			assert.Equal(t, test.dstOnly, dstOnly, test.what, "dstOnly differ")
+			assert.Equal(t, test.matches, matches, test.what, "matches differ")
+		})
 	}
 }