12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532 |
- // Copyright 2017 Google Inc. All rights reserved.
- //
- // Licensed under the Apache License, Version 2.0 (the "License");
- // you may not use this file except in compliance with the License.
- // You may obtain a copy of the License at
- //
- // http://www.apache.org/licenses/LICENSE-2.0
- //
- // Unless required by applicable law or agreed to in writing, software
- // distributed under the License is distributed on an "AS IS" BASIS,
- // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- // See the License for the specific language governing permissions and
- // limitations under the License.
- package finder
- import (
- "fmt"
- "io/ioutil"
- "log"
- "os"
- "path/filepath"
- "sort"
- "testing"
- "android/soong/finder/fs"
- )
- // some utils for tests to use
- func newFs() *fs.MockFs {
- return fs.NewMockFs(map[string][]byte{})
- }
- func newFinder(t *testing.T, filesystem *fs.MockFs, cacheParams CacheParams) *Finder {
- return newFinderWithNumThreads(t, filesystem, cacheParams, 2)
- }
- func newFinderWithNumThreads(t *testing.T, filesystem *fs.MockFs, cacheParams CacheParams, numThreads int) *Finder {
- f, err := newFinderAndErr(t, filesystem, cacheParams, numThreads)
- if err != nil {
- t.Fatal(err.Error())
- }
- return f
- }
- func newFinderAndErr(t *testing.T, filesystem *fs.MockFs, cacheParams CacheParams, numThreads int) (*Finder, error) {
- cachePath := "/finder/finder-db"
- cacheDir := filepath.Dir(cachePath)
- filesystem.MkDirs(cacheDir)
- if cacheParams.WorkingDirectory == "" {
- cacheParams.WorkingDirectory = "/cwd"
- }
- logger := log.New(ioutil.Discard, "", 0)
- f, err := newImpl(cacheParams, filesystem, logger, cachePath, numThreads)
- return f, err
- }
- func finderWithSameParams(t *testing.T, original *Finder) *Finder {
- f, err := finderAndErrorWithSameParams(t, original)
- if err != nil {
- t.Fatal(err.Error())
- }
- return f
- }
- func finderAndErrorWithSameParams(t *testing.T, original *Finder) (*Finder, error) {
- f, err := newImpl(
- original.cacheMetadata.Config.CacheParams,
- original.filesystem,
- original.logger,
- original.DbPath,
- original.numDbLoadingThreads,
- )
- return f, err
- }
- // runSimpleTests creates a few files, searches for findme.txt, and checks for the expected matches
- func runSimpleTest(t *testing.T, existentPaths []string, expectedMatches []string) {
- filesystem := newFs()
- root := "/tmp"
- filesystem.MkDirs(root)
- for _, path := range existentPaths {
- fs.Create(t, filepath.Join(root, path), filesystem)
- }
- finder := newFinder(t,
- filesystem,
- CacheParams{
- "/cwd",
- []string{root},
- nil,
- nil,
- []string{"findme.txt", "skipme.txt"},
- },
- )
- defer finder.Shutdown()
- foundPaths := finder.FindNamedAt(root, "findme.txt")
- absoluteMatches := []string{}
- for i := range expectedMatches {
- absoluteMatches = append(absoluteMatches, filepath.Join(root, expectedMatches[i]))
- }
- fs.AssertSameResponse(t, foundPaths, absoluteMatches)
- }
- // testAgainstSeveralThreadcounts runs the given test for each threadcount that we care to test
- func testAgainstSeveralThreadcounts(t *testing.T, tester func(t *testing.T, numThreads int)) {
- // test singlethreaded, multithreaded, and also using the same number of threads as
- // will be used on the current system
- threadCounts := []int{1, 2, defaultNumThreads}
- for _, numThreads := range threadCounts {
- testName := fmt.Sprintf("%v threads", numThreads)
- // store numThreads in a new variable to prevent numThreads from changing in each loop
- localNumThreads := numThreads
- t.Run(testName, func(t *testing.T) {
- tester(t, localNumThreads)
- })
- }
- }
- // end of utils, start of individual tests
- func TestSingleFile(t *testing.T) {
- runSimpleTest(t,
- []string{"findme.txt"},
- []string{"findme.txt"},
- )
- }
- func TestIncludeFiles(t *testing.T) {
- runSimpleTest(t,
- []string{"findme.txt", "skipme.txt"},
- []string{"findme.txt"},
- )
- }
- func TestNestedDirectories(t *testing.T) {
- runSimpleTest(t,
- []string{"findme.txt", "skipme.txt", "subdir/findme.txt", "subdir/skipme.txt"},
- []string{"findme.txt", "subdir/findme.txt"},
- )
- }
- func TestEmptyDirectory(t *testing.T) {
- runSimpleTest(t,
- []string{},
- []string{},
- )
- }
- func TestEmptyPath(t *testing.T) {
- filesystem := newFs()
- root := "/tmp"
- fs.Create(t, filepath.Join(root, "findme.txt"), filesystem)
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{root},
- IncludeFiles: []string{"findme.txt", "skipme.txt"},
- },
- )
- defer finder.Shutdown()
- foundPaths := finder.FindNamedAt("", "findme.txt")
- fs.AssertSameResponse(t, foundPaths, []string{})
- }
- func TestFilesystemRoot(t *testing.T) {
- testWithNumThreads := func(t *testing.T, numThreads int) {
- filesystem := newFs()
- root := "/"
- createdPath := "/findme.txt"
- fs.Create(t, createdPath, filesystem)
- finder := newFinderWithNumThreads(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{root},
- IncludeFiles: []string{"findme.txt", "skipme.txt"},
- },
- numThreads,
- )
- defer finder.Shutdown()
- foundPaths := finder.FindNamedAt(root, "findme.txt")
- fs.AssertSameResponse(t, foundPaths, []string{createdPath})
- }
- testAgainstSeveralThreadcounts(t, testWithNumThreads)
- }
- func TestNonexistentDir(t *testing.T) {
- filesystem := newFs()
- fs.Create(t, "/tmp/findme.txt", filesystem)
- _, err := newFinderAndErr(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp/IDontExist"},
- IncludeFiles: []string{"findme.txt", "skipme.txt"},
- },
- 1,
- )
- if err == nil {
- t.Fatal("Did not fail when given a nonexistent root directory")
- }
- }
- func TestExcludeDirs(t *testing.T) {
- filesystem := newFs()
- fs.Create(t, "/tmp/exclude/findme.txt", filesystem)
- fs.Create(t, "/tmp/exclude/subdir/findme.txt", filesystem)
- fs.Create(t, "/tmp/subdir/exclude/findme.txt", filesystem)
- fs.Create(t, "/tmp/subdir/subdir/findme.txt", filesystem)
- fs.Create(t, "/tmp/subdir/findme.txt", filesystem)
- fs.Create(t, "/tmp/findme.txt", filesystem)
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- ExcludeDirs: []string{"exclude"},
- IncludeFiles: []string{"findme.txt", "skipme.txt"},
- },
- )
- defer finder.Shutdown()
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/findme.txt",
- "/tmp/subdir/findme.txt",
- "/tmp/subdir/subdir/findme.txt"})
- }
- func TestPruneFiles(t *testing.T) {
- filesystem := newFs()
- fs.Create(t, "/tmp/out/findme.txt", filesystem)
- fs.Create(t, "/tmp/out/.ignore-out-dir", filesystem)
- fs.Create(t, "/tmp/out/child/findme.txt", filesystem)
- fs.Create(t, "/tmp/out2/.ignore-out-dir", filesystem)
- fs.Create(t, "/tmp/out2/sub/findme.txt", filesystem)
- fs.Create(t, "/tmp/findme.txt", filesystem)
- fs.Create(t, "/tmp/include/findme.txt", filesystem)
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- PruneFiles: []string{".ignore-out-dir"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- defer finder.Shutdown()
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/findme.txt",
- "/tmp/include/findme.txt"})
- }
- // TestRootDir tests that the value of RootDirs is used
- // tests of the filesystem root are in TestFilesystemRoot
- func TestRootDir(t *testing.T) {
- filesystem := newFs()
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/subdir/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/subdir/findme.txt", filesystem)
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp/a"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- defer finder.Shutdown()
- foundPaths := finder.FindNamedAt("/tmp/a", "findme.txt")
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/a/findme.txt",
- "/tmp/a/subdir/findme.txt"})
- }
- func TestUncachedDir(t *testing.T) {
- filesystem := newFs()
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/subdir/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/subdir/findme.txt", filesystem)
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp/b"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp/a", "findme.txt")
- // If the caller queries for a file that is in the cache, then computing the
- // correct answer won't be fast, and it would be easy for the caller to
- // fail to notice its slowness. Instead, we only ever search the cache for files
- // to return, which enforces that we can determine which files will be
- // interesting upfront.
- fs.AssertSameResponse(t, foundPaths, []string{})
- finder.Shutdown()
- }
- func TestSearchingForFilesExcludedFromCache(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/misc.txt", filesystem)
- // set up the finder and run it
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "misc.txt")
- // If the caller queries for a file that is in the cache, then computing the
- // correct answer won't be fast, and it would be easy for the caller to
- // fail to notice its slowness. Instead, we only ever search the cache for files
- // to return, which enforces that we can determine which files will be
- // interesting upfront.
- fs.AssertSameResponse(t, foundPaths, []string{})
- finder.Shutdown()
- }
- func TestRelativeFilePaths(t *testing.T) {
- filesystem := newFs()
- fs.Create(t, "/tmp/ignore/hi.txt", filesystem)
- fs.Create(t, "/tmp/include/hi.txt", filesystem)
- fs.Create(t, "/cwd/hi.txt", filesystem)
- fs.Create(t, "/cwd/a/hi.txt", filesystem)
- fs.Create(t, "/cwd/a/a/hi.txt", filesystem)
- fs.Create(t, "/rel/a/hi.txt", filesystem)
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/cwd", "../rel", "/tmp/include"},
- IncludeFiles: []string{"hi.txt"},
- },
- )
- defer finder.Shutdown()
- foundPaths := finder.FindNamedAt("a", "hi.txt")
- fs.AssertSameResponse(t, foundPaths,
- []string{"a/hi.txt",
- "a/a/hi.txt"})
- foundPaths = finder.FindNamedAt("/tmp/include", "hi.txt")
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/include/hi.txt"})
- foundPaths = finder.FindNamedAt(".", "hi.txt")
- fs.AssertSameResponse(t, foundPaths,
- []string{"hi.txt",
- "a/hi.txt",
- "a/a/hi.txt"})
- foundPaths = finder.FindNamedAt("/rel", "hi.txt")
- fs.AssertSameResponse(t, foundPaths,
- []string{"/rel/a/hi.txt"})
- foundPaths = finder.FindNamedAt("/tmp/include", "hi.txt")
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/include/hi.txt"})
- }
- // have to run this test with the race-detector (`go test -race src/android/soong/finder/*.go`)
- // for there to be much chance of the test actually detecting any error that may be present
- func TestRootDirsContainedInOtherRootDirs(t *testing.T) {
- filesystem := newFs()
- fs.Create(t, "/tmp/a/b/c/d/e/f/g/h/i/j/findme.txt", filesystem)
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/", "/tmp/a/b/c", "/tmp/a/b/c/d/e/f", "/tmp/a/b/c/d/e/f/g/h/i"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- defer finder.Shutdown()
- foundPaths := finder.FindNamedAt("/tmp/a", "findme.txt")
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/a/b/c/d/e/f/g/h/i/j/findme.txt"})
- }
- func TestFindFirst(t *testing.T) {
- filesystem := newFs()
- fs.Create(t, "/tmp/a/hi.txt", filesystem)
- fs.Create(t, "/tmp/b/hi.txt", filesystem)
- fs.Create(t, "/tmp/b/a/hi.txt", filesystem)
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"hi.txt"},
- },
- )
- defer finder.Shutdown()
- foundPaths := finder.FindFirstNamed("hi.txt")
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/a/hi.txt",
- "/tmp/b/hi.txt"},
- )
- }
- func TestConcurrentFindSameDirectory(t *testing.T) {
- testWithNumThreads := func(t *testing.T, numThreads int) {
- filesystem := newFs()
- // create a bunch of files and directories
- paths := []string{}
- for i := 0; i < 10; i++ {
- parentDir := fmt.Sprintf("/tmp/%v", i)
- for j := 0; j < 10; j++ {
- filePath := filepath.Join(parentDir, fmt.Sprintf("%v/findme.txt", j))
- paths = append(paths, filePath)
- }
- }
- sort.Strings(paths)
- for _, path := range paths {
- fs.Create(t, path, filesystem)
- }
- // set up a finder
- finder := newFinderWithNumThreads(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- numThreads,
- )
- defer finder.Shutdown()
- numTests := 20
- results := make(chan []string, numTests)
- // make several parallel calls to the finder
- for i := 0; i < numTests; i++ {
- go func() {
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- results <- foundPaths
- }()
- }
- // check that each response was correct
- for i := 0; i < numTests; i++ {
- foundPaths := <-results
- fs.AssertSameResponse(t, foundPaths, paths)
- }
- }
- testAgainstSeveralThreadcounts(t, testWithNumThreads)
- }
- func TestConcurrentFindDifferentDirectories(t *testing.T) {
- filesystem := newFs()
- // create a bunch of files and directories
- allFiles := []string{}
- numSubdirs := 10
- rootPaths := []string{}
- queryAnswers := [][]string{}
- for i := 0; i < numSubdirs; i++ {
- parentDir := fmt.Sprintf("/tmp/%v", i)
- rootPaths = append(rootPaths, parentDir)
- queryAnswers = append(queryAnswers, []string{})
- for j := 0; j < 10; j++ {
- filePath := filepath.Join(parentDir, fmt.Sprintf("%v/findme.txt", j))
- queryAnswers[i] = append(queryAnswers[i], filePath)
- allFiles = append(allFiles, filePath)
- }
- sort.Strings(queryAnswers[i])
- }
- sort.Strings(allFiles)
- for _, path := range allFiles {
- fs.Create(t, path, filesystem)
- }
- // set up a finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- defer finder.Shutdown()
- type testRun struct {
- path string
- foundMatches []string
- correctMatches []string
- }
- numTests := numSubdirs + 1
- testRuns := make(chan testRun, numTests)
- searchAt := func(path string, correctMatches []string) {
- foundPaths := finder.FindNamedAt(path, "findme.txt")
- testRuns <- testRun{path, foundPaths, correctMatches}
- }
- // make several parallel calls to the finder
- go searchAt("/tmp", allFiles)
- for i := 0; i < len(rootPaths); i++ {
- go searchAt(rootPaths[i], queryAnswers[i])
- }
- // check that each response was correct
- for i := 0; i < numTests; i++ {
- testRun := <-testRuns
- fs.AssertSameResponse(t, testRun.foundMatches, testRun.correctMatches)
- }
- }
- func TestStrangelyFormattedPaths(t *testing.T) {
- filesystem := newFs()
- fs.Create(t, "/tmp/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/findme.txt", filesystem)
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"//tmp//a//.."},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- defer finder.Shutdown()
- foundPaths := finder.FindNamedAt("//tmp//a//..", "findme.txt")
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/a/findme.txt",
- "/tmp/b/findme.txt",
- "/tmp/findme.txt"})
- }
- func TestCorruptedCacheHeader(t *testing.T) {
- filesystem := newFs()
- fs.Create(t, "/tmp/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- fs.Write(t, "/finder/finder-db", "sample header", filesystem)
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- defer finder.Shutdown()
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/a/findme.txt",
- "/tmp/findme.txt"})
- }
- func TestCanUseCache(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- // check the response of the first finder
- correctResponse := []string{"/tmp/a/findme.txt",
- "/tmp/findme.txt"}
- fs.AssertSameResponse(t, foundPaths, correctResponse)
- finder.Shutdown()
- // check results
- cacheText := fs.Read(t, finder.DbPath, filesystem)
- if len(cacheText) < 1 {
- t.Fatalf("saved cache db is empty\n")
- }
- if len(filesystem.StatCalls) == 0 {
- t.Fatal("No Stat calls recorded by mock filesystem")
- }
- if len(filesystem.ReadDirCalls) == 0 {
- t.Fatal("No ReadDir calls recorded by filesystem")
- }
- statCalls := filesystem.StatCalls
- filesystem.ClearMetrics()
- // run the second finder
- finder2 := finderWithSameParams(t, finder)
- foundPaths = finder2.FindNamedAt("/tmp", "findme.txt")
- // check results
- fs.AssertSameReadDirCalls(t, filesystem.ReadDirCalls, []string{})
- fs.AssertSameReadDirCalls(t, filesystem.StatCalls, statCalls)
- finder2.Shutdown()
- }
- func TestCorruptedCacheBody(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- finder.Shutdown()
- // check the response of the first finder
- correctResponse := []string{"/tmp/a/findme.txt",
- "/tmp/findme.txt"}
- fs.AssertSameResponse(t, foundPaths, correctResponse)
- numStatCalls := len(filesystem.StatCalls)
- numReadDirCalls := len(filesystem.ReadDirCalls)
- // load the cache file, corrupt it, and save it
- cacheReader, err := filesystem.Open(finder.DbPath)
- if err != nil {
- t.Fatal(err)
- }
- cacheData, err := ioutil.ReadAll(cacheReader)
- if err != nil {
- t.Fatal(err)
- }
- cacheData = append(cacheData, []byte("DontMindMe")...)
- filesystem.WriteFile(finder.DbPath, cacheData, 0777)
- filesystem.ClearMetrics()
- // run the second finder
- finder2 := finderWithSameParams(t, finder)
- foundPaths = finder2.FindNamedAt("/tmp", "findme.txt")
- // check results
- fs.AssertSameResponse(t, foundPaths, correctResponse)
- numNewStatCalls := len(filesystem.StatCalls)
- numNewReadDirCalls := len(filesystem.ReadDirCalls)
- // It's permissable to make more Stat calls with a corrupted cache because
- // the Finder may restart once it detects corruption.
- // However, it may have already issued many Stat calls.
- // Because a corrupted db is not expected to be a common (or even a supported case),
- // we don't care to optimize it and don't cache the already-issued Stat calls
- if numNewReadDirCalls < numReadDirCalls {
- t.Fatalf(
- "Finder made fewer ReadDir calls with a corrupted cache (%v calls) than with no cache"+
- " (%v calls)",
- numNewReadDirCalls, numReadDirCalls)
- }
- if numNewStatCalls < numStatCalls {
- t.Fatalf(
- "Finder made fewer Stat calls with a corrupted cache (%v calls) than with no cache (%v calls)",
- numNewStatCalls, numStatCalls)
- }
- finder2.Shutdown()
- }
- func TestStatCalls(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- // run finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- finder.Shutdown()
- // check response
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/a/findme.txt"})
- fs.AssertSameStatCalls(t, filesystem.StatCalls, []string{"/tmp", "/tmp/a"})
- fs.AssertSameReadDirCalls(t, filesystem.ReadDirCalls, []string{"/tmp", "/tmp/a"})
- }
- func TestFileAdded(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/ignoreme.txt", filesystem)
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/ignore.txt", filesystem)
- fs.Create(t, "/tmp/b/c/nope.txt", filesystem)
- fs.Create(t, "/tmp/b/c/d/irrelevant.txt", filesystem)
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- filesystem.Clock.Tick()
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- finder.Shutdown()
- // check the response of the first finder
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/a/findme.txt"})
- // modify the filesystem
- filesystem.Clock.Tick()
- fs.Create(t, "/tmp/b/c/findme.txt", filesystem)
- filesystem.Clock.Tick()
- filesystem.ClearMetrics()
- // run the second finder
- finder2 := finderWithSameParams(t, finder)
- foundPaths = finder2.FindNamedAt("/tmp", "findme.txt")
- // check results
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/a/findme.txt", "/tmp/b/c/findme.txt"})
- fs.AssertSameStatCalls(t, filesystem.StatCalls, []string{"/tmp", "/tmp/a", "/tmp/b", "/tmp/b/c", "/tmp/b/c/d"})
- fs.AssertSameReadDirCalls(t, filesystem.ReadDirCalls, []string{"/tmp/b/c"})
- finder2.Shutdown()
- }
- func TestDirectoriesAdded(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/ignoreme.txt", filesystem)
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/ignore.txt", filesystem)
- fs.Create(t, "/tmp/b/c/nope.txt", filesystem)
- fs.Create(t, "/tmp/b/c/d/irrelevant.txt", filesystem)
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- finder.Shutdown()
- // check the response of the first finder
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/a/findme.txt"})
- // modify the filesystem
- filesystem.Clock.Tick()
- fs.Create(t, "/tmp/b/c/new/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/c/new/new2/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/c/new/new2/ignoreme.txt", filesystem)
- filesystem.ClearMetrics()
- // run the second finder
- finder2 := finderWithSameParams(t, finder)
- foundPaths = finder2.FindNamedAt("/tmp", "findme.txt")
- // check results
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/a/findme.txt", "/tmp/b/c/new/findme.txt", "/tmp/b/c/new/new2/findme.txt"})
- fs.AssertSameStatCalls(t, filesystem.StatCalls,
- []string{"/tmp", "/tmp/a", "/tmp/b", "/tmp/b/c", "/tmp/b/c/d", "/tmp/b/c/new", "/tmp/b/c/new/new2"})
- fs.AssertSameReadDirCalls(t, filesystem.ReadDirCalls, []string{"/tmp/b/c", "/tmp/b/c/new", "/tmp/b/c/new/new2"})
- finder2.Shutdown()
- }
- func TestDirectoryAndSubdirectoryBothUpdated(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/hi1.txt", filesystem)
- fs.Create(t, "/tmp/a/hi1.txt", filesystem)
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"hi1.txt", "hi2.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "hi1.txt")
- finder.Shutdown()
- // check the response of the first finder
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/hi1.txt", "/tmp/a/hi1.txt"})
- // modify the filesystem
- filesystem.Clock.Tick()
- fs.Create(t, "/tmp/hi2.txt", filesystem)
- fs.Create(t, "/tmp/a/hi2.txt", filesystem)
- filesystem.ClearMetrics()
- // run the second finder
- finder2 := finderWithSameParams(t, finder)
- foundPaths = finder2.FindAll()
- // check results
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/hi1.txt", "/tmp/hi2.txt", "/tmp/a/hi1.txt", "/tmp/a/hi2.txt"})
- fs.AssertSameStatCalls(t, filesystem.StatCalls,
- []string{"/tmp", "/tmp/a"})
- fs.AssertSameReadDirCalls(t, filesystem.ReadDirCalls, []string{"/tmp", "/tmp/a"})
- finder2.Shutdown()
- }
- func TestFileDeleted(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/ignoreme.txt", filesystem)
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/c/nope.txt", filesystem)
- fs.Create(t, "/tmp/b/c/d/irrelevant.txt", filesystem)
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- finder.Shutdown()
- // check the response of the first finder
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/a/findme.txt", "/tmp/b/findme.txt"})
- // modify the filesystem
- filesystem.Clock.Tick()
- fs.Delete(t, "/tmp/b/findme.txt", filesystem)
- filesystem.ClearMetrics()
- // run the second finder
- finder2 := finderWithSameParams(t, finder)
- foundPaths = finder2.FindNamedAt("/tmp", "findme.txt")
- // check results
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/a/findme.txt"})
- fs.AssertSameStatCalls(t, filesystem.StatCalls, []string{"/tmp", "/tmp/a", "/tmp/b", "/tmp/b/c", "/tmp/b/c/d"})
- fs.AssertSameReadDirCalls(t, filesystem.ReadDirCalls, []string{"/tmp/b"})
- finder2.Shutdown()
- }
- func TestDirectoriesDeleted(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/1/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/1/2/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/findme.txt", filesystem)
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- finder.Shutdown()
- // check the response of the first finder
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/findme.txt",
- "/tmp/a/findme.txt",
- "/tmp/a/1/findme.txt",
- "/tmp/a/1/2/findme.txt",
- "/tmp/b/findme.txt"})
- // modify the filesystem
- filesystem.Clock.Tick()
- fs.RemoveAll(t, "/tmp/a/1", filesystem)
- filesystem.ClearMetrics()
- // run the second finder
- finder2 := finderWithSameParams(t, finder)
- foundPaths = finder2.FindNamedAt("/tmp", "findme.txt")
- // check results
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/findme.txt", "/tmp/a/findme.txt", "/tmp/b/findme.txt"})
- // Technically, we don't care whether /tmp/a/1/2 gets Statted or gets skipped
- // if the Finder detects the nonexistence of /tmp/a/1
- // However, when resuming from cache, we don't want the Finder to necessarily wait
- // to stat a directory until after statting its parent.
- // So here we just include /tmp/a/1/2 in the list.
- // The Finder is currently implemented to always restat every dir and
- // to not short-circuit due to nonexistence of parents (but it will remove
- // missing dirs from the cache for next time)
- fs.AssertSameStatCalls(t, filesystem.StatCalls,
- []string{"/tmp", "/tmp/a", "/tmp/a/1", "/tmp/a/1/2", "/tmp/b"})
- fs.AssertSameReadDirCalls(t, filesystem.ReadDirCalls, []string{"/tmp/a"})
- finder2.Shutdown()
- }
- func TestDirectoriesMoved(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/1/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/1/2/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/findme.txt", filesystem)
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- finder.Shutdown()
- // check the response of the first finder
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/findme.txt",
- "/tmp/a/findme.txt",
- "/tmp/a/1/findme.txt",
- "/tmp/a/1/2/findme.txt",
- "/tmp/b/findme.txt"})
- // modify the filesystem
- filesystem.Clock.Tick()
- fs.Move(t, "/tmp/a", "/tmp/c", filesystem)
- filesystem.ClearMetrics()
- // run the second finder
- finder2 := finderWithSameParams(t, finder)
- foundPaths = finder2.FindNamedAt("/tmp", "findme.txt")
- // check results
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/findme.txt",
- "/tmp/b/findme.txt",
- "/tmp/c/findme.txt",
- "/tmp/c/1/findme.txt",
- "/tmp/c/1/2/findme.txt"})
- // Technically, we don't care whether /tmp/a/1/2 gets Statted or gets skipped
- // if the Finder detects the nonexistence of /tmp/a/1
- // However, when resuming from cache, we don't want the Finder to necessarily wait
- // to stat a directory until after statting its parent.
- // So here we just include /tmp/a/1/2 in the list.
- // The Finder is currently implemented to always restat every dir and
- // to not short-circuit due to nonexistence of parents (but it will remove
- // missing dirs from the cache for next time)
- fs.AssertSameStatCalls(t, filesystem.StatCalls,
- []string{"/tmp", "/tmp/a", "/tmp/a/1", "/tmp/a/1/2", "/tmp/b", "/tmp/c", "/tmp/c/1", "/tmp/c/1/2"})
- fs.AssertSameReadDirCalls(t, filesystem.ReadDirCalls, []string{"/tmp", "/tmp/c", "/tmp/c/1", "/tmp/c/1/2"})
- finder2.Shutdown()
- }
- func TestDirectoriesSwapped(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/1/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/1/2/findme.txt", filesystem)
- fs.Create(t, "/tmp/b/findme.txt", filesystem)
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- finder.Shutdown()
- // check the response of the first finder
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/findme.txt",
- "/tmp/a/findme.txt",
- "/tmp/a/1/findme.txt",
- "/tmp/a/1/2/findme.txt",
- "/tmp/b/findme.txt"})
- // modify the filesystem
- filesystem.Clock.Tick()
- fs.Move(t, "/tmp/a", "/tmp/temp", filesystem)
- fs.Move(t, "/tmp/b", "/tmp/a", filesystem)
- fs.Move(t, "/tmp/temp", "/tmp/b", filesystem)
- filesystem.ClearMetrics()
- // run the second finder
- finder2 := finderWithSameParams(t, finder)
- foundPaths = finder2.FindNamedAt("/tmp", "findme.txt")
- // check results
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/findme.txt",
- "/tmp/a/findme.txt",
- "/tmp/b/findme.txt",
- "/tmp/b/1/findme.txt",
- "/tmp/b/1/2/findme.txt"})
- // Technically, we don't care whether /tmp/a/1/2 gets Statted or gets skipped
- // if the Finder detects the nonexistence of /tmp/a/1
- // However, when resuming from cache, we don't want the Finder to necessarily wait
- // to stat a directory until after statting its parent.
- // So here we just include /tmp/a/1/2 in the list.
- // The Finder is currently implemented to always restat every dir and
- // to not short-circuit due to nonexistence of parents (but it will remove
- // missing dirs from the cache for next time)
- fs.AssertSameStatCalls(t, filesystem.StatCalls,
- []string{"/tmp", "/tmp/a", "/tmp/a/1", "/tmp/a/1/2", "/tmp/b", "/tmp/b/1", "/tmp/b/1/2"})
- fs.AssertSameReadDirCalls(t, filesystem.ReadDirCalls, []string{"/tmp", "/tmp/a", "/tmp/b", "/tmp/b/1", "/tmp/b/1/2"})
- finder2.Shutdown()
- }
- // runFsReplacementTest tests a change modifying properties of the filesystem itself:
- // runFsReplacementTest tests changing the user, the hostname, or the device number
- // runFsReplacementTest is a helper method called by other tests
- func runFsReplacementTest(t *testing.T, fs1 *fs.MockFs, fs2 *fs.MockFs) {
- // setup fs1
- fs.Create(t, "/tmp/findme.txt", fs1)
- fs.Create(t, "/tmp/a/findme.txt", fs1)
- fs.Create(t, "/tmp/a/a/findme.txt", fs1)
- // setup fs2 to have the same directories but different files
- fs.Create(t, "/tmp/findme.txt", fs2)
- fs.Create(t, "/tmp/a/findme.txt", fs2)
- fs.Create(t, "/tmp/a/a/ignoreme.txt", fs2)
- fs.Create(t, "/tmp/a/b/findme.txt", fs2)
- // run the first finder
- finder := newFinder(
- t,
- fs1,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- finder.Shutdown()
- // check the response of the first finder
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/findme.txt", "/tmp/a/findme.txt", "/tmp/a/a/findme.txt"})
- // copy the cache data from the first filesystem to the second
- cacheContent := fs.Read(t, finder.DbPath, fs1)
- fs.Write(t, finder.DbPath, cacheContent, fs2)
- // run the second finder, with the same config and same cache contents but a different filesystem
- finder2 := newFinder(
- t,
- fs2,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- foundPaths = finder2.FindNamedAt("/tmp", "findme.txt")
- // check results
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/findme.txt", "/tmp/a/findme.txt", "/tmp/a/b/findme.txt"})
- fs.AssertSameStatCalls(t, fs2.StatCalls,
- []string{"/tmp", "/tmp/a", "/tmp/a/a", "/tmp/a/b"})
- fs.AssertSameReadDirCalls(t, fs2.ReadDirCalls,
- []string{"/tmp", "/tmp/a", "/tmp/a/a", "/tmp/a/b"})
- finder2.Shutdown()
- }
- func TestChangeOfDevice(t *testing.T) {
- fs1 := newFs()
- // not as fine-grained mounting controls as a real filesystem, but should be adequate
- fs1.SetDeviceNumber(0)
- fs2 := newFs()
- fs2.SetDeviceNumber(1)
- runFsReplacementTest(t, fs1, fs2)
- }
- func TestChangeOfUserOrHost(t *testing.T) {
- fs1 := newFs()
- fs1.SetViewId("me@here")
- fs2 := newFs()
- fs2.SetViewId("you@there")
- runFsReplacementTest(t, fs1, fs2)
- }
- func TestConsistentCacheOrdering(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- for i := 0; i < 5; i++ {
- fs.Create(t, fmt.Sprintf("/tmp/%v/findme.txt", i), filesystem)
- }
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- finder.FindNamedAt("/tmp", "findme.txt")
- finder.Shutdown()
- // read db file
- string1 := fs.Read(t, finder.DbPath, filesystem)
- err := filesystem.Remove(finder.DbPath)
- if err != nil {
- t.Fatal(err)
- }
- // run another finder
- finder2 := finderWithSameParams(t, finder)
- finder2.FindNamedAt("/tmp", "findme.txt")
- finder2.Shutdown()
- string2 := fs.Read(t, finder.DbPath, filesystem)
- if string1 != string2 {
- t.Errorf("Running Finder twice generated two dbs not having identical contents.\n"+
- "Content of first file:\n"+
- "\n"+
- "%v"+
- "\n"+
- "\n"+
- "Content of second file:\n"+
- "\n"+
- "%v\n"+
- "\n",
- string1,
- string2,
- )
- }
- }
- func TestNumSyscallsOfSecondFind(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/misc.txt", filesystem)
- // set up the finder and run it once
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/findme.txt", "/tmp/a/findme.txt"})
- filesystem.ClearMetrics()
- // run the finder again and confirm it doesn't check the filesystem
- refoundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- fs.AssertSameResponse(t, refoundPaths, foundPaths)
- fs.AssertSameStatCalls(t, filesystem.StatCalls, []string{})
- fs.AssertSameReadDirCalls(t, filesystem.ReadDirCalls, []string{})
- finder.Shutdown()
- }
- func TestChangingParamsOfSecondFind(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/findme.txt", filesystem)
- fs.Create(t, "/tmp/a/metoo.txt", filesystem)
- // set up the finder and run it once
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"findme.txt", "metoo.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "findme.txt")
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/findme.txt", "/tmp/a/findme.txt"})
- filesystem.ClearMetrics()
- // run the finder again and confirm it gets the right answer without asking the filesystem
- refoundPaths := finder.FindNamedAt("/tmp", "metoo.txt")
- fs.AssertSameResponse(t, refoundPaths, []string{"/tmp/a/metoo.txt"})
- fs.AssertSameStatCalls(t, filesystem.StatCalls, []string{})
- fs.AssertSameReadDirCalls(t, filesystem.ReadDirCalls, []string{})
- finder.Shutdown()
- }
- func TestSymlinkPointingToFile(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/a/hi.txt", filesystem)
- fs.Create(t, "/tmp/a/ignoreme.txt", filesystem)
- fs.Link(t, "/tmp/hi.txt", "a/hi.txt", filesystem)
- fs.Link(t, "/tmp/b/hi.txt", "../a/hi.txt", filesystem)
- fs.Link(t, "/tmp/c/hi.txt", "/tmp/hi.txt", filesystem)
- fs.Link(t, "/tmp/d/hi.txt", "../a/bye.txt", filesystem)
- fs.Link(t, "/tmp/d/bye.txt", "../a/hi.txt", filesystem)
- fs.Link(t, "/tmp/e/bye.txt", "../a/bye.txt", filesystem)
- fs.Link(t, "/tmp/f/hi.txt", "somethingThatDoesntExist", filesystem)
- // set up the finder and run it once
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"hi.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "hi.txt")
- // should search based on the name of the link rather than the destination or validity of the link
- correctResponse := []string{
- "/tmp/a/hi.txt",
- "/tmp/hi.txt",
- "/tmp/b/hi.txt",
- "/tmp/c/hi.txt",
- "/tmp/d/hi.txt",
- "/tmp/f/hi.txt",
- }
- fs.AssertSameResponse(t, foundPaths, correctResponse)
- }
- func TestSymlinkPointingToDirectory(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/dir/hi.txt", filesystem)
- fs.Create(t, "/tmp/dir/ignoreme.txt", filesystem)
- fs.Link(t, "/tmp/links/dir", "../dir", filesystem)
- fs.Link(t, "/tmp/links/link", "../dir", filesystem)
- fs.Link(t, "/tmp/links/hi.txt", "../dir", filesystem)
- fs.Link(t, "/tmp/links/broken", "nothingHere", filesystem)
- fs.Link(t, "/tmp/links/recursive", "recursive", filesystem)
- // set up the finder and run it once
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"hi.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "hi.txt")
- // should completely ignore symlinks that point to directories
- correctResponse := []string{
- "/tmp/dir/hi.txt",
- }
- fs.AssertSameResponse(t, foundPaths, correctResponse)
- }
- // TestAddPruneFile confirms that adding a prune-file (into a directory for which we
- // already had a cache) causes the directory to be ignored
- func TestAddPruneFile(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/out/hi.txt", filesystem)
- fs.Create(t, "/tmp/out/a/hi.txt", filesystem)
- fs.Create(t, "/tmp/hi.txt", filesystem)
- // do find
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- PruneFiles: []string{".ignore-out-dir"},
- IncludeFiles: []string{"hi.txt"},
- },
- )
- foundPaths := finder.FindNamedAt("/tmp", "hi.txt")
- // check result
- fs.AssertSameResponse(t, foundPaths,
- []string{"/tmp/hi.txt",
- "/tmp/out/hi.txt",
- "/tmp/out/a/hi.txt"},
- )
- finder.Shutdown()
- // modify filesystem
- filesystem.Clock.Tick()
- fs.Create(t, "/tmp/out/.ignore-out-dir", filesystem)
- // run another find and check its result
- finder2 := finderWithSameParams(t, finder)
- foundPaths = finder2.FindNamedAt("/tmp", "hi.txt")
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/hi.txt"})
- finder2.Shutdown()
- }
- func TestUpdatingDbIffChanged(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/a/hi.txt", filesystem)
- fs.Create(t, "/tmp/b/bye.txt", filesystem)
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"hi.txt"},
- },
- )
- filesystem.Clock.Tick()
- foundPaths := finder.FindAll()
- finder.Shutdown()
- // check results
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/a/hi.txt"})
- // modify the filesystem
- filesystem.Clock.Tick()
- fs.Create(t, "/tmp/b/hi.txt", filesystem)
- filesystem.Clock.Tick()
- filesystem.ClearMetrics()
- // run the second finder
- finder2 := finderWithSameParams(t, finder)
- foundPaths = finder2.FindAll()
- finder2.Shutdown()
- // check results
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/a/hi.txt", "/tmp/b/hi.txt"})
- fs.AssertSameReadDirCalls(t, filesystem.ReadDirCalls, []string{"/tmp/b"})
- expectedDbWriteTime := filesystem.Clock.Time()
- actualDbWriteTime := fs.ModTime(t, finder2.DbPath, filesystem)
- if actualDbWriteTime != expectedDbWriteTime {
- t.Fatalf("Expected to write db at %v, actually wrote db at %v\n",
- expectedDbWriteTime, actualDbWriteTime)
- }
- // reset metrics
- filesystem.ClearMetrics()
- // run the third finder
- finder3 := finderWithSameParams(t, finder2)
- foundPaths = finder3.FindAll()
- // check results
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/a/hi.txt", "/tmp/b/hi.txt"})
- fs.AssertSameReadDirCalls(t, filesystem.ReadDirCalls, []string{})
- finder3.Shutdown()
- actualDbWriteTime = fs.ModTime(t, finder3.DbPath, filesystem)
- if actualDbWriteTime != expectedDbWriteTime {
- t.Fatalf("Re-wrote db even when contents did not change")
- }
- }
- func TestDirectoryNotPermitted(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/hi.txt", filesystem)
- fs.Create(t, "/tmp/a/hi.txt", filesystem)
- fs.Create(t, "/tmp/a/a/hi.txt", filesystem)
- fs.Create(t, "/tmp/b/hi.txt", filesystem)
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"hi.txt"},
- },
- )
- filesystem.Clock.Tick()
- foundPaths := finder.FindAll()
- finder.Shutdown()
- allPaths := []string{"/tmp/hi.txt", "/tmp/a/hi.txt", "/tmp/a/a/hi.txt", "/tmp/b/hi.txt"}
- // check results
- fs.AssertSameResponse(t, foundPaths, allPaths)
- // modify the filesystem
- filesystem.Clock.Tick()
- fs.SetReadable(t, "/tmp/a", false, filesystem)
- filesystem.Clock.Tick()
- // run the second finder
- finder2 := finderWithSameParams(t, finder)
- foundPaths = finder2.FindAll()
- finder2.Shutdown()
- // check results
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/hi.txt", "/tmp/b/hi.txt"})
- // modify the filesystem back
- fs.SetReadable(t, "/tmp/a", true, filesystem)
- // run the third finder
- finder3 := finderWithSameParams(t, finder2)
- foundPaths = finder3.FindAll()
- finder3.Shutdown()
- // check results
- fs.AssertSameResponse(t, foundPaths, allPaths)
- }
- func TestFileNotPermitted(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/hi.txt", filesystem)
- fs.SetReadable(t, "/tmp/hi.txt", false, filesystem)
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"hi.txt"},
- },
- )
- filesystem.Clock.Tick()
- foundPaths := finder.FindAll()
- finder.Shutdown()
- // check results
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/hi.txt"})
- }
- func TestCacheEntryPathUnexpectedError(t *testing.T) {
- // setup filesystem
- filesystem := newFs()
- fs.Create(t, "/tmp/a/hi.txt", filesystem)
- // run the first finder
- finder := newFinder(
- t,
- filesystem,
- CacheParams{
- RootDirs: []string{"/tmp"},
- IncludeFiles: []string{"hi.txt"},
- },
- )
- filesystem.Clock.Tick()
- foundPaths := finder.FindAll()
- finder.Shutdown()
- // check results
- fs.AssertSameResponse(t, foundPaths, []string{"/tmp/a/hi.txt"})
- // make the directory not readable
- fs.SetReadErr(t, "/tmp/a", os.ErrInvalid, filesystem)
- // run the second finder
- _, err := finderAndErrorWithSameParams(t, finder)
- if err == nil {
- t.Fatal("Failed to detect unexpected filesystem error")
- }
- }
|