Example #1
0
func TestNewRequestGET(t *testing.T) {
	// First call returns HTTP 500, second succeeds.
	serverCalls := 0
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		serverCalls++
		content, err := ioutil.ReadAll(r.Body)
		ut.ExpectEqual(t, nil, err)
		ut.ExpectEqual(t, []byte{}, content)
		if serverCalls == 1 {
			w.WriteHeader(500)
		} else {
			fmt.Fprintf(w, "Hello, client\n")
		}
	}))
	defer ts.Close()

	httpReq, err := http.NewRequest("GET", ts.URL, nil)
	ut.AssertEqual(t, nil, err)

	clientCalls := 0
	clientReq, err := NewRequest(http.DefaultClient, httpReq, func(resp *http.Response) error {
		clientCalls++
		content, err := ioutil.ReadAll(resp.Body)
		ut.AssertEqual(t, nil, err)
		ut.AssertEqual(t, "Hello, client\n", string(content))
		ut.AssertEqual(t, nil, resp.Body.Close())
		return nil
	})
	ut.AssertEqual(t, nil, err)

	ut.AssertEqual(t, nil, fast.Do(clientReq))
	ut.AssertEqual(t, 200, clientReq.Status())
	ut.AssertEqual(t, 2, serverCalls)
	ut.AssertEqual(t, 1, clientCalls)
}
Example #2
0
func TestRemoveAllMissing(t *testing.T) {
	td, err := ioutil.TempDir("", "pre-commit-go")
	ut.ExpectEqual(t, nil, err)

	foo := filepath.Join(td, "foo")
	err = ioutil.WriteFile(foo, []byte("yo"), 0600)
	ut.ExpectEqual(t, nil, err)
	ut.AssertEqual(t, nil, RemoveAll(td))
}
Example #3
0
func TestCancelable(t *testing.T) {
	t.Parallel()
	c := newCanceler()
	ut.AssertEqual(t, nil, c.CancelationReason())
	select {
	case <-c.Channel():
		t.FailNow()
	default:
	}

	wg := sync.WaitGroup{}
	wg.Add(1)
	go func() {
		defer wg.Done()
		select {
		case err, isCanceled := <-c.Channel():
			ut.ExpectEqualf(t, true, isCanceled, "Closed, but shouldn't be.")
			ut.ExpectEqual(t, ErrCanceled, err)
		}
	}()
	c.Cancel(nil)
	ut.AssertEqual(t, ErrCanceled, c.CancelationReason())
	t.Log("waiting for goroutine above to end.")
	wg.Wait()
	ut.AssertEqual(t, nil, c.Close())
	assertClosed(t, c)
}
Example #4
0
func TestGetJSONBadContentTypeIgnore(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		_, err := io.WriteString(w, "{}")
		ut.ExpectEqual(t, nil, err)
	}))
	defer ts.Close()

	status, err := GetJSON(fast, http.DefaultClient, ts.URL, nil)
	ut.AssertEqual(t, errors.New("unexpected Content-Type, expected \"application/json; charset=utf-8\", got \"text/plain; charset=utf-8\""), err)
	ut.AssertEqual(t, 200, status)
}
Example #5
0
// handlerJSON converts a jsonAPI http handler to a proper http.Handler.
func handlerJSON(t *testing.T, handler jsonAPI) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		//ut.ExpectEqual(t, jsonContentType, r.Header.Get("Content-Type"))
		defer r.Body.Close()
		out := handler(r.Body)
		if out == nil {
			w.WriteHeader(500)
		} else {
			w.Header().Set("Content-Type", jsonContentType)
			ut.ExpectEqual(t, nil, json.NewEncoder(w).Encode(out))
		}
	})
}
Example #6
0
func TestGetJSON(t *testing.T) {
	// First call returns HTTP 500, second succeeds.
	serverCalls := 0
	ts := httptest.NewServer(handlerJSON(t, func(body io.Reader) interface{} {
		serverCalls++
		content, err := ioutil.ReadAll(body)
		ut.ExpectEqual(t, nil, err)
		ut.ExpectEqual(t, []byte{}, content)
		if serverCalls == 1 {
			return nil
		}
		return map[string]string{"success": "yeah"}
	}))
	defer ts.Close()

	actual := map[string]string{}
	status, err := GetJSON(fast, http.DefaultClient, ts.URL, &actual)
	ut.AssertEqual(t, nil, err)
	ut.AssertEqual(t, 200, status)
	ut.AssertEqual(t, map[string]string{"success": "yeah"}, actual)
	ut.AssertEqual(t, 2, serverCalls)
}
func TestCoveragePrerequisites(t *testing.T) {
	// This test can't be parallel.
	if !IsContinuousIntegration() {
		old := os.Getenv("CI")
		defer func() {
			ut.ExpectEqual(t, nil, os.Setenv("CI", old))
		}()
		ut.AssertEqual(t, nil, os.Setenv("CI", "true"))
		ut.AssertEqual(t, true, IsContinuousIntegration())
	}
	c := Coverage{UseCoveralls: true}
	ut.AssertEqual(t, 1, len(c.GetPrerequisites()))
}
Example #8
0
func TestPostJSON(t *testing.T) {
	// First call returns HTTP 500, second succeeds.
	serverCalls := 0
	ts := httptest.NewServer(handlerJSON(t, func(body io.Reader) interface{} {
		serverCalls++
		data := map[string]string{}
		ut.ExpectEqual(t, nil, json.NewDecoder(body).Decode(&data))
		ut.ExpectEqual(t, map[string]string{"in": "all"}, data)
		if serverCalls == 1 {
			return nil
		}
		return map[string]string{"success": "yeah"}
	}))
	defer ts.Close()

	in := map[string]string{"in": "all"}
	actual := map[string]string{}
	status, err := PostJSON(fast, http.DefaultClient, ts.URL, in, &actual)
	ut.AssertEqual(t, nil, err)
	ut.AssertEqual(t, 200, status)
	ut.AssertEqual(t, map[string]string{"success": "yeah"}, actual)
	ut.AssertEqual(t, 2, serverCalls)
}
Example #9
0
func TestGetJSONBadResultIgnore(t *testing.T) {
	serverCalls := 0
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		serverCalls++
		w.Header().Set("Content-Type", jsonContentType)
		_, err := io.WriteString(w, "yo")
		ut.ExpectEqual(t, nil, err)
	}))
	defer ts.Close()

	status, err := GetJSON(fast, http.DefaultClient, ts.URL, nil)
	ut.AssertEqual(t, retry.Error{errors.New("bad response " + ts.URL + ": invalid character 'y' looking for beginning of value")}, err)
	ut.AssertEqual(t, 200, status)
}
Example #10
0
func TestCancelableUnblockAfterClosed(t *testing.T) {
	t.Parallel()
	c := newCanceler()
	wg := sync.WaitGroup{}
	wg.Add(1)
	go func() {
		defer wg.Done()
		select {
		case _, stillOpen := <-c.Channel():
			ut.ExpectEqual(t, false, stillOpen)
		}
	}()
	ut.AssertEqual(t, nil, c.Close())
	t.Log("waiting for goroutine above to end.")
	wg.Wait()
	assertClosed(t, c)
}
Example #11
0
func TestGoroutinePriorityPoolWithPriority(t *testing.T) {
	t.Parallel()

	const MAX_PRIORITIES = 15
	pool := NewGoroutinePriorityPool(1, NewCanceler())
	logs := make(chan int)
	wg := sync.WaitGroup{}
	for i := 0; i < MAX_PRIORITIES; i++ {
		wg.Add(1)
		i := i
		go func() {
			pool.Schedule(int64(i), func() { logs <- i }, nil)
			wg.Done()
		}()
	}
	wg.Wait()
	var fail error
	go func() {
		defer close(logs)
		fail = pool.Wait()
		ut.ExpectEqual(t, nil, fail)
	}()
	doneJobs := make([]bool, MAX_PRIORITIES)
	// First job can be any, the rest must be in order.
	prio := <-logs
	doneJobs[prio] = true
	for prio := range logs {
		ut.AssertEqual(t, false, doneJobs[prio])
		doneJobs[prio] = true
		// All higher priority jobs must be finished.
		for p := 0; p < prio; p++ {
			ut.AssertEqual(t, true, doneJobs[prio])
		}
	}
	for p, d := range doneJobs {
		ut.AssertEqualIndex(t, p, true, d)
	}
}