Ignore traces

golden/go/analysis/analysis_test.go

 package analysis
 
 import (
         "fmt"
         "os"
         "sort"
         "strings"
         "testing"
         "time"
 
@@ skipping 65 matching lines @@
                 "t4": map[string]types.Label{"d_44": types.POSITIVE},
         }
         STATUS_OK_2, UNTRIAGED_COUNT_2, NEGATIVE_COUNT_2 := true, 0, 0
 
         assert.Equal(t, len(digests), len(params))
         assert.Equal(t, len(digests[0]), len(commits))
 
         diffStore := NewMockDiffStore()
         expStore := expstorage.NewMemExpectationsStore()
         tileStore := NewMockTileStore(t, digests, params, commits)
+        ignoreStore := types.NewMemIgnoreStore()
         timeBetweenPolls := 10 * time.Hour
-        a := NewAnalyzer(expStore, tileStore, diffStore, mockUrlGenerator, timeBetweenPolls)
+        a := NewAnalyzer(expStore, tileStore, diffStore, ignoreStore, mockUrlGenerator, timeBetweenPolls)
 
         allTests, err := a.ListTestDetails(nil)
         assert.Nil(t, err)
 
         // Poll until ready
         for allTests == nil {
                 time.Sleep(10 * time.Millisecond)
                 allTests, err = a.ListTestDetails(nil)
                 assert.Nil(t, err)
         }
         assert.NotNil(t, allTests)
         assert.Equal(t, len(params), len(allTests.Tests))
 
         // Make sure the lookup function works correctly.
-        for _, oneTest := range a.currentTestDetails.Tests {
-                found := a.currentTestDetails.lookup(oneTest.Name)
+        for _, oneTest := range a.current.TestDetails.Tests {
+                found := a.current.TestDetails.lookup(oneTest.Name)
                 assert.NotNil(t, found)
                 assert.Equal(t, oneTest, found)
         }
 
         test1, err := a.GetTestDetails("t1", nil)
         assert.Nil(t, err)
         assert.NotNil(t, test1)
         assert.Equal(t, commits, test1.Commits)
         assert.Equal(t, 1, len(test1.Tests))
         assert.Equal(t, 0, len(test1.Query))
@@ skipping 60 matching lines @@
         // Download the testdata and remove the testdata directory at the end.
         err := testutils.DownloadTestDataFile(TEST_DATA_STORAGE_PATH, TEST_DATA_PATH)
         assert.Nil(t, err, "Unable to download testdata.")
         defer func() {
                 os.RemoveAll(TEST_DATA_DIR)
         }()
 
         diffStore := NewMockDiffStore()
         expStore := expstorage.NewMemExpectationsStore()
         tileStore := NewMockTileStoreFromJson(t, TEST_DATA_PATH)
+        ignoreStore := types.NewMemIgnoreStore()
         timeBetweenPolls := 10 * time.Hour
-        a := NewAnalyzer(expStore, tileStore, diffStore, mockUrlGenerator, timeBetweenPolls)
+        a := NewAnalyzer(expStore, tileStore, diffStore, ignoreStore, mockUrlGenerator, timeBetweenPolls)
 
         // Poll until the Analyzer has process the tile.
         var allTests *GUITestDetails
         allTests, err = a.ListTestDetails(nil)
         assert.Nil(t, err)
         for allTests == nil {
                 time.Sleep(10 * time.Millisecond)
                 allTests, err = a.ListTestDetails(nil)
                 assert.Nil(t, err)
         }
@@ skipping 35 matching lines @@
                         assert.True(t, commitIds[0] < len(oneTest.Commits))
                         assert.True(t, commitIds[0] >= 0)
                         for i := 1; i < len(commitIds); i++ {
                                 assert.True(t, commitIds[i-1] < commitIds[i], fmt.Sprintf("%d is not smaller than %d", commitIds[i-1], commitIds[i]))
                                 assert.True(t, commitIds[i] < len(oneTest.Commits))
                                 assert.True(t, commitIds[i] >= 0)
                         }
                 }
 
                 // Go through the current tile and check whether the digests match up.
-                for _, trace := range a.currentTile.Traces[testName] {
+                for _, trace := range a.current.Tile.Traces[testName] {
                         for idx, digest := range trace.Digests {
                                 assert.NotNil(t, commitsBD[digest], fmt.Sprintf("Did not find digest: %s in \n %v", digest, commitsBD))
                                 assert.NotEqual(t, len(commitsBD[digest]), sort.SearchInts(commitsBD[digest], trace.CommitIds[idx]))
                         }
                 }
         }
 
         // Get the status.
         status := a.GetStatus()
 
         // Query over all corpora.
         allTests, err = a.ListTestDetails(nil)
         assert.Nil(t, err)
         assert.NotNil(t, allTests.AllParams)
 
         // Query each corpus individually and make sure the results make sense.
         testCount := 0
         testParams := map[string][]string{}
         for corpus, _ := range status.CorpStatus {
                 q := map[string][]string{"source_type": []string{corpus}}
                 corpusTests, err := a.ListTestDetails(q)
+                q["head"] = []string{"0"}
                 assert.Nil(t, err)
                 assert.Equal(t, q, corpusTests.Query)
                 assert.NotEqual(t, allTests.AllParams, corpusTests.AllParams)
 
                 testCount += len(corpusTests.Tests)
                 addParams(testParams, corpusTests.AllParams)
         }
         assert.Equal(t, len(allTests.Tests), testCount)
         assert.Equal(t, len(allTests.AllParams), len(testParams))
         for param, values := range allTests.AllParams {
@@ skipping 58 matching lines @@
 }
 
 func (m MockDiffStore) AbsPath(digest []string) map[string]string {
         result := map[string]string{}
         for _, d := range digest {
                 result[d] = "abspath/" + d
         }
         return result
 }
 
-func (m MockDiffStore) IgnorableDigests() map[string]bool {
+func (m MockDiffStore) UnavailableDigests() map[string]bool {
         return nil
 }
 
 func NewMockDiffStore() diff.DiffStore {
         return MockDiffStore{}
 }
 
 // Mock the tilestore for GoldenTraces
 func NewMockTileStore(t *testing.T, digests [][]string, params []map[string]string, commits []*ptypes.Commit) ptypes.TileStore {
         // Build the tile from the digests, params and commits.
@@ skipping 47 matching lines @@
 }
 
 func (m *MockTileStore) Put(scale, index int, tile *ptypes.Tile) error {
         assert.FailNow(m.t, "Should not be called.")
         return nil
 }
 
 func (m *MockTileStore) GetModifiable(scale, index int) (*ptypes.Tile, error) {
         return m.Get(scale, index)
 }