Пример #1
0
// archiveData archives a tree fictious data.
// Returns (tree of sha1s, name of the node, sha1 of the node entry).
// Accept the paths as posix.
func archiveData(t testing.TB, cas CasTable, nodes NodesTable, tree map[string]string) (map[string]string, string, string) {
	sha1tree, entries := marshalData(t, tree)
	for k, v := range tree {
		err := cas.AddEntry(bytes.NewBuffer([]byte(v)), sha1tree[k])
		ut.AssertEqualf(t, true, err == nil || err == os.ErrExist, "Unexpected error: %s", err)
	}
	entrySha1, err := AddBytes(cas, entries)
	ut.AssertEqual(t, nil, err)

	// And finally add the node.
	now := time.Now().UTC()
	nodeName, err := nodes.AddEntry(&Node{entrySha1, "useful comment"}, "fictious")
	ut.AssertEqual(t, nil, err)
	ut.AssertEqualf(t, true, strings.HasPrefix(nodeName, now.Format("2006-01")+string(filepath.Separator)), "Invalid node name %s", nodeName)
	return sha1tree, nodeName, entrySha1
}
Пример #2
0
func run(t *testing.T, tmpDir string, env []string, args ...string) string {
	internal := &git{root: tmpDir}
	out, code, err := internal.capture(env, args...)
	ut.AssertEqualf(t, 0, code, "%s", out)
	ut.AssertEqual(t, nil, err)
	return out
}
Пример #3
0
// CheckBuffer asserts the content of os.Stdout and os.Stderr mocks.
func (t *TB) CheckBuffer(out, err bool) {
	if out {
		// Print Stderr to see what happened.
		ut.AssertEqualf(t, true, t.bufOut.Len() != 0, "Expected stdout")
	} else {
		ut.AssertEqualf(t, t.bufOut.Len(), 0, "Unexpected stdout")
	}

	if err {
		ut.AssertEqualf(t, true, t.bufErr.Len() != 0, "Expected stderr")
	} else {
		ut.AssertEqualf(t, t.bufErr.Len(), 0, "Unexpected stderr")
	}
	t.bufOut.Reset()
	t.bufErr.Reset()
}
Пример #4
0
func TestLoadIsolateForConfigMissingVars(t *testing.T) {
	t.Parallel()
	isoData := []byte(sampleIsolateData)
	root := "/dir"
	if common.IsWindows() {
		root = "x:\\dir"
	}
	_, _, _, _, err := LoadIsolateForConfig(root, isoData, nil)
	ut.AssertEqual(t, true, err != nil)
	ut.AssertEqualf(t, true, strings.Contains(err.Error(), "variables were missing"), "%s", err)
	ut.AssertEqualf(t, true, strings.Contains(err.Error(), "bit"), "%s", err)
	ut.AssertEqualf(t, true, strings.Contains(err.Error(), "OS"), "%s", err)
	_, _, _, _, err = LoadIsolateForConfig(root, isoData, map[string]string{"bit": "32"})
	ut.AssertEqual(t, true, err != nil)
	ut.AssertEqualf(t, true, strings.Contains(err.Error(), "variables were missing"), "%s", err)
	ut.AssertEqualf(t, true, strings.Contains(err.Error(), "OS"), "%s", err)
}
Пример #5
0
func request(t testing.TB, nodes NodesTable, path string, expectedCode int, expectedBody string) string {
	req, err := http.ReadRequest(bufio.NewReader(bytes.NewBufferString("GET " + path + " HTTP/1.1\r\nHost: test\r\n\r\n")))
	ut.AssertEqual(t, nil, err)

	resp := httptest.NewRecorder()
	nodes.ServeHTTP(resp, req)
	bytes, err := ioutil.ReadAll(resp.Body)
	ut.AssertEqual(t, nil, err)

	body := string(bytes)
	ut.AssertEqual(t, expectedCode, resp.Code)
	ut.AssertEqualf(t, true, expectedBody == "" || body == expectedBody, "%s: %#s != %#s", path, expectedBody, body)
	return body
}
Пример #6
0
func TestVariableValueOrder(t *testing.T) {
	t.Parallel()
	I := func(i int) variableValue { return variableValue{nil, &i} }
	S := func(s string) variableValue { return variableValue{&s, nil} }
	unbound := variableValue{}
	expectations := []struct {
		res int
		l   variableValue
		r   variableValue
	}{
		{0, unbound, unbound},
		{1, unbound, I(1)},
		{1, unbound, S("s")},
		{0, I(1), I(1)},
		{1, I(1), I(2)},
		{1, I(1), S("1")},
		{0, S("s"), S("s")},
		{1, S("a"), S("b")},
	}
	for _, e := range expectations {
		ut.AssertEqualf(t, e.res, e.l.compare(e.r), "%d != (%v < %v)", e.res, e.l.String(), e.r.String())
		ut.AssertEqualf(t, -e.res, e.r.compare(e.l), "%d != (%v > %v)", -e.res, e.l.String(), e.r.String())
	}
}
Пример #7
0
func testCasTableImpl(t testing.TB, cas CasTable) {
	items, err := EnumerateCasAsList(cas)
	ut.AssertEqual(t, nil, err)
	ut.AssertEqual(t, []string{}, items)

	file1, err := AddBytes(cas, []byte("content1"))
	ut.AssertEqual(t, nil, err)

	items, err = EnumerateCasAsList(cas)
	ut.AssertEqual(t, nil, err)
	ut.AssertEqual(t, []string{file1}, items)

	// Add the same content.
	file2, err := AddBytes(cas, []byte("content1"))
	ut.AssertEqualf(t, true, os.IsExist(err), "Unexpected error: %s", err)
	ut.AssertEqual(t, file1, file2)

	items, err = EnumerateCasAsList(cas)
	ut.AssertEqual(t, nil, err)
	ut.AssertEqual(t, []string{file1}, items)

	f, err := cas.Open(file1)
	ut.AssertEqual(t, nil, err)

	data, err := ioutil.ReadAll(f)
	f.Close()
	ut.AssertEqual(t, nil, err)
	ut.AssertEqual(t, "content1", string(data))

	_, err = cas.Open("0")
	ut.AssertEqual(t, false, err == nil)

	err = cas.Remove(file1)
	ut.AssertEqual(t, nil, err)

	err = cas.Remove(file1)
	ut.AssertEqual(t, false, err == nil)

	// Test fsck bit.
	ut.AssertEqual(t, false, cas.GetFsckBit())
	cas.SetFsckBit()
	ut.AssertEqual(t, true, cas.GetFsckBit())
	cas.ClearFsckBit()
	ut.AssertEqual(t, false, cas.GetFsckBit())
}
Пример #8
0
func testGoroutinePoolCancel(t *testing.T, newPool newPoolFunc) {
	t.Parallel()

	cancelError := errors.New("cancelError")
	const MAX = 10
	const J = 11 * MAX
	pool := newPool(MAX)
	logs := make(chan int, 2*J) // Avoid job blocking when writing to log.
	for i := 1; i <= J; i++ {
		i := i
		pool.Schedule(func() {
			if i == 1 {
				pool.Cancel(cancelError)
			}
			logs <- i
		}, func() {
			// Push negative on canceled tasks.
			logs <- -i
		})
	}
	var wait1 error
	var wait2 error
	go func() {
		defer close(logs)
		wait1 = pool.Wait()
		// Schedule more jobs, all of which must be cancelled.
		for i := J + 1; i <= 2*J; i++ {
			i := i
			pool.Schedule(func() {
				logs <- i
			}, func() {
				logs <- -i
			})
		}
		wait2 = pool.Wait()
	}()
	// At most MAX-1 could have been executing concurrently with job[i=1]
	// after it had cancelled the pool and before it wrote to log.
	// No new job should have started after that. So, log must have at most MAX-1
	// jobs after 1.
	finishedPre := 0
	finishedAfter := 0
	canceled := 0
	for i := range logs {
		if i == 1 {
			finishedAfter++
			break
		}
		finishedPre++
	}
	for i := range logs {
		ut.AssertEqual(t, true, i <= J)
		if i > 0 {
			finishedAfter++
		} else {
			canceled++
		}
	}
	t.Logf("JOBS: Total %d Pre %d After %d Cancelled %d", 2*J, finishedPre, finishedAfter, canceled)
	ut.AssertEqual(t, 2*J, finishedPre+finishedAfter+canceled)
	ut.AssertEqualf(t, true, finishedAfter < MAX,
		"%d (>=%d MAX) jobs started after cancellation.", finishedAfter, MAX)
	ut.AssertEqualf(t, true, canceled >= J, "%d > %d", canceled, J)
	ut.AssertEqual(t, cancelError, wait1)
	ut.AssertEqual(t, cancelError, wait2)
}
Пример #9
0
func (f *WebDumbcasAppMock) get(url string, expectedURL string) *http.Response {
	r, err := http.Get(f.baseURL + url)
	ut.AssertEqual(f, nil, err)
	ut.AssertEqualf(f, true, expectedURL == "" || r.Request.URL.Path == expectedURL, "%s != %s", expectedURL, r.Request.URL.Path)
	return r
}
Пример #10
0
func TestArchive(t *testing.T) {
	// Create a .isolate file and archive it.
	t.Parallel()
	server := isolatedfake.New()
	ts := httptest.NewServer(server)
	defer ts.Close()
	a := archiver.New(isolatedclient.New(ts.URL, "default-gzip"), nil)

	// Setup temporary directory.
	//   /base/bar
	//   /base/ignored
	//   /foo/baz.isolate
	//   /link -> /base/bar
	// Result:
	//   /baz.isolated
	tmpDir, err := ioutil.TempDir("", "isolate")
	ut.AssertEqual(t, nil, err)
	defer func() {
		if err := os.RemoveAll(tmpDir); err != nil {
			t.Fail()
		}
	}()
	baseDir := filepath.Join(tmpDir, "base")
	fooDir := filepath.Join(tmpDir, "foo")
	ut.AssertEqual(t, nil, os.Mkdir(baseDir, 0700))
	ut.AssertEqual(t, nil, os.Mkdir(fooDir, 0700))
	ut.AssertEqual(t, nil, ioutil.WriteFile(filepath.Join(baseDir, "bar"), []byte("foo"), 0600))
	ut.AssertEqual(t, nil, ioutil.WriteFile(filepath.Join(baseDir, "ignored"), []byte("ignored"), 0600))
	isolate := `{
		'variables': {
			'files': [
				'../base/',
				'../link',
			],
		},
		'conditions': [
			['OS=="amiga"', {
				'variables': {
					'command': ['amiga', '<(EXTRA)'],
				},
			}],
			['OS=="win"', {
				'variables': {
					'command': ['win'],
				},
			}],
		],
	}`
	isolatePath := filepath.Join(fooDir, "baz.isolate")
	ut.AssertEqual(t, nil, ioutil.WriteFile(isolatePath, []byte(isolate), 0600))
	if !common.IsWindows() {
		ut.AssertEqual(t, nil, os.Symlink(filepath.Join("base", "bar"), filepath.Join(tmpDir, "link")))
	} else {
		ut.AssertEqual(t, nil, ioutil.WriteFile(filepath.Join(tmpDir, "link"), []byte("no link on Windows"), 0600))
	}
	opts := &ArchiveOptions{
		Isolate:         isolatePath,
		Isolated:        filepath.Join(tmpDir, "baz.isolated"),
		Blacklist:       common.Strings{"ignored", "*.isolate"},
		PathVariables:   map[string]string{"VAR": "wonderful"},
		ExtraVariables:  map[string]string{"EXTRA": "really"},
		ConfigVariables: map[string]string{"OS": "amiga"},
	}
	future := Archive(a, opts)
	ut.AssertEqual(t, "baz.isolated", future.DisplayName())
	future.WaitForHashed()
	ut.AssertEqual(t, nil, future.Error())
	ut.AssertEqual(t, nil, a.Close())

	mode := 0600
	if common.IsWindows() {
		mode = 0666
	}
	//   /base/
	isolatedDirData := isolated.Isolated{
		Algo: "sha-1",
		Files: map[string]isolated.File{
			filepath.Join("base", "bar"): {Digest: "0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33", Mode: newInt(mode), Size: newInt64(3)},
		},
		Version: isolated.IsolatedFormatVersion,
	}
	encoded, err := json.Marshal(isolatedDirData)
	ut.AssertEqual(t, nil, err)
	isolatedDirEncoded := string(encoded) + "\n"
	isolatedDirHash := isolated.HashBytes([]byte(isolatedDirEncoded))

	isolatedData := isolated.Isolated{
		Algo:        "sha-1",
		Command:     []string{"amiga", "really"},
		Files:       map[string]isolated.File{},
		Includes:    []isolated.HexDigest{isolatedDirHash},
		RelativeCwd: "foo",
		Version:     isolated.IsolatedFormatVersion,
	}
	if !common.IsWindows() {
		isolatedData.Files["link"] = isolated.File{Link: newString(filepath.Join("base", "bar"))}
	} else {
		isolatedData.Files["link"] = isolated.File{Digest: "12339b9756c2994f85c310d560bc8c142a6b79a1", Mode: newInt(0666), Size: newInt64(18)}
	}
	encoded, err = json.Marshal(isolatedData)
	ut.AssertEqual(t, nil, err)
	isolatedEncoded := string(encoded) + "\n"
	isolatedHash := isolated.HashBytes([]byte(isolatedEncoded))

	expected := map[string]string{
		"0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33": "foo",
		string(isolatedDirHash):                    isolatedDirEncoded,
		string(isolatedHash):                       isolatedEncoded,
	}
	if common.IsWindows() {
		expected["12339b9756c2994f85c310d560bc8c142a6b79a1"] = "no link on Windows"
	}
	actual := map[string]string{}
	for k, v := range server.Contents() {
		actual[string(k)] = string(v)
		ut.AssertEqualf(t, expected[string(k)], actual[string(k)], "%s: %#v", k, actual[string(k)])
	}
	ut.AssertEqual(t, expected, actual)
	ut.AssertEqual(t, isolatedHash, future.Digest())

	stats := a.Stats()
	ut.AssertEqual(t, 0, stats.TotalHits())
	ut.AssertEqual(t, common.Size(0), stats.TotalBytesHits())
	if !common.IsWindows() {
		ut.AssertEqual(t, 3, stats.TotalMisses())
		ut.AssertEqual(t, common.Size(3+len(isolatedDirEncoded)+len(isolatedEncoded)), stats.TotalBytesPushed())
	} else {
		ut.AssertEqual(t, 4, stats.TotalMisses())
		ut.AssertEqual(t, common.Size(3+18+len(isolatedDirEncoded)+len(isolatedEncoded)), stats.TotalBytesPushed())
	}

	ut.AssertEqual(t, nil, server.Error())
	digest, err := isolated.HashFile(filepath.Join(tmpDir, "baz.isolated"))
	ut.AssertEqual(t, isolated.DigestItem{isolatedHash, false, int64(len(isolatedEncoded))}, digest)
	ut.AssertEqual(t, nil, err)
}