func (command TagsCommand) listAllTags() error { store, err := storage.Open() if err != nil { return fmt.Errorf("could not open storage: %v", err) } defer store.Close() if command.verbose { log.Info("retrieving all tags.") } if command.count { count, err := store.TagCount() if err != nil { return fmt.Errorf("could not retrieve tag count: %v", err) } log.Print(count) } else { tags, err := store.Tags() if err != nil { return fmt.Errorf("could not retrieve tags: %v", err) } for _, tag := range tags { log.Print(tag.Name) } } return nil }
func findDuplicatesInDb() error { store, err := storage.Open() if err != nil { return fmt.Errorf("could not open storage: %v", err) } defer store.Close() log.Info(2, "identifying duplicate files.") fileSets, err := store.DuplicateFiles() if err != nil { return fmt.Errorf("could not identify duplicate files: %v", err) } log.Infof(2, "found %v sets of duplicate files.", len(fileSets)) for index, fileSet := range fileSets { if index > 0 { fmt.Println() } fmt.Printf("Set of %v duplicates:\n", len(fileSet)) for _, file := range fileSet { relPath := _path.Rel(file.Path()) fmt.Printf(" %v\n", relPath) } } return nil }
func (command ImplyCommand) Exec(options cli.Options, args []string) error { command.verbose = options.HasOption("--verbose") store, err := storage.Open() if err != nil { return fmt.Errorf("could not open storage: %v", err) } defer store.Close() switch { case options.HasOption("--list"): return command.listImplications(store) case options.HasOption("--delete"): if len(args) < 2 { return fmt.Errorf("Implying and implied tag must be specified.") } return command.deleteImplication(store, args[0], args[1]) } if len(args) < 2 { return fmt.Errorf("Implying and implied tag must be specified.") } return command.addImplication(store, args[0], args[1]) }
func TestRenameDestTagAlreadyExists(test *testing.T) { // set-up databasePath := configureDatabase() defer os.Remove(databasePath) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() _, err = store.AddTag("source") if err != nil { test.Fatal(err) } _, err = store.AddTag("dest") if err != nil { test.Fatal(err) } command := RenameCommand{false} // test err = command.Exec(cli.Options{}, []string{"source", "dest"}) // validate if err == nil { test.Fatal("Existing dest tag not identified.") } }
func (command DupesCommand) findDuplicatesInDb() error { store, err := storage.Open() if err != nil { return fmt.Errorf("could not open storage: %v", err) } defer store.Close() if command.verbose { log.Info("identifying duplicate files.") } fileSets, err := store.DuplicateFiles() if err != nil { return fmt.Errorf("could not identify duplicate files: %v", err) } if command.verbose { log.Infof("found %v sets of duplicate files.", len(fileSets)) } for index, fileSet := range fileSets { if index > 0 { log.Print() } log.Printf("Set of %v duplicates:", len(fileSet)) for _, file := range fileSet { relPath := _path.Rel(file.Path()) log.Printf(" %v", relPath) } } return nil }
func (StatsCommand) Exec(options cli.Options, args []string) error { store, err := storage.Open() if err != nil { return fmt.Errorf("could not open storage: %v", err) } defer store.Close() tagCount, err := store.TagCount() if err != nil { return fmt.Errorf("could not retrieve tag count: %v", err) } fileCount, err := store.FileCount() if err != nil { return fmt.Errorf("could not retrieve file count: %v", err) } fileTagCount, err := store.FileTagCount() if err != nil { return fmt.Errorf("could not retrieve taggings count: %v", err) } log.Printf(" Tags: %v", tagCount) log.Printf(" Files: %v", fileCount) log.Printf(" Taggings: %v", fileTagCount) return nil }
func TestMergeNonExistentDestinationTag(test *testing.T) { // set-up databasePath := testDatabase() defer os.Remove(databasePath) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() _, err = store.AddTag("a") if err != nil { test.Fatal(err) } store.Commit() // test if err := MergeCommand.Exec(Options{}, []string{"a", "b"}); err == nil { test.Fatal("Expected non-existent destination tag to be identified.") } }
func TestMergeSourceAndDestinationTheSame(test *testing.T) { // set-up databasePath := testDatabase() defer os.Remove(databasePath) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() _, err = store.AddTag("a") if err != nil { test.Fatal(err) } store.Commit() // test if err := MergeCommand.Exec(Options{}, []string{"a", "a"}); err == nil { test.Fatal("Expected source and destination the same tag to be identified.") } }
func TestMergeNonExistentSourceTag(test *testing.T) { // set-up databasePath := configureDatabase() defer os.Remove(databasePath) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() _, err = store.AddTag("b") if err != nil { test.Fatal(err) } command := MergeCommand{false} // test if err := command.Exec(cli.Options{}, []string{"a", "b"}); err == nil { test.Fatal("Expected non-existent source tag to be identified.") } }
func TestDupesNoneUntaggedFile(test *testing.T) { // set-up databasePath := testDatabase() defer os.Remove(databasePath) err := redirectStreams() if err != nil { test.Fatal(err) } defer restoreStreams() path := filepath.Join(os.TempDir(), "tmsu-file") _, err = os.Create(path) if err != nil { test.Fatal(err) } defer os.Remove(path) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() _, err = store.AddFile("/tmp/a", fingerprint.Fingerprint("abc"), time.Now(), 123, true) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/a/b", fingerprint.Fingerprint("def"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/b", fingerprint.Fingerprint("ghi"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/e/f", fingerprint.Fingerprint("klm"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/a/d", fingerprint.Fingerprint("nop"), time.Now(), 123, false) if err != nil { test.Fatal(err) } store.Commit() // test if err := DupesCommand.Exec(Options{}, []string{path}); err != nil { test.Fatal(err) } // validate outFile.Seek(0, 0) bytes, err := ioutil.ReadAll(outFile) compareOutput(test, "", string(bytes)) }
func TestDupesMultipleUntaggedFile(test *testing.T) { // set-up databasePath := testDatabase() defer os.Remove(databasePath) err := redirectStreams() if err != nil { test.Fatal(err) } defer restoreStreams() path := filepath.Join(os.TempDir(), "tmsu-file") _, err = os.Create(path) if err != nil { test.Fatal(err) } defer os.Remove(path) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() _, err = store.AddFile("/tmp/a", fingerprint.Fingerprint("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), time.Now(), 123, true) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/a/b", fingerprint.Fingerprint("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/b", fingerprint.Fingerprint("xxx"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/e/f", fingerprint.Fingerprint("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/a/d", fingerprint.Fingerprint("xxx"), time.Now(), 123, false) if err != nil { test.Fatal(err) } store.Commit() // test if err := DupesCommand.Exec(Options{}, []string{path}); err != nil { test.Fatal(err) } // validate outFile.Seek(0, 0) bytes, err := ioutil.ReadAll(outFile) compareOutput(test, "/tmp/a\n/tmp/a/b\n/tmp/e/f\n", string(bytes)) }
func createTags(names []string) error { store, err := storage.Open() if err != nil { return fmt.Errorf("could not open storage: %v", err) } defer store.Close() defer store.Commit() tags, err := store.TagsByNames(names) if err != nil { return fmt.Errorf("could not retrieve tags %v: %v", names, err) } wereErrors := false for _, tag := range tags { log.Warnf("tag '%v' already exists", tag.Name) wereErrors = true } if wereErrors { return blankError } for _, name := range names { _, err := store.AddTag(name) if err != nil { return fmt.Errorf("could not add tag '%v': %v", name, err) } } return nil }
func TestCopyDestTagAlreadyExists(test *testing.T) { // set-up databasePath := testDatabase() defer os.Remove(databasePath) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() _, err = store.AddTag("source") if err != nil { test.Fatal(err) } _, err = store.AddTag("dest") if err != nil { test.Fatal(err) } store.Commit() // test err = CopyCommand.Exec(Options{}, []string{"source", "dest"}) // validate if err == nil { test.Fatal("Existing dest tag not identified.") } }
func TestTagsForSingleFile(test *testing.T) { // set-up databasePath := configureDatabase() defer os.Remove(databasePath) outPath, errPath, err := configureOutput() if err != nil { test.Fatal(err) } defer os.Remove(outPath) defer os.Remove(errPath) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() file, err := store.AddFile("/tmp/tmsu/a", fingerprint.Fingerprint("123"), time.Now(), 0, false) if err != nil { test.Fatal(err) } appleTag, err := store.AddTag("apple") if err != nil { test.Fatal(err) } bananaTag, err := store.AddTag("banana") if err != nil { test.Fatal(err) } _, err = store.AddFileTag(file.Id, appleTag.Id) if err != nil { test.Fatal(err) } _, err = store.AddFileTag(file.Id, bananaTag.Id) if err != nil { test.Fatal(err) } tagsCommand := TagsCommand{false, false} // test if err := tagsCommand.Exec(cli.Options{}, []string{"/tmp/tmsu/a"}); err != nil { test.Fatal(err) } // verify log.Outfile.Seek(0, 0) bytes, err := ioutil.ReadAll(log.Outfile) compareOutput(test, "apple\nbanana\n", string(bytes)) }
func (command DupesCommand) findDuplicatesOf(paths []string) error { store, err := storage.Open() if err != nil { return fmt.Errorf("could not open storage: %v", err) } defer store.Close() first := true for _, path := range paths { if command.verbose { log.Infof("%v: identifying duplicate files.\n", path) } fp, err := fingerprint.Create(path) if err != nil { return fmt.Errorf("%v: could not create fingerprint: %v", path, err) } if fp == fingerprint.Fingerprint("") { return nil } files, err := store.FilesByFingerprint(fp) if err != nil { return fmt.Errorf("%v: could not retrieve files matching fingerprint '%v': %v", path, fp, err) } absPath, err := filepath.Abs(path) if err != nil { return fmt.Errorf("%v: could not determine absolute path: %v", path, err) } // filter out the file we're searching on dupes := files.Where(func(file *database.File) bool { return file.Path() != absPath }) if len(paths) > 1 && len(dupes) > 0 { if first { first = false } else { log.Print() } log.Printf("%v duplicates of %v:", len(dupes), path) for _, dupe := range dupes { relPath := _path.Rel(dupe.Path()) log.Printf(" %v", relPath) } } else { for _, dupe := range dupes { relPath := _path.Rel(dupe.Path()) log.Print(relPath) } } } return nil }
func TestSingleUntag(test *testing.T) { // set-up databasePath := configureDatabase() defer os.Remove(databasePath) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() file, err := store.AddFile("/tmp/tmsu/a", fingerprint.Fingerprint("abc123"), time.Now(), 0, false) if err != nil { test.Fatal(err) } appleTag, err := store.AddTag("apple") if err != nil { test.Fatal(err) } bananaTag, err := store.AddTag("banana") if err != nil { test.Fatal(err) } _, err = store.AddFileTag(file.Id, appleTag.Id) if err != nil { test.Fatal(err) } _, err = store.AddFileTag(file.Id, bananaTag.Id) if err != nil { test.Fatal(err) } untagCommand := UntagCommand{false, false} // test if err := untagCommand.Exec(cli.Options{}, []string{"/tmp/tmsu/a", "apple"}); err != nil { test.Fatal(err) } // validate fileTags, err := store.FileTags() if err != nil { test.Fatal(err) } if len(fileTags) != 1 { test.Fatalf("Expected one file-tag but are %v", len(fileTags)) } if fileTags[0].TagId != bananaTag.Id { test.Fatalf("Incorrect tag was applied.") } }
func TestTagsForSingleFile(test *testing.T) { // set-up databasePath := testDatabase() defer os.Remove(databasePath) err := redirectStreams() if err != nil { test.Fatal(err) } defer restoreStreams() store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() file, err := store.AddFile("/tmp/tmsu/a", fingerprint.Fingerprint("123"), time.Now(), 0, false) if err != nil { test.Fatal(err) } appleTag, err := store.AddTag("apple") if err != nil { test.Fatal(err) } bananaTag, err := store.AddTag("banana") if err != nil { test.Fatal(err) } _, err = store.AddFileTag(file.Id, appleTag.Id, 0) if err != nil { test.Fatal(err) } _, err = store.AddFileTag(file.Id, bananaTag.Id, 0) if err != nil { test.Fatal(err) } store.Commit() // test if err := TagsCommand.Exec(Options{}, []string{"/tmp/tmsu/a"}); err != nil { test.Fatal(err) } // verify outFile.Seek(0, 0) bytes, err := ioutil.ReadAll(outFile) compareOutput(test, "apple\nbanana\n", string(bytes)) }
func TestCopySuccessful(test *testing.T) { // set-up databasePath := testDatabase() defer os.Remove(databasePath) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() fileA, err := store.AddFile("/tmp/a", fingerprint.Fingerprint("abc"), time.Now(), 123, true) if err != nil { test.Fatal(err) } fileAB, err := store.AddFile("/tmp/a/b", fingerprint.Fingerprint("abc"), time.Now(), 123, false) if err != nil { test.Fatal(err) } sourceTag, err := store.AddTag("source") if err != nil { test.Fatal(err) } if _, err := store.AddFileTag(fileA.Id, sourceTag.Id, 0); err != nil { test.Fatal(err) } if _, err := store.AddFileTag(fileAB.Id, sourceTag.Id, 0); err != nil { test.Fatal(err) } store.Commit() // test if err := CopyCommand.Exec(Options{}, []string{"source", "dest"}); err != nil { test.Fatal(err) } // validate destTag, err := store.TagByName("dest") if err != nil { test.Fatal(err) } if destTag == nil { test.Fatal("Destination tag does not exist.") } expectTags(test, store, fileA, sourceTag, destTag) expectTags(test, store, fileAB, sourceTag, destTag) }
func TestDupesMultiple(test *testing.T) { // set-up databasePath := configureDatabase() defer os.Remove(databasePath) outPath, errPath, err := configureOutput() if err != nil { test.Fatal(err) } defer os.Remove(outPath) defer os.Remove(errPath) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() _, err = store.AddFile("/tmp/a", fingerprint.Fingerprint("abc"), time.Now(), 123, true) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/a/b", fingerprint.Fingerprint("abc"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/b", fingerprint.Fingerprint("def"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/e/f", fingerprint.Fingerprint("def"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/a/d", fingerprint.Fingerprint("def"), time.Now(), 123, false) if err != nil { test.Fatal(err) } command := DupesCommand{false} // test if err := command.Exec(cli.Options{}, []string{}); err != nil { test.Fatal(err) } // validate log.Outfile.Seek(0, 0) bytes, err := ioutil.ReadAll(log.Outfile) compareOutput(test, "Set of 2 duplicates:\n /tmp/a\n /tmp/a/b\n\nSet of 3 duplicates:\n /tmp/a/d\n /tmp/b\n /tmp/e/f\n", string(bytes)) }
func TestDupesMultiple(test *testing.T) { // set-up databasePath := testDatabase() defer os.Remove(databasePath) err := redirectStreams() if err != nil { test.Fatal(err) } defer restoreStreams() store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() _, err = store.AddFile("/tmp/a", fingerprint.Fingerprint("abc"), time.Now(), 123, true) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/a/b", fingerprint.Fingerprint("abc"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/b", fingerprint.Fingerprint("def"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/e/f", fingerprint.Fingerprint("def"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/a/d", fingerprint.Fingerprint("def"), time.Now(), 123, false) if err != nil { test.Fatal(err) } store.Commit() // test if err := DupesCommand.Exec(Options{}, []string{}); err != nil { test.Fatal(err) } // validate outFile.Seek(0, 0) bytes, err := ioutil.ReadAll(outFile) compareOutput(test, "Set of 2 duplicates:\n /tmp/a\n /tmp/a/b\n\nSet of 3 duplicates:\n /tmp/a/d\n /tmp/b\n /tmp/e/f\n", string(bytes)) }
func tagFrom(fromPath string, paths []string, recursive bool) error { store, err := storage.Open() if err != nil { return fmt.Errorf("could not open storage: %v", err) } defer store.Close() defer store.Commit() fingerprintAlgorithmSetting, err := store.Setting("fingerprintAlgorithm") if err != nil { return fmt.Errorf("could not retrieve fingerprint algorithm: %v", err) } file, err := store.FileByPath(fromPath) if err != nil { return fmt.Errorf("%v: could not retrieve file: %v", fromPath, err) } if file == nil { return fmt.Errorf("%v: path is not tagged") } fileTags, err := store.FileTagsByFileId(file.Id) if err != nil { return fmt.Errorf("%v: could not retrieve filetags: %v", fromPath, err) } tagValuePairs := make([]TagValuePair, len(fileTags)) for index, fileTag := range fileTags { tagValuePairs[index] = TagValuePair{fileTag.TagId, fileTag.ValueId} } wereErrors := false for _, path := range paths { if err := tagPath(store, path, tagValuePairs, recursive, fingerprintAlgorithmSetting.Value); err != nil { switch { case os.IsPermission(err): log.Warnf("%v: permisison denied", path) wereErrors = true case os.IsNotExist(err): log.Warnf("%v: no such file", path) wereErrors = true default: return fmt.Errorf("%v: could not stat file: %v", path, err) } } } if wereErrors { return blankError } return nil }
func untagPathsAll(paths []string, recursive bool) error { store, err := storage.Open() if err != nil { return fmt.Errorf("could not open storage: %v", err) } defer store.Close() defer store.Commit() wereErrors := false for _, path := range paths { absPath, err := filepath.Abs(path) if err != nil { return fmt.Errorf("%v: could not get absolute path: %v", path, err) } file, err := store.FileByPath(absPath) if err != nil { return fmt.Errorf("%v: could not retrieve file: %v", path, err) } if file == nil { log.Warnf("%v: file is not tagged.", path) wereErrors = true continue } log.Infof(2, "%v: removing all tags.", file.Path()) if err := store.DeleteFileTagsByFileId(file.Id); err != nil { return fmt.Errorf("%v: could not remove file's tags: %v", file.Path(), err) } if recursive { childFiles, err := store.FilesByDirectory(file.Path()) if err != nil { return fmt.Errorf("%v: could not retrieve files for directory: %v", file.Path()) } for _, childFile := range childFiles { if err := store.DeleteFileTagsByFileId(childFile.Id); err != nil { return fmt.Errorf("%v: could not remove file's tags: %v", childFile.Path(), err) } } } } if wereErrors { return blankError } return nil }
func (command FilesCommand) listFilesForTags(args []string) error { if len(args) == 0 { return fmt.Errorf("at least one tag must be specified. Use --all to show all files.") } store, err := storage.Open() if err != nil { return fmt.Errorf("could not open storage: %v", err) } defer store.Close() includeTagIds := make([]uint, 0) excludeTagIds := make([]uint, 0) for _, arg := range args { var tagName string var include bool if arg[0] == '-' { tagName = arg[1:] include = false } else { tagName = arg include = true } tag, err := store.TagByName(tagName) if err != nil { return fmt.Errorf("could not retrieve tag '%v': %v", tagName, err) } if tag == nil { log.Fatalf("no such tag '%v'.", tagName) } if include { includeTagIds = append(includeTagIds, tag.Id) } else { excludeTagIds = append(excludeTagIds, tag.Id) } } if command.verbose { log.Info("retrieving set of tagged files from the database.") } files, err := store.FilesWithTags(includeTagIds, excludeTagIds) if err != nil { return fmt.Errorf("could not retrieve files with tags %v and without tags %v: %v", includeTagIds, excludeTagIds, err) } return command.listFiles(files) }
func (command StatusCommand) statusPaths(paths []string) (*StatusReport, error) { report := NewReport() store, err := storage.Open() if err != nil { return nil, fmt.Errorf("could not open storage: %v", err) } defer store.Close() for _, path := range paths { absPath, err := filepath.Abs(path) if err != nil { return nil, fmt.Errorf("%v: could not get absolute path: %v", path, err) } file, err := store.FileByPath(absPath) if err != nil { return nil, fmt.Errorf("%v: could not retrieve file: %v", path, err) } if file != nil { err = command.checkFile(file, report) if err != nil { return nil, err } } if !command.directory { if command.verbose { log.Infof("%v: retrieving files from database.", path) } files, err := store.FilesByDirectory(absPath) if err != nil { return nil, fmt.Errorf("%v: could not retrieve files for directory: %v", path, err) } err = command.checkFiles(files, report) if err != nil { return nil, err } } err = command.findNewFiles(path, report) if err != nil { return nil, err } } return report, nil }
func listFilesForQuery(queryText string, dirOnly, fileOnly, topOnly, leafOnly, recursive, print0, showCount, onePerLine bool) error { if queryText == "" { return fmt.Errorf("query must be specified. Use --all to show all files.") } store, err := storage.Open() if err != nil { return fmt.Errorf("could not open storage: %v", err) } defer store.Close() log.Info(2, "parsing query") expression, err := query.Parse(queryText) if err != nil { return err } log.Info(2, "checking tag names") wereErrors := false tagNames := query.TagNames(expression) tags, err := store.TagsByNames(tagNames) for _, tagName := range tagNames { if !tags.ContainsName(tagName) { log.Warnf("no such tag '%v'.", tagName) wereErrors = true continue } } if wereErrors { return blankError } log.Info(2, "querying database") files, err := store.QueryFiles(expression) if err != nil { return fmt.Errorf("could not query files: %v", err) } if err = listFiles(files, dirOnly, fileOnly, topOnly, leafOnly, recursive, print0, showCount, onePerLine); err != nil { return err } return nil }
func TestFilesAll(test *testing.T) { // set-up databasePath := configureDatabase() defer os.Remove(databasePath) outPath, errPath, err := configureOutput() if err != nil { test.Fatal(err) } defer os.Remove(outPath) defer os.Remove(errPath) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() _, err = store.AddFile("/tmp/d", fingerprint.Fingerprint("abc"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/b/a", fingerprint.Fingerprint("abc"), time.Now(), 123, false) if err != nil { test.Fatal(err) } _, err = store.AddFile("/tmp/b", fingerprint.Fingerprint("abc"), time.Now(), 123, true) if err != nil { test.Fatal(err) } command := FilesCommand{} // test if err := command.Exec(cli.Options{cli.Option{"-a", "--all", "", false, ""}}, []string{}); err != nil { test.Fatal(err) } // validate log.Outfile.Seek(0, 0) bytes, err := ioutil.ReadAll(log.Outfile) compareOutput(test, "/tmp/b\n/tmp/b/a\n/tmp/d\n", string(bytes)) }
func TestRepairModifiedFile(test *testing.T) { // set-up databasePath := configureDatabase() defer os.Remove(databasePath) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() if err := createFile("/tmp/tmsu/a", "hello"); err != nil { test.Fatal(err) } defer os.Remove("/tmp/tmsu/a") tagCommand := TagCommand{false, false} if err := tagCommand.Exec(cli.Options{}, []string{"/tmp/tmsu/a", "a"}); err != nil { test.Fatal(err) } if err := createFile("/tmp/tmsu/a", "banana"); err != nil { test.Fatal(err) } command := RepairCommand{false, false, false} // test if err := command.Exec(cli.Options{}, []string{"/tmp/tmsu"}); err != nil { test.Fatal(err) } // validate files, err := store.Files() if err != nil { test.Fatal(err) } if len(files) != 1 { test.Fatalf("Expected one file but are %v", len(files)) } if files[0].Size != 6 { test.Fatalf("File modification was not repaired.") } }
func statusPaths(paths []string, dirOnly bool) (*StatusReport, error) { report := NewReport() store, err := storage.Open() if err != nil { return nil, fmt.Errorf("could not open storage: %v", err) } defer store.Close() defer store.Commit() for _, path := range paths { absPath, err := filepath.Abs(path) if err != nil { return nil, fmt.Errorf("%v: could not get absolute path: %v", path, err) } file, err := store.FileByPath(absPath) if err != nil { return nil, fmt.Errorf("%v: could not retrieve file: %v", path, err) } if file != nil { err = statusCheckFile(file, report) if err != nil { return nil, err } } if !dirOnly { log.Infof(2, "%v: retrieving files from database.", path) files, err := store.FilesByDirectory(absPath) if err != nil { return nil, fmt.Errorf("%v: could not retrieve files for directory: %v", path, err) } err = statusCheckFiles(files, report) if err != nil { return nil, err } } err = findNewFiles(path, report, dirOnly) if err != nil { return nil, err } } return report, nil }
func TestRepairMovedFile(test *testing.T) { // set-up databasePath := testDatabase() defer os.Remove(databasePath) store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() if err := createFile("/tmp/tmsu/a", "hello"); err != nil { test.Fatal(err) } defer os.Remove("/tmp/tmsu/a") if err := TagCommand.Exec(Options{}, []string{"/tmp/tmsu/a", "a"}); err != nil { test.Fatal(err) } if err := os.Rename("/tmp/tmsu/a", "/tmp/tmsu/b"); err != nil { test.Fatal(err) } store.Commit() // test if err := RepairCommand.Exec(Options{}, []string{"/tmp/tmsu"}); err != nil { test.Fatal(err) } // validate files, err := store.Files() if err != nil { test.Fatal(err) } if len(files) != 1 { test.Fatalf("Expected one file but are %v", len(files)) } if files[0].Path() != "/tmp/tmsu/b" { test.Fatalf("File rename was not repaired.") } }
func TestAllValues(test *testing.T) { // set-up databasePath := testDatabase() defer os.Remove(databasePath) err := redirectStreams() if err != nil { test.Fatal(err) } defer restoreStreams() store, err := storage.Open() if err != nil { test.Fatal(err) } defer store.Close() _, err = store.AddValue("wood") if err != nil { test.Fatal(err) } _, err = store.AddValue("metal") if err != nil { test.Fatal(err) } _, err = store.AddValue("torroid") if err != nil { test.Fatal(err) } store.Commit() // test if err := ValuesCommand.Exec(Options{Option{"--all", "-a", "", false, ""}}, []string{}); err != nil { test.Fatal(err) } // verify outFile.Seek(0, 0) bytes, err := ioutil.ReadAll(outFile) compareOutput(test, "metal\ntorroid\nwood\n", string(bytes)) }