Esempio n. 1
0
func newTestResponse() *Response {
	return &Response{
		Response: &http.Response{},
		MediaHeader: &mediaheader.MediaHeader{
			Relations: hypermedia.Relations{"next": hypermedia.Hyperlink("/path")},
		},
	}
}
Esempio n. 2
0
// One accesses the root URI templates and assigns them to result
//
// https://developer.github.com/v3/#root-endpoint
func (r *RootService) One() (root *Root, result *Result) {
	root = &Root{HALResource: &hypermedia.HALResource{}}
	result = r.client.get(r.URL, &root)
	if root != nil {
		// Cached hyperlinks
		root.PullsURL = hypermedia.Hyperlink(PullRequestsURL)
	}

	return
}
Esempio n. 3
0
func TestResolveClientRelativeHyperlink(t *testing.T) {
	client, err := NewFromString("http://github.enterprise.com/api/v3/", nil)
	if err != nil {
		t.Fatal(err.Error())
	}
	link := hypermedia.Hyperlink("repos/{repo}")
	expanded, err := link.Expand(hypermedia.M{"repo": "foo"})

	u, err := client.ResolveReferenceString(expanded.String())
	if err != nil {
		t.Fatal(err.Error())
	}

	assert.Equal(t, "http://github.enterprise.com/api/v3/repos/foo", u)
}
Esempio n. 4
0
func (d *Decoder) Decode(header http.Header) (mediaHeader *MediaHeader) {
	mediaHeader = &MediaHeader{Relations: hypermedia.Relations{}}

	link := header.Get("Link")
	if len(link) == 0 {
		return
	}

	for _, l := range strings.Split(link, ",") {
		l = strings.TrimSpace(l)
		segments := strings.Split(l, ";")

		if len(segments) < 2 {
			continue
		}

		if !strings.HasPrefix(segments[0], "<") || !strings.HasSuffix(segments[0], ">") {
			continue
		}

		url, err := url.Parse(segments[0][1 : len(segments[0])-1])
		if err != nil {
			continue
		}

		link := hypermedia.Hyperlink(url.String())

		for _, segment := range segments[1:] {
			switch strings.TrimSpace(segment) {
			case `rel="next"`:
				mediaHeader.Relations["next"] = link
			case `rel="prev"`:
				mediaHeader.Relations["prev"] = link
			case `rel="first"`:
				mediaHeader.Relations["first"] = link
			case `rel="last"`:
				mediaHeader.Relations["last"] = link
			}
		}
	}

	return
}
Esempio n. 5
0
// Url generates full URL to API endpoint for given test case.
// urlpath must provide full URL to the endpoint with no query parameters.
func (testCase *ApiTestCase) Url(urlpath string) (string, error) {
	// TODO: what if url template contains something, but it's not provided by test case?
	sawyerHyperlink := hypermedia.Hyperlink(urlpath)
	params := hypermedia.M{}
	for name, p := range testCase.PathParams {
		params[name] = p.Value
	}

	u, err := sawyerHyperlink.Expand(params)
	if err != nil {
		return "", err
	}
	if testCase.QueryParams != nil {
		query := url.Values{}
		for key, param := range testCase.QueryParams {
			valueStr := fmt.Sprintf("%v", param.Value)
			query.Set(key, valueStr)
		}
		u.RawQuery = query.Encode()
	}

	return u.String(), nil
}
Esempio n. 6
0
// Expand utilizes the sawyer expand method to convert a URI template into a full
// URL
func (l Hyperlink) Expand(m M) (u *url.URL, err error) {
	sawyerHyperlink := hypermedia.Hyperlink(string(l))
	u, err = sawyerHyperlink.Expand(hypermedia.M(m))
	return
}
Esempio n. 7
0
func TestNewResult_Pageable(t *testing.T) {
	resp := &Response{MediaHeader: &mediaheader.MediaHeader{Relations: hypermedia.Relations{"next": hypermedia.Hyperlink("/path")}}}
	result := newResult(resp, nil)

	assert.Equal(t, "/path", string(*result.NextPage))
	assert.T(t, result.PrevPage == nil)
	assert.T(t, result.LastPage == nil)
	assert.T(t, result.FirstPage == nil)
}