Ejemplo n.º 1
0
func TestDecodeJSON(t *testing.T) {
	testcases := []usererrors.UserError{
		0: usererrors.InvalidParams{{
			Params:  []string{"foo"},
			Message: "hi there!",
		}},
		1: usererrors.InternalFailure{"myid"},
		2: usererrors.ActionNotAllowed{"doit"},
		3: usererrors.NotFound{},
		4: usererrors.BearerAuthRequired{},
		5: usererrors.AuthInvalid{},
	}

	for i, testcase := range testcases {
		encoded, err := usererrors.MarshalJSON(testcase)

		t.Log(string(encoded))

		res, err := usererrors.UnmarshalJSON(encoded)
		if err != nil {
			t.Errorf("%d: %s", i, err)
		} else if !reflect.DeepEqual(res, testcase) {
			t.Errorf("%d: err=%#v, expected %#v", i, res, testcase)
		}
	}

	unknownJSON := []byte(`{"code":"foo","error":"bar"}`)
	if res, err := usererrors.UnmarshalJSON(unknownJSON); err != nil {
		t.Error(err)
	} else if res.Code() != "foo" {
		t.Errorf("code=%q, expected %q", res.Code(), "foo")
	} else if have := res.Error(); have != "bar" {
		t.Errorf("error=%q, want %q", have, "bar")
	}
}
Ejemplo n.º 2
0
// Do sends an API request and returns the API response. The API
// response is JSON-decoded and stored in the value pointed to by
// v. If a known usererror response is returned, the error will be a
// UserError with the correct underlying type.
func (c *Client) Do(req *http.Request, v interface{}) (*http.Response, error) {
	rv := reflect.ValueOf(v)
	if !(v == nil || rv.Kind() == reflect.Ptr) {
		return nil, errors.Errorf("value must be a pointer or nil not %s", reflect.TypeOf(v).String())
	}

	resp, err := c.do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode > 399 {
		body, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			return resp, errors.Annotate(err, "unable to read response body")
		}

		uerr, err := usererrors.UnmarshalJSON(body)
		if err != nil {
			return resp, errors.Annotate(err, "unable to parse error body")
		}
		return resp, uerr
	} else if resp.StatusCode > 299 || resp.StatusCode < 199 {
		return resp, errors.Errorf("unexpected status code %d", resp.StatusCode)
	}

	if v != nil {
		if err := json.NewDecoder(resp.Body).Decode(v); err != nil {
			return resp, errors.Annotate(err, "unable to parse response body")
		}
	}

	return resp, nil
}
Ejemplo n.º 3
0
func TestWrapPanic(t *testing.T) {
	var buf bytes.Buffer
	reqlog.SetLogger(stdlog.New(&buf, "", 0))

	mux := goji.NewMux()

	mux.HandleFunc(pat.New("/safe"), func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusNoContent)
	})
	mux.HandleFunc(pat.New("/panic"), func(w http.ResponseWriter, r *http.Request) {
		panic("hi there!")
	})

	mux.UseC(respond.WrapPanicC)

	req, err := http.NewRequest("FOO", "/safe", nil)
	if err != nil {
		t.Fatal(err)
	}

	rr := httptest.NewRecorder()
	mux.ServeHTTP(rr, req)

	if err := apptest.AssertStatus(rr, http.StatusNoContent); err != nil {
		t.Error(err)
	}

	buf.Reset()
	rr = httptest.NewRecorder()
	req.URL.Path = "/panic"
	mux.ServeHTTP(rr, req)

	if err := apptest.AssertStatus(rr, http.StatusInternalServerError); err != nil {
		t.Error(err)
	}

	t.Log(rr.Body.String())
	uerr, err := usererrors.UnmarshalJSON(rr.Body.Bytes())
	if err != nil {
		t.Fatal(err)
	}

	_, ok := uerr.(usererrors.InternalFailure)
	if !ok {
		t.Errorf("expected an InternalFailure but got %#v", uerr)
	}

	t.Log(buf.String())
}