// Create a file and sync it. Change the last modified date and resync. // If we're only doing sync by size and checksum, we expect nothing to // to be transferred on the second sync. func TestSyncBasedOnCheckSum(t *testing.T) { r := NewRun(t) defer r.Finalise() fs.Config.CheckSum = true defer func() { fs.Config.CheckSum = false }() file1 := r.WriteFile("check sum", "", t1) fstest.CheckItems(t, r.flocal, file1) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) require.NoError(t, err) // We should have transferred exactly one file. assert.Equal(t, int64(1), fs.Stats.GetTransfers()) fstest.CheckItems(t, r.fremote, file1) // Change last modified date only file2 := r.WriteFile("check sum", "", t2) fstest.CheckItems(t, r.flocal, file2) fs.Stats.ResetCounters() err = fs.Sync(r.fremote, r.flocal) require.NoError(t, err) // We should have transferred no files assert.Equal(t, int64(0), fs.Stats.GetTransfers()) fstest.CheckItems(t, r.flocal, file2) fstest.CheckItems(t, r.fremote, file1) }
// Test with exclude and delete excluded func TestSyncWithExcludeAndDeleteExcluded(t *testing.T) { r := NewRun(t) defer r.Finalise() file1 := r.WriteBoth("potato2", "------------------------------------------------------------", t1) // 60 bytes file2 := r.WriteBoth("empty space", "", t2) file3 := r.WriteBoth("enormous", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", t1) // 100 bytes fstest.CheckItems(t, r.fremote, file1, file2, file3) fstest.CheckItems(t, r.flocal, file1, file2, file3) fs.Config.Filter.MaxSize = 40 fs.Config.Filter.DeleteExcluded = true defer func() { fs.Config.Filter.MaxSize = 0 fs.Config.Filter.DeleteExcluded = false }() fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } fstest.CheckItems(t, r.fremote, file2) // Check sync the other way round to make sure enormous gets // deleted even though it is excluded fs.Stats.ResetCounters() err = fs.Sync(r.flocal, r.fremote) if err != nil { t.Fatalf("Sync failed: %v", err) } fstest.CheckItems(t, r.flocal, file2) }
// Create a file and sync it. Keep the last modified date but change // the size. With --ignore-size we expect nothing to to be // transferred on the second sync. func TestSyncIgnoreSize(t *testing.T) { r := NewRun(t) defer r.Finalise() fs.Config.IgnoreSize = true defer func() { fs.Config.IgnoreSize = false }() file1 := r.WriteFile("ignore-size", "contents", t1) fstest.CheckItems(t, r.flocal, file1) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) require.NoError(t, err) // We should have transferred exactly one file. assert.Equal(t, int64(1), fs.Stats.GetTransfers()) fstest.CheckItems(t, r.fremote, file1) // Update size but not date of file file2 := r.WriteFile("ignore-size", "longer contents but same date", t1) fstest.CheckItems(t, r.flocal, file2) fs.Stats.ResetCounters() err = fs.Sync(r.fremote, r.flocal) require.NoError(t, err) // We should have transferred no files assert.Equal(t, int64(0), fs.Stats.GetTransfers()) fstest.CheckItems(t, r.flocal, file2) fstest.CheckItems(t, r.fremote, file1) }
// Test with exclude and delete excluded func TestSyncWithExcludeAndDeleleteExcluded(t *testing.T) { fs.Config.Filter.MaxSize = 40 fs.Config.Filter.DeleteExcluded = true reset := func() { fs.Config.Filter.MaxSize = 0 fs.Config.Filter.DeleteExcluded = false } defer reset() err := fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } items := []fstest.Item{ {Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"}, } fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow) // Tidy up reset() err = os.Remove(localName + "/enormous") if err != nil { t.Fatalf("Remove failed: %v", err) } err = fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } items = []fstest.Item{ {Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"}, {Path: "potato2", Size: 60, ModTime: t1, Md5sum: "d6548b156ea68a4e003e786df99eee76"}, } fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow) }
func TestSyncIgnoreExisting(t *testing.T) { r := NewRun(t) defer r.Finalise() file1 := r.WriteFile("existing", "potato", t1) fs.Config.IgnoreExisting = true defer func() { fs.Config.IgnoreExisting = false }() fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } fstest.CheckItems(t, r.flocal, file1) fstest.CheckItems(t, r.fremote, file1) // Change everything r.WriteFile("existing", "newpotatoes", t2) fs.Stats.ResetCounters() err = fs.Sync(r.fremote, r.flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } // Items should not change fstest.CheckItems(t, r.fremote, file1) }
func TestSyncIgnoreTimes(t *testing.T) { r := NewRun(t) defer r.Finalise() file1 := r.WriteBoth("existing", "potato", t1) fstest.CheckItems(t, r.fremote, file1) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) require.NoError(t, err) // We should have transferred exactly 0 files because the // files were identical. assert.Equal(t, int64(0), fs.Stats.GetTransfers()) fs.Config.IgnoreTimes = true defer func() { fs.Config.IgnoreTimes = false }() fs.Stats.ResetCounters() err = fs.Sync(r.fremote, r.flocal) require.NoError(t, err) // We should have transferred exactly one file even though the // files were identical. assert.Equal(t, int64(1), fs.Stats.GetTransfers()) fstest.CheckItems(t, r.flocal, file1) fstest.CheckItems(t, r.fremote, file1) }
// Test with exclude func TestSyncWithExclude(t *testing.T) { r := NewRun(t) defer r.Finalise() file1 := r.WriteBoth("potato2", "------------------------------------------------------------", t1) file2 := r.WriteBoth("empty space", "", t2) file3 := r.WriteFile("enormous", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", t1) // 100 bytes fs.Config.Filter.MaxSize = 40 defer func() { fs.Config.Filter.MaxSize = 0 }() fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } fstest.CheckItems(t, r.fremote, file2, file1) // Now sync the other way round and check enormous doesn't get // deleted as it is excluded from the sync fs.Stats.ResetCounters() err = fs.Sync(r.flocal, r.fremote) if err != nil { t.Fatalf("Sync failed: %v", err) } fstest.CheckItems(t, r.flocal, file2, file1, file3) }
// Test with exclude func TestSyncWithExclude(t *testing.T) { WriteFile("enormous", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", t1) // 100 bytes fs.Config.Filter.MaxSize = 40 defer func() { fs.Config.Filter.MaxSize = 0 }() err := fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } items := []fstest.Item{ {Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"}, {Path: "potato2", Size: 60, ModTime: t1, Md5sum: "d6548b156ea68a4e003e786df99eee76"}, } fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow) // Now sync the other way round and check enormous doesn't get // deleted as it is excluded from the sync items = append(items, fstest.Item{ Path: "enormous", Size: 100, ModTime: t1, Md5sum: "8adc5937e635f6c9af646f0b23560fae", }) err = fs.Sync(flocal, fremote) if err != nil { t.Fatalf("Sync failed: %v", err) } fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow) }
// Create a file and sync it. Change the last modified date and the // file contents but not the size. If we're only doing sync by size // only, we expect nothing to to be transferred on the second sync. func TestSyncSizeOnly(t *testing.T) { r := NewRun(t) defer r.Finalise() fs.Config.SizeOnly = true defer func() { fs.Config.SizeOnly = false }() file1 := r.WriteFile("sizeonly", "potato", t1) fstest.CheckItems(t, r.flocal, file1) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) require.NoError(t, err) // We should have transferred exactly one file. assert.Equal(t, int64(1), fs.Stats.GetTransfers()) fstest.CheckItems(t, r.fremote, file1) // Update mtime, md5sum but not length of file file2 := r.WriteFile("sizeonly", "POTATO", t2) fstest.CheckItems(t, r.flocal, file2) fs.Stats.ResetCounters() err = fs.Sync(r.fremote, r.flocal) require.NoError(t, err) // We should have transferred no files assert.Equal(t, int64(0), fs.Stats.GetTransfers()) fstest.CheckItems(t, r.flocal, file2) fstest.CheckItems(t, r.fremote, file1) }
// Create a file and sync it. Change the last modified date and resync. // If we're only doing sync by size and checksum, we expect nothing to // to be transferred on the second sync. func TestSyncBasedOnCheckSum(t *testing.T) { cleanTempDir(t) fs.Config.CheckSum = true defer func() { fs.Config.CheckSum = false }() WriteFile("check sum", "", t1) local_items := []fstest.Item{ {Path: "check sum", Size: 0, ModTime: t1, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"}, } fstest.CheckListingWithPrecision(t, flocal, local_items, fs.Config.ModifyWindow) fs.Stats.ResetCounters() err := fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Initial sync failed: %v", err) } // We should have transferred exactly one file. if fs.Stats.GetTransfers() != 1 { t.Fatalf("Sync 1: want 1 transfer, got %d", fs.Stats.GetTransfers()) } remote_items := local_items fstest.CheckListingWithPrecision(t, fremote, remote_items, fs.Config.ModifyWindow) err = os.Chtimes(localName+"/check sum", t2, t2) if err != nil { t.Fatalf("Chtimes failed: %v", err) } local_items = []fstest.Item{ {Path: "check sum", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"}, } fstest.CheckListingWithPrecision(t, flocal, local_items, fs.Config.ModifyWindow) fs.Stats.ResetCounters() err = fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } // We should have transferred no files if fs.Stats.GetTransfers() != 0 { t.Fatalf("Sync 2: want 0 transfers, got %d", fs.Stats.GetTransfers()) } fstest.CheckListingWithPrecision(t, flocal, local_items, fs.Config.ModifyWindow) fstest.CheckListingWithPrecision(t, fremote, remote_items, fs.Config.ModifyWindow) cleanTempDir(t) }
// Create a file and sync it. Change the last modified date and the // file contents but not the size. If we're only doing sync by size // only, we expect nothing to to be transferred on the second sync. func TestSyncSizeOnly(t *testing.T) { cleanTempDir(t) fs.Config.SizeOnly = true defer func() { fs.Config.SizeOnly = false }() WriteFile("sizeonly", "potato", t1) local_items := []fstest.Item{ {Path: "sizeonly", Size: 6, ModTime: t1, Md5sum: "8ee2027983915ec78acc45027d874316"}, } fstest.CheckListingWithPrecision(t, flocal, local_items, fs.Config.ModifyWindow) fs.Stats.ResetCounters() err := fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Initial sync failed: %v", err) } // We should have transferred exactly one file. if fs.Stats.GetTransfers() != 1 { t.Fatalf("Sync 1: want 1 transfer, got %d", fs.Stats.GetTransfers()) } remote_items := local_items fstest.CheckListingWithPrecision(t, fremote, remote_items, fs.Config.ModifyWindow) // Update mtime, md5sum but not length of file WriteFile("sizeonly", "POTATO", t2) local_items = []fstest.Item{ {Path: "sizeonly", Size: 6, ModTime: t2, Md5sum: "8ac6f27a282e4938125482607ccfb55f"}, } fstest.CheckListingWithPrecision(t, flocal, local_items, fs.Config.ModifyWindow) fs.Stats.ResetCounters() err = fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } // We should have transferred no files if fs.Stats.GetTransfers() != 0 { t.Fatalf("Sync 2: want 0 transfers, got %d", fs.Stats.GetTransfers()) } fstest.CheckListingWithPrecision(t, flocal, local_items, fs.Config.ModifyWindow) fstest.CheckListingWithPrecision(t, fremote, remote_items, fs.Config.ModifyWindow) cleanTempDir(t) }
func TestSyncAfterChangingModtimeOnlyWithNoUpdateModTime(t *testing.T) { r := NewRun(t) defer r.Finalise() if r.fremote.Hashes().Count() == 0 { t.Log("Can't check this if no hashes supported") return } fs.Config.NoUpdateModTime = true defer func() { fs.Config.NoUpdateModTime = false }() file1 := r.WriteFile("empty space", "", t2) file2 := r.WriteObject("empty space", "", t1) fstest.CheckItems(t, r.flocal, file1) fstest.CheckItems(t, r.fremote, file2) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) require.NoError(t, err) fstest.CheckItems(t, r.flocal, file1) fstest.CheckItems(t, r.fremote, file2) }
// Test with UpdateOlder set func TestSyncWithUpdateOlder(t *testing.T) { if fs.Config.ModifyWindow == fs.ModTimeNotSupported { t.Skip("Can't run this test on fs which doesn't support mod time") } r := NewRun(t) defer r.Finalise() t2plus := t2.Add(time.Second / 2) t2minus := t2.Add(time.Second / 2) oneF := r.WriteFile("one", "one", t1) twoF := r.WriteFile("two", "two", t3) threeF := r.WriteFile("three", "three", t2) fourF := r.WriteFile("four", "four", t2) fiveF := r.WriteFile("five", "five", t2) fstest.CheckItems(t, r.flocal, oneF, twoF, threeF, fourF, fiveF) oneO := r.WriteObject("one", "ONE", t2) twoO := r.WriteObject("two", "TWO", t2) threeO := r.WriteObject("three", "THREE", t2plus) fourO := r.WriteObject("four", "FOURFOUR", t2minus) fstest.CheckItems(t, r.fremote, oneO, twoO, threeO, fourO) fs.Config.UpdateOlder = true oldModifyWindow := fs.Config.ModifyWindow fs.Config.ModifyWindow = fs.ModTimeNotSupported defer func() { fs.Config.UpdateOlder = false fs.Config.ModifyWindow = oldModifyWindow }() fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) require.NoError(t, err) fstest.CheckItems(t, r.fremote, oneO, twoF, threeO, fourF, fiveF) }
// Sync after removing a file and adding a file func TestSyncAfterRemovingAFileAndAddingAFile(t *testing.T) { err := fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } items := []fstest.Item{ {Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"}, {Path: "potato2", Size: 60, ModTime: t1, Md5sum: "d6548b156ea68a4e003e786df99eee76"}, } fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow) fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow) }
func TestSyncAfterAddingAFile(t *testing.T) { r := NewRun(t) defer r.Finalise() file1 := r.WriteBoth("empty space", "", t2) file2 := r.WriteFile("potato", "------------------------------------------------------------", t3) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) require.NoError(t, err) fstest.CheckItems(t, r.flocal, file1, file2) fstest.CheckItems(t, r.fremote, file1, file2) }
// Sync after changing a file's contents, modtime but not length func TestSyncAfterChangingContentsOnly(t *testing.T) { if fremote.Precision() == fs.ModTimeNotSupported { t.Logf("ModTimeNotSupported so forcing file to be a different size") WriteFile("potato", "different size to make sure it syncs", t2) err := fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } } WriteFile("potato", "SMALLER BUT SAME DATE", t2) err := fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } items := []fstest.Item{ {Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"}, {Path: "potato", Size: 21, ModTime: t2, Md5sum: "e4cb6955d9106df6263c45fcfc10f163"}, } fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow) fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow) }
// Create a file and sync it. Change the last modified date and the // file contents but not the size. If we're only doing sync by size // only, we expect nothing to to be transferred on the second sync. func TestSyncSizeOnly(t *testing.T) { r := NewRun(t) defer r.Finalise() fs.Config.SizeOnly = true defer func() { fs.Config.SizeOnly = false }() file1 := r.WriteFile("sizeonly", "potato", t1) fstest.CheckItems(t, r.flocal, file1) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) if err != nil { t.Fatalf("Initial sync failed: %v", err) } // We should have transferred exactly one file. if fs.Stats.GetTransfers() != 1 { t.Fatalf("Sync 1: want 1 transfer, got %d", fs.Stats.GetTransfers()) } fstest.CheckItems(t, r.fremote, file1) // Update mtime, md5sum but not length of file file2 := r.WriteFile("sizeonly", "POTATO", t2) fstest.CheckItems(t, r.flocal, file2) fs.Stats.ResetCounters() err = fs.Sync(r.fremote, r.flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } // We should have transferred no files if fs.Stats.GetTransfers() != 0 { t.Fatalf("Sync 2: want 0 transfers, got %d", fs.Stats.GetTransfers()) } fstest.CheckItems(t, r.flocal, file2) fstest.CheckItems(t, r.fremote, file1) }
// Create a file and sync it. Change the last modified date and resync. // If we're only doing sync by size and checksum, we expect nothing to // to be transferred on the second sync. func TestSyncBasedOnCheckSum(t *testing.T) { r := NewRun(t) defer r.Finalise() fs.Config.CheckSum = true defer func() { fs.Config.CheckSum = false }() file1 := r.WriteFile("check sum", "", t1) fstest.CheckItems(t, r.flocal, file1) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) if err != nil { t.Fatalf("Initial sync failed: %v", err) } // We should have transferred exactly one file. if fs.Stats.GetTransfers() != 1 { t.Fatalf("Sync 1: want 1 transfer, got %d", fs.Stats.GetTransfers()) } fstest.CheckItems(t, r.fremote, file1) // Change last modified date only file2 := r.WriteFile("check sum", "", t2) fstest.CheckItems(t, r.flocal, file2) fs.Stats.ResetCounters() err = fs.Sync(r.fremote, r.flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } // We should have transferred no files if fs.Stats.GetTransfers() != 0 { t.Fatalf("Sync 2: want 0 transfers, got %d", fs.Stats.GetTransfers()) } fstest.CheckItems(t, r.flocal, file2) fstest.CheckItems(t, r.fremote, file1) }
func TestSyncAfterChangingModtimeOnly(t *testing.T) { r := NewRun(t) defer r.Finalise() file1 := r.WriteFile("empty space", "", t2) r.WriteObject("empty space", "", t1) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) require.NoError(t, err) fstest.CheckItems(t, r.flocal, file1) fstest.CheckItems(t, r.fremote, file1) }
func TestSyncAfterChangingFilesSizeOnly(t *testing.T) { WriteFile("potato", "smaller but same date", t3) err := fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } items := []fstest.Item{ {Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"}, {Path: "potato", Size: 21, ModTime: t3, Md5sum: "100defcf18c42a1e0dc42a789b107cd2"}, } fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow) fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow) }
// Test with exclude and delete excluded func TestSyncWithExcludeAndDeleleteExcluded(t *testing.T) { fs.Config.Filter.MaxSize = 40 fs.Config.Filter.DeleteExcluded = true reset := func() { fs.Config.Filter.MaxSize = 0 fs.Config.Filter.DeleteExcluded = false } defer reset() err := fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } items := []fstest.Item{ {Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"}, } fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow) // Check sync the other way round to make sure enormous gets // deleted even though it is excluded err = fs.Sync(flocal, fremote) if err != nil { t.Fatalf("Sync failed: %v", err) } fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow) // Tidy up - put potato2 back! reset() WriteFile("potato2", "------------------------------------------------------------", t1) err = fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } items = []fstest.Item{ {Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"}, {Path: "potato2", Size: 60, ModTime: t1, Md5sum: "d6548b156ea68a4e003e786df99eee76"}, } fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow) }
func TestSyncAfterAddingAFile(t *testing.T) { r := NewRun(t) defer r.Finalise() file1 := r.WriteBoth("empty space", "", t2) file2 := r.WriteFile("potato", "------------------------------------------------------------", t3) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } fstest.CheckItems(t, r.flocal, file1, file2) fstest.CheckItems(t, r.fremote, file1, file2) }
func TestSyncAfterChangingFilesSizeOnly(t *testing.T) { r := NewRun(t) defer r.Finalise() file1 := r.WriteObject("potato", "------------------------------------------------------------", t3) file2 := r.WriteFile("potato", "smaller but same date", t3) fstest.CheckItems(t, r.fremote, file1) fstest.CheckItems(t, r.flocal, file2) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) require.NoError(t, err) fstest.CheckItems(t, r.flocal, file2) fstest.CheckItems(t, r.fremote, file2) }
// Test with TrackRenames set func TestSyncWithTrackRenames(t *testing.T) { r := NewRun(t) defer r.Finalise() fs.Config.TrackRenames = true defer func() { fs.Config.TrackRenames = false }() haveHash := r.fremote.Hashes().Overlap(r.flocal.Hashes()).GetOne() != fs.HashNone canTrackRenames := haveHash && fs.CanServerSideMove(r.fremote) t.Logf("Can track renames: %v", canTrackRenames) f1 := r.WriteFile("potato", "Potato Content", t1) f2 := r.WriteFile("yam", "Yam Content", t2) fs.Stats.ResetCounters() require.NoError(t, fs.Sync(r.fremote, r.flocal)) fstest.CheckItems(t, r.fremote, f1, f2) fstest.CheckItems(t, r.flocal, f1, f2) // Now rename locally. f2 = r.RenameFile(f2, "yaml") fs.Stats.ResetCounters() require.NoError(t, fs.Sync(r.fremote, r.flocal)) fstest.CheckItems(t, r.fremote, f1, f2) if canTrackRenames { assert.Equal(t, fs.Stats.GetTransfers(), int64(0)) } else { assert.Equal(t, fs.Stats.GetTransfers(), int64(1)) } }
func TestSyncAfterChangingModtimeOnly(t *testing.T) { r := NewRun(t) defer r.Finalise() file1 := r.WriteFile("empty space", "", t2) r.WriteObject("empty space", "", t1) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } fstest.CheckItems(t, r.flocal, file1) fstest.CheckItems(t, r.fremote, file1) }
// Sync after removing a file and adding a file func TestSyncAfterRemovingAFileAndAddingAFile(t *testing.T) { r := NewRun(t) defer r.Finalise() file1 := r.WriteFile("potato2", "------------------------------------------------------------", t1) file2 := r.WriteObject("potato", "SMALLER BUT SAME DATE", t2) file3 := r.WriteBoth("empty space", "", t2) fstest.CheckItems(t, r.fremote, file2, file3) fstest.CheckItems(t, r.flocal, file1, file3) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) require.NoError(t, err) fstest.CheckItems(t, r.flocal, file1, file3) fstest.CheckItems(t, r.fremote, file1, file3) }
func TestSyncIgnoreExisting(t *testing.T) { WriteFile("existing", "potato", t1) fs.Config.IgnoreExisting = true defer func() { fs.Config.IgnoreExisting = false }() err := fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } items := []fstest.Item{ {Path: "existing", Size: 6, ModTime: t1, Md5sum: "8ee2027983915ec78acc45027d874316"}, } fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow) fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow) // Change everything WriteFile("existing", "newpotatoes", t2) err = fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } // Items should not change fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow) cleanTempDir(t) }
// Test with exclude func TestSyncWithExclude(t *testing.T) { WriteFile("enormous", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", t1) // 100 bytes fs.Config.Filter.MaxSize = 80 defer func() { fs.Config.Filter.MaxSize = 0 }() err := fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } items := []fstest.Item{ {Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"}, {Path: "potato2", Size: 60, ModTime: t1, Md5sum: "d6548b156ea68a4e003e786df99eee76"}, } fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow) }
// Now with --no-traverse func TestSyncNoTraverse(t *testing.T) { r := NewRun(t) defer r.Finalise() fs.Config.NoTraverse = true defer func() { fs.Config.NoTraverse = false }() file1 := r.WriteFile("sub dir/hello world", "hello world", t1) fs.Stats.ResetCounters() err := fs.Sync(r.fremote, r.flocal) require.NoError(t, err) fstest.CheckItems(t, r.flocal, file1) fstest.CheckItems(t, r.fremote, file1) }
func TestSyncAfterChangingModtimeOnly(t *testing.T) { WriteFile("empty space", "", t1) err := os.Chtimes(localName+"/empty space", t2, t2) if err != nil { t.Fatalf("Chtimes failed: %v", err) } err = fs.Sync(fremote, flocal) if err != nil { t.Fatalf("Sync failed: %v", err) } items := []fstest.Item{ {Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"}, } fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow) fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow) }