diff --git a/internal/restorer/filerestorer_test.go b/internal/restorer/filerestorer_test.go index 75d6e199d..f40c12a3a 100644 --- a/internal/restorer/filerestorer_test.go +++ b/internal/restorer/filerestorer_test.go @@ -13,21 +13,17 @@ import ( rtest "github.com/restic/restic/internal/test" ) -/////////////////////////////////////////////////////////////////////////////// -// test helpers (TODO move to a dedicated file?) -/////////////////////////////////////////////////////////////////////////////// - -type _Blob struct { +type TestBlob struct { data string pack string } -type _File struct { +type TestFile struct { name string - blobs []_Blob + blobs []TestBlob } -type _TestData struct { +type TestRepo struct { key *crypto.Key // pack names and ids @@ -47,39 +43,40 @@ type _TestData struct { idx filePackTraverser } -func (i *_TestData) Lookup(blobID restic.ID, _ restic.BlobType) ([]restic.PackedBlob, bool) { +func (i *TestRepo) Lookup(blobID restic.ID, _ restic.BlobType) ([]restic.PackedBlob, bool) { packs, found := i.blobs[blobID] return packs, found } -func (i *_TestData) packName(pack *packInfo) string { +func (i *TestRepo) packName(pack *packInfo) string { return i.packsIDToName[pack.id] } -func (i *_TestData) packID(name string) restic.ID { + +func (i *TestRepo) packID(name string) restic.ID { return i.packsNameToID[name] } -func (i *_TestData) pack(queue *packQueue, name string) *packInfo { +func (i *TestRepo) pack(queue *packQueue, name string) *packInfo { id := i.packsNameToID[name] return queue.packs[id] } -func (i *_TestData) fileContent(file *fileInfo) string { +func (i *TestRepo) fileContent(file *fileInfo) string { return i.filesPathToContent[file.path] } -func _newTestData(_files []_File) *_TestData { - type _Pack struct { +func newTestRepo(content []TestFile) *TestRepo { + type Pack struct { name string data []byte blobs map[restic.ID]restic.Blob } - _packs := make(map[string]_Pack) + packs := make(map[string]Pack) key := crypto.NewRandomKey() seal := func(data []byte) []byte { ciphertext := restic.NewBlobBuffer(len(data)) - ciphertext = ciphertext[:0] // TODO what does this actually do? + ciphertext = ciphertext[:0] // truncate the slice nonce := crypto.NewRandomNonce() ciphertext = append(ciphertext, nonce...) return key.Seal(ciphertext, nonce, data, nil) @@ -87,34 +84,34 @@ func _newTestData(_files []_File) *_TestData { filesPathToContent := make(map[string]string) - for _, _file := range _files { + for _, file := range content { var content string - for _, _blob := range _file.blobs { - content += _blob.data + for _, blob := range file.blobs { + content += blob.data // get the pack, create as necessary - var _pack _Pack - var found bool // TODO is there more concise way of doing this in go? - if _pack, found = _packs[_blob.pack]; !found { - _pack = _Pack{name: _blob.pack, blobs: make(map[restic.ID]restic.Blob)} + var pack Pack + var found bool + if pack, found = packs[blob.pack]; !found { + pack = Pack{name: blob.pack, blobs: make(map[restic.ID]restic.Blob)} } // calculate blob id and add to the pack as necessary - _blobID := restic.Hash([]byte(_blob.data)) - if _, found := _pack.blobs[_blobID]; !found { - _blobData := seal([]byte(_blob.data)) - _pack.blobs[_blobID] = restic.Blob{ + blobID := restic.Hash([]byte(blob.data)) + if _, found := pack.blobs[blobID]; !found { + blobData := seal([]byte(blob.data)) + pack.blobs[blobID] = restic.Blob{ Type: restic.DataBlob, - ID: _blobID, - Length: uint(len(_blobData)), // XXX is Length encrypted or plaintext? - Offset: uint(len(_pack.data)), + ID: blobID, + Length: uint(len(blobData)), + Offset: uint(len(pack.data)), } - _pack.data = append(_pack.data, _blobData...) + pack.data = append(pack.data, blobData...) } - _packs[_blob.pack] = _pack + packs[blob.pack] = pack } - filesPathToContent[_file.name] = content + filesPathToContent[file.name] = content } blobs := make(map[restic.ID][]restic.PackedBlob) @@ -122,26 +119,26 @@ func _newTestData(_files []_File) *_TestData { packsIDToData := make(map[restic.ID][]byte) packsNameToID := make(map[string]restic.ID) - for _, _pack := range _packs { - _packID := restic.Hash(_pack.data) - packsIDToName[_packID] = _pack.name - packsIDToData[_packID] = _pack.data - packsNameToID[_pack.name] = _packID - for blobID, blob := range _pack.blobs { - blobs[blobID] = append(blobs[blobID], restic.PackedBlob{Blob: blob, PackID: _packID}) + for _, pack := range packs { + packID := restic.Hash(pack.data) + packsIDToName[packID] = pack.name + packsIDToData[packID] = pack.data + packsNameToID[pack.name] = packID + for blobID, blob := range pack.blobs { + blobs[blobID] = append(blobs[blobID], restic.PackedBlob{Blob: blob, PackID: packID}) } } var files []*fileInfo - for _, _file := range _files { + for _, file := range content { content := restic.IDs{} - for _, _blob := range _file.blobs { - content = append(content, restic.Hash([]byte(_blob.data))) + for _, blob := range file.blobs { + content = append(content, restic.Hash([]byte(blob.data))) } - files = append(files, &fileInfo{path: _file.name, blobs: content}) + files = append(files, &fileInfo{path: file.name, blobs: content}) } - _data := &_TestData{ + repo := &TestRepo{ key: key, packsIDToName: packsIDToName, packsIDToData: packsIDToData, @@ -150,30 +147,30 @@ func _newTestData(_files []_File) *_TestData { files: files, filesPathToContent: filesPathToContent, } - _data.idx = filePackTraverser{lookup: _data.Lookup} - _data.loader = func(ctx context.Context, h restic.Handle, length int, offset int64, fn func(rd io.Reader) error) error { + repo.idx = filePackTraverser{lookup: repo.Lookup} + repo.loader = func(ctx context.Context, h restic.Handle, length int, offset int64, fn func(rd io.Reader) error) error { packID, err := restic.ParseID(h.Name) if err != nil { return err } - rd := bytes.NewReader(_data.packsIDToData[packID][int(offset) : int(offset)+length]) + rd := bytes.NewReader(repo.packsIDToData[packID][int(offset) : int(offset)+length]) return fn(rd) } - return _data + return repo } -func restoreAndVerify(t *testing.T, _files []_File) { - test := _newTestData(_files) +func restoreAndVerify(t *testing.T, content []TestFile) { + repo := newTestRepo(content) - r := newFileRestorer(test.loader, test.key, test.idx) - r.files = test.files + r := newFileRestorer(repo.loader, repo.key, repo.idx) + r.files = repo.files r.restoreFiles(context.TODO(), func(path string, err error) { rtest.OK(t, errors.Wrapf(err, "unexpected error")) }) - for _, file := range test.files { + for _, file := range repo.files { data, err := ioutil.ReadFile(file.path) if err != nil { t.Errorf("unable to read file %v: %v", file.path, err) @@ -182,7 +179,7 @@ func restoreAndVerify(t *testing.T, _files []_File) { rtest.Equals(t, false, r.filesWriter.writers.Contains(file.path)) - content := test.fileContent(file) + content := repo.fileContent(file) if !bytes.Equal(data, []byte(content)) { t.Errorf("file %v has wrong content: want %q, got %q", file.path, content, data) } @@ -191,36 +188,36 @@ func restoreAndVerify(t *testing.T, _files []_File) { rtest.OK(t, nil) } -func TestFileRestorer_basic(t *testing.T) { +func TestFileRestorerBasic(t *testing.T) { tempdir, cleanup := rtest.TempDir(t) defer cleanup() - restoreAndVerify(t, []_File{ - _File{ + restoreAndVerify(t, []TestFile{ + TestFile{ name: tempdir + "/file1", - blobs: []_Blob{ - _Blob{"data1-1", "pack1-1"}, - _Blob{"data1-2", "pack1-2"}, + blobs: []TestBlob{ + TestBlob{"data1-1", "pack1-1"}, + TestBlob{"data1-2", "pack1-2"}, }, }, - _File{ + TestFile{ name: tempdir + "/file2", - blobs: []_Blob{ - _Blob{"data2-1", "pack2-1"}, - _Blob{"data2-2", "pack2-2"}, + blobs: []TestBlob{ + TestBlob{"data2-1", "pack2-1"}, + TestBlob{"data2-2", "pack2-2"}, }, }, }) } -func TestFileRestorer_emptyFile(t *testing.T) { +func TestFileRestorerEmptyFile(t *testing.T) { tempdir, cleanup := rtest.TempDir(t) defer cleanup() - restoreAndVerify(t, []_File{ - _File{ + restoreAndVerify(t, []TestFile{ + TestFile{ name: tempdir + "/empty", - blobs: []_Blob{}, + blobs: []TestBlob{}, }, }) } diff --git a/internal/restorer/packcache_test.go b/internal/restorer/packcache_test.go index ccf58cb9f..05a9eca2b 100644 --- a/internal/restorer/packcache_test.go +++ b/internal/restorer/packcache_test.go @@ -39,7 +39,7 @@ func TestBytesWriterSeeker(t *testing.T) { assertNotOK(t, "unsupported seek", err) } -func TestPackCache_basic(t *testing.T) { +func TestPackCacheBasic(t *testing.T) { assertReader := func(expected []byte, offset int64, rd io.ReaderAt) { actual := make([]byte, len(expected)) rd.ReadAt(actual, offset) @@ -89,7 +89,7 @@ func TestPackCache_basic(t *testing.T) { assertReader([]byte{1, 2, 3, 4, 5}, 10, rd) } -func TestPackCache_invalid_range(t *testing.T) { +func TestPackCacheInvalidRange(t *testing.T) { c := newPackCache(10) id := restic.NewRandomID() @@ -113,7 +113,7 @@ func TestPackCache_invalid_range(t *testing.T) { assertNotOK(t, "negative length", err) } -func TestPackCache_capacity(t *testing.T) { +func TestPackCacheCapacity(t *testing.T) { c := newPackCache(10) id1, id2, id3 := restic.NewRandomID(), restic.NewRandomID(), restic.NewRandomID() @@ -159,7 +159,7 @@ func TestPackCache_capacity(t *testing.T) { rtest.Equals(t, true, loaded) } -func TestPackCache_downsize_record(t *testing.T) { +func TestPackCacheDownsizeRecord(t *testing.T) { c := newPackCache(10) id := restic.NewRandomID() @@ -233,7 +233,7 @@ func TestPackCache_downsize_record(t *testing.T) { rd.Close() } -func TestPackCache_wrong_load_size(t *testing.T) { +func TestPackCacheWrongLoadSize(t *testing.T) { c := newPackCache(10) _, err := c.get(restic.NewRandomID(), 0, 5, func(offset int64, length int, wr io.WriteSeeker) error { @@ -249,7 +249,7 @@ func TestPackCache_wrong_load_size(t *testing.T) { assertNotOK(t, "too many bytes read", err) } -func TestPackCache_invalidRequests(t *testing.T) { +func TestPackCacheInvalidRequests(t *testing.T) { c := newPackCache(10) id := restic.NewRandomID() diff --git a/internal/restorer/packqueue_test.go b/internal/restorer/packqueue_test.go index b874a7cb7..880f7037a 100644 --- a/internal/restorer/packqueue_test.go +++ b/internal/restorer/packqueue_test.go @@ -7,7 +7,7 @@ import ( rtest "github.com/restic/restic/internal/test" ) -func processPack(t *testing.T, data *_TestData, pack *packInfo, files []*fileInfo) { +func processPack(t *testing.T, data *TestRepo, pack *packInfo, files []*fileInfo) { for _, file := range files { data.idx.forEachFilePack(file, func(packIdx int, packID restic.ID, packBlobs []restic.Blob) bool { // assert file's head pack @@ -18,13 +18,13 @@ func processPack(t *testing.T, data *_TestData, pack *packInfo, files []*fileInf } } -func TestPackQueue_basic(t *testing.T) { - data := _newTestData([]_File{ - _File{ +func TestPackQueueBasic(t *testing.T) { + data := newTestRepo([]TestFile{ + TestFile{ name: "file", - blobs: []_Blob{ - _Blob{"data1", "pack1"}, - _Blob{"data2", "pack2"}, + blobs: []TestBlob{ + TestBlob{"data1", "pack1"}, + TestBlob{"data2", "pack2"}, }, }, }) @@ -83,16 +83,16 @@ func TestPackQueue_basic(t *testing.T) { rtest.Equals(t, true, queue.isEmpty()) } -func TestPackQueue_failedFile(t *testing.T) { +func TestPackQueueFailedFile(t *testing.T) { // point of this test is to assert that enqueuePack removes // all references to files that failed restore - data := _newTestData([]_File{ - _File{ + data := newTestRepo([]TestFile{ + TestFile{ name: "file", - blobs: []_Blob{ - _Blob{"data1", "pack1"}, - _Blob{"data2", "pack2"}, + blobs: []TestBlob{ + TestBlob{"data1", "pack1"}, + TestBlob{"data2", "pack2"}, }, }, }) @@ -105,23 +105,23 @@ func TestPackQueue_failedFile(t *testing.T) { rtest.Equals(t, true, queue.isEmpty()) } -func TestPackQueue_ordering_cost(t *testing.T) { +func TestPackQueueOrderingCost(t *testing.T) { // assert pack1 is selected before pack2: // pack1 is ready to restore file1, pack2 is ready to restore file2 // but pack2 cannot be immediately used to restore file1 - data := _newTestData([]_File{ - _File{ + data := newTestRepo([]TestFile{ + TestFile{ name: "file1", - blobs: []_Blob{ - _Blob{"data1", "pack1"}, - _Blob{"data2", "pack2"}, + blobs: []TestBlob{ + TestBlob{"data1", "pack1"}, + TestBlob{"data2", "pack2"}, }, }, - _File{ + TestFile{ name: "file2", - blobs: []_Blob{ - _Blob{"data2", "pack2"}, + blobs: []TestBlob{ + TestBlob{"data2", "pack2"}, }, }, }) @@ -143,22 +143,22 @@ func TestPackQueue_ordering_cost(t *testing.T) { rtest.Equals(t, false, queue.requeuePack(pack, files, []*fileInfo{})) } -func TestPackQueue_ordering_inprogress(t *testing.T) { +func TestPackQueueOrderingInprogress(t *testing.T) { // finish restoring one file before starting another - data := _newTestData([]_File{ - _File{ + data := newTestRepo([]TestFile{ + TestFile{ name: "file1", - blobs: []_Blob{ - _Blob{"data1-1", "pack1-1"}, - _Blob{"data1-2", "pack1-2"}, + blobs: []TestBlob{ + TestBlob{"data1-1", "pack1-1"}, + TestBlob{"data1-2", "pack1-2"}, }, }, - _File{ + TestFile{ name: "file2", - blobs: []_Blob{ - _Blob{"data2-1", "pack2-1"}, - _Blob{"data2-2", "pack2-2"}, + blobs: []TestBlob{ + TestBlob{"data2-1", "pack2-1"}, + TestBlob{"data2-2", "pack2-2"}, }, }, }) @@ -192,17 +192,17 @@ func TestPackQueue_ordering_inprogress(t *testing.T) { rtest.Equals(t, false, file == files[0]) // different file as before } -func TestPackQueue_packMultiuse(t *testing.T) { +func TestPackQueuePackMultiuse(t *testing.T) { // the same pack is required multiple times to restore the same file - data := _newTestData([]_File{ - _File{ + data := newTestRepo([]TestFile{ + TestFile{ name: "file", - blobs: []_Blob{ - _Blob{"data1", "pack1"}, - _Blob{"data2", "pack2"}, - _Blob{"data3", "pack1"}, // pack1 reuse, new blob - _Blob{"data2", "pack2"}, // pack2 reuse, same blob + blobs: []TestBlob{ + TestBlob{"data1", "pack1"}, + TestBlob{"data2", "pack2"}, + TestBlob{"data3", "pack1"}, // pack1 reuse, new blob + TestBlob{"data2", "pack2"}, // pack2 reuse, same blob }, }, })