All Function return http responce (#416)

Add Docs on how to deal with this breaking change

doResponse should return responce in all cases, to prosses things manualy if wanted

helper func return http response

Co-authored-by: 6543 <6543@obermui.de>
Reviewed-on: https://gitea.com/gitea/go-sdk/pulls/416
Reviewed-by: Andrew Thornton <art27@cantab.net>
Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com>

docs/migrate-v0.12-to-v0.13.md

@@ -1,8 +1,7 @@
 # Migration Guide: v0.12 to v0.13
 
-v0.13.0 introduces a number of breaking changes, throu it should not be hard to
+v0.13.0 introduces a number of breaking changes, throu it should not be hard to migrate.  
-migrate.
+Just follow this guid and if issues still ocure ask for help on discord or  
-Just follow this guid and if issues still ocure ask for help on discord or
 feel free to create an issue.
 
 <!-- toc -->
@@ -11,51 +10,67 @@ feel free to create an issue.
 -   [RepoSearch Options Struct was rewritten (#346)](#RepoSearch-Options-Struct-was-rewritten)
 -   [Variable Renames (#386)](#Variable-Renames)
 -   [Change Type of Permission Field (#408)](#Change-Type-of-Permission-Field)
+-   [All Function return http responce (#416)](#All-Function-return-http-responce)
 
 <!-- tocstop -->
 
 ## EditMilestoneOption use StateType
 
-Instead of a raw string StateType is now used for State too.
+Instead of a raw string StateType is now used for State too.  
 just replace old strings with new enum.
 
 
 Pulls:
-
 -   [#350 EditMilestoneOption also use StateType](https://gitea.com/gitea/go-sdk/pulls/350)
 
 
 ## RepoSearch Options Struct was rewritten
 
-Since the API itself is ugly and there was no nameconvention whats o ever.
+Since the API itself is ugly and there was no nameconvention whats o ever.  
-You easely can pass the wrong options and dont get the result you want.
+You easely can pass the wrong options and dont get the result you want.  
 
-Now it is rewritten and translated for the API.
+Now it is rewritten and translated for the API.  
 The easyest way to migrate is to look at who this function is used and rewritten that code block.
 
 If there is a special edgecase you have you can pass a `RawQuery` to the API endpoint.
 
 Pulls:
-
 -   [#346 Refactor RepoSearch to be easy usable](https://gitea.com/gitea/go-sdk/pulls/346)
 
 
 ## Variable Renames
 
-Some names of strcut options have been renamed to describe there function/usecase more precisely.
+Some names of strcut options have been renamed to describe there function/usecase more precisely.  
 if you use `CreateOrgOption` somewhere just rename `UserName` to `Name`.
 
 Pulls:
-
 -   [#386 CreateOrgOption rename UserName to Name](https://gitea.com/gitea/go-sdk/pulls/386)
 
 ## Change Type of Permission Field
 
 The following functions are affected:  ListOrgTeams, ListMyTeams, GetTeam, CreateTeam, EditTeam and AddCollaborator
 
-The `Permission` field has changed type from `string` to `AccessMode`, which represent the raw strings you must use before.
+The `Permission` field has changed type from `string` to `AccessMode`,  
+which represent the raw strings you must use before.  
 Just replace the string with the AccessMode equivalent.
 
 Pulls:
-
 -   [#408 Use enum AccessMode for OrgTeam and Collaborator functions](https://gitea.com/gitea/go-sdk/pulls/408)
+
+
+## All Function return http responce
+
+All functions got one new return (`Responce`)!  
+If you just like to migrate, add `_,` before the error return.
+
+example:
+```diff
+- user, err := c.GetMyUserInfo()
++ user, _, err := c.GetMyUserInfo()
+```
+
+If you like to check responce if an error ocure, make sure responce is not nil!  
+If an error ocure before an http request (e.g. gitea is to old), it will be nil.
+
+Pulls:
+-   [#416 All Function return http responce](https://gitea.com/gitea/go-sdk/pulls/416)

gitea/Issue_label_test.go

@@ -32,7 +32,7 @@ func TestLabels(t *testing.T) {
 	assert.EqualValues(t, "empty name not allowed", err.Error())
 	createOpts.Name = "label one"
 
-	label1, err := c.CreateLabel(repo.Owner.UserName, repo.Name, createOpts)
+	label1, _, err := c.CreateLabel(repo.Owner.UserName, repo.Name, createOpts)
 	assert.NoError(t, err)
 	assert.EqualValues(t, createOpts.Name, label1.Name)
 	assert.EqualValues(t, createOpts.Color, label1.Color)

gitea/admin_cron.go

@@ -24,20 +24,21 @@ type ListCronTaskOptions struct {
 }
 
 // ListCronTasks list available cron tasks
-func (c *Client) ListCronTasks(opt ListCronTaskOptions) ([]*CronTask, error) {
+func (c *Client) ListCronTasks(opt ListCronTaskOptions) ([]*CronTask, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	opt.setDefaults()
 	ct := make([]*CronTask, 0, opt.PageSize)
-	return ct, c.getParsedResponse("GET", fmt.Sprintf("/admin/cron?%s", opt.getURLQuery().Encode()), jsonHeader, nil, &ct)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/admin/cron?%s", opt.getURLQuery().Encode()), jsonHeader, nil, &ct)
+	return ct, resp, err
 }
 
 // RunCronTasks run a cron task
-func (c *Client) RunCronTasks(task string) error {
+func (c *Client) RunCronTasks(task string) (*Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
-		return err
+		return nil, err
 	}
-	_, err := c.getResponse("POST", fmt.Sprintf("/admin/cron/%s", task), jsonHeader, nil)
+	_, resp, err := c.getResponse("POST", fmt.Sprintf("/admin/cron/%s", task), jsonHeader, nil)
-	return err
+	return resp, err
 }

gitea/admin_org.go

@@ -17,19 +17,20 @@ type AdminListOrgsOptions struct {
 }
 
 // AdminListOrgs lists all orgs
-func (c *Client) AdminListOrgs(opt AdminListOrgsOptions) ([]*Organization, error) {
+func (c *Client) AdminListOrgs(opt AdminListOrgsOptions) ([]*Organization, *Response, error) {
 	opt.setDefaults()
 	orgs := make([]*Organization, 0, opt.PageSize)
-	return orgs, c.getParsedResponse("GET", fmt.Sprintf("/admin/orgs?%s", opt.getURLQuery().Encode()), nil, nil, &orgs)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/admin/orgs?%s", opt.getURLQuery().Encode()), nil, nil, &orgs)
+	return orgs, resp, err
 }
 
 // AdminCreateOrg create an organization
-func (c *Client) AdminCreateOrg(user string, opt CreateOrgOption) (*Organization, error) {
+func (c *Client) AdminCreateOrg(user string, opt CreateOrgOption) (*Organization, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	org := new(Organization)
-	return org, c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/orgs", user),
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/orgs", user), jsonHeader, bytes.NewReader(body), org)
-		jsonHeader, bytes.NewReader(body), org)
+	return org, resp, err
 }

gitea/admin_repo.go

@@ -11,12 +11,12 @@ import (
 )
 
 // AdminCreateRepo create a repo
-func (c *Client) AdminCreateRepo(user string, opt CreateRepoOption) (*Repository, error) {
+func (c *Client) AdminCreateRepo(user string, opt CreateRepoOption) (*Repository, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	repo := new(Repository)
-	return repo, c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/repos", user),
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/repos", user), jsonHeader, bytes.NewReader(body), repo)
-		jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
 }

gitea/admin_test.go

@@ -14,11 +14,11 @@ import (
 func TestAdminOrg(t *testing.T) {
 	log.Println("== TestAdminOrg ==")
 	c := newTestClient()
-	user, err := c.GetMyUserInfo()
+	user, _, err := c.GetMyUserInfo()
 	assert.NoError(t, err)
 
 	orgName := "NewTestOrg"
-	newOrg, err := c.AdminCreateOrg(user.UserName, CreateOrgOption{
+	newOrg, _, err := c.AdminCreateOrg(user.UserName, CreateOrgOption{
 		Name:        orgName,
 		FullName:    orgName + " FullName",
 		Description: "test adminCreateOrg",
@@ -28,12 +28,12 @@ func TestAdminOrg(t *testing.T) {
 	assert.NotEmpty(t, newOrg)
 	assert.EqualValues(t, orgName, newOrg.UserName)
 
-	orgs, err := c.AdminListOrgs(AdminListOrgsOptions{})
+	orgs, _, err := c.AdminListOrgs(AdminListOrgsOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, orgs, 1)
 	assert.EqualValues(t, newOrg.ID, orgs[0].ID)
 
-	err = c.DeleteOrg(orgName)
+	_, err = c.DeleteOrg(orgName)
 	assert.NoError(t, err)
 }
 
@@ -41,9 +41,9 @@ func TestAdminCronTasks(t *testing.T) {
 	log.Println("== TestAdminCronTasks ==")
 	c := newTestClient()
 
-	tasks, err := c.ListCronTasks(ListCronTaskOptions{})
+	tasks, _, err := c.ListCronTasks(ListCronTaskOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, tasks, 15)
-
+	_, err = c.RunCronTasks(tasks[0].Name)
-	assert.NoError(t, c.RunCronTasks(tasks[0].Name))
+	assert.NoError(t, err)
 }

gitea/admin_user.go

@@ -17,10 +17,11 @@ type AdminListUsersOptions struct {
 }
 
 // AdminListUsers lists all users
-func (c *Client) AdminListUsers(opt AdminListUsersOptions) ([]*User, error) {
+func (c *Client) AdminListUsers(opt AdminListUsersOptions) ([]*User, *Response, error) {
 	opt.setDefaults()
 	users := make([]*User, 0, opt.PageSize)
-	return users, c.getParsedResponse("GET", fmt.Sprintf("/admin/users?%s", opt.getURLQuery().Encode()), nil, nil, &users)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/admin/users?%s", opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
 }
 
 // CreateUserOption create user options
@@ -47,16 +48,17 @@ func (opt CreateUserOption) Validate() error {
 }
 
 // AdminCreateUser create a user
-func (c *Client) AdminCreateUser(opt CreateUserOption) (*User, error) {
+func (c *Client) AdminCreateUser(opt CreateUserOption) (*User, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	user := new(User)
-	return user, c.getParsedResponse("POST", "/admin/users", jsonHeader, bytes.NewReader(body), user)
+	resp, err := c.getParsedResponse("POST", "/admin/users", jsonHeader, bytes.NewReader(body), user)
+	return user, resp, err
 }
 
 // EditUserOption edit user options
@@ -79,33 +81,34 @@ type EditUserOption struct {
 }
 
 // AdminEditUser modify user informations
-func (c *Client) AdminEditUser(user string, opt EditUserOption) error {
+func (c *Client) AdminEditUser(user string, opt EditUserOption) (*Response, error) {
-	body, err := json.Marshal(&opt)
-	if err != nil {
-		return err
-	}
-	_, err = c.getResponse("PATCH", fmt.Sprintf("/admin/users/%s", user), jsonHeader, bytes.NewReader(body))
-	return err
-}
-
-// AdminDeleteUser delete one user according name
-func (c *Client) AdminDeleteUser(user string) error {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/admin/users/%s", user), nil, nil)
-	return err
-}
-
-// AdminCreateUserPublicKey adds a public key for the user
-func (c *Client) AdminCreateUserPublicKey(user string, opt CreateKeyOption) (*PublicKey, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
 		return nil, err
 	}
+	_, resp, err := c.getResponse("PATCH", fmt.Sprintf("/admin/users/%s", user), jsonHeader, bytes.NewReader(body))
+	return resp, err
+}
+
+// AdminDeleteUser delete one user according name
+func (c *Client) AdminDeleteUser(user string) (*Response, error) {
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/admin/users/%s", user), nil, nil)
+	return resp, err
+}
+
+// AdminCreateUserPublicKey adds a public key for the user
+func (c *Client) AdminCreateUserPublicKey(user string, opt CreateKeyOption) (*PublicKey, *Response, error) {
+	body, err := json.Marshal(&opt)
+	if err != nil {
+		return nil, nil, err
+	}
 	key := new(PublicKey)
-	return key, c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/keys", user), jsonHeader, bytes.NewReader(body), key)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/admin/users/%s/keys", user), jsonHeader, bytes.NewReader(body), key)
+	return key, resp, err
 }
 
 // AdminDeleteUserPublicKey deletes a user's public key
-func (c *Client) AdminDeleteUserPublicKey(user string, keyID int) error {
+func (c *Client) AdminDeleteUserPublicKey(user string, keyID int) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/admin/users/%s/keys/%d", user, keyID), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/admin/users/%s/keys/%d", user, keyID), nil, nil)
-	return err
+	return resp, err
 }

gitea/attachment.go

@@ -30,47 +30,47 @@ type ListReleaseAttachmentsOptions struct {
 }
 
 // ListReleaseAttachments list release's attachments
-func (c *Client) ListReleaseAttachments(user, repo string, release int64, opt ListReleaseAttachmentsOptions) ([]*Attachment, error) {
+func (c *Client) ListReleaseAttachments(user, repo string, release int64, opt ListReleaseAttachmentsOptions) ([]*Attachment, *Response, error) {
 	opt.setDefaults()
 	attachments := make([]*Attachment, 0, opt.PageSize)
-	err := c.getParsedResponse("GET",
+	resp, err := c.getParsedResponse("GET",
 		fmt.Sprintf("/repos/%s/%s/releases/%d/assets?%s", user, repo, release, opt.getURLQuery().Encode()),
 		nil, nil, &attachments)
-	return attachments, err
+	return attachments, resp, err
 }
 
 // GetReleaseAttachment returns the requested attachment
-func (c *Client) GetReleaseAttachment(user, repo string, release int64, id int64) (*Attachment, error) {
+func (c *Client) GetReleaseAttachment(user, repo string, release int64, id int64) (*Attachment, *Response, error) {
 	a := new(Attachment)
-	err := c.getParsedResponse("GET",
+	resp, err := c.getParsedResponse("GET",
 		fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, id),
 		nil, nil, &a)
-	return a, err
+	return a, resp, err
 }
 
 // CreateReleaseAttachment creates an attachment for the given release
-func (c *Client) CreateReleaseAttachment(user, repo string, release int64, file io.Reader, filename string) (*Attachment, error) {
+func (c *Client) CreateReleaseAttachment(user, repo string, release int64, file io.Reader, filename string) (*Attachment, *Response, error) {
 	// Write file to body
 	body := new(bytes.Buffer)
 	writer := multipart.NewWriter(body)
 	part, err := writer.CreateFormFile("attachment", filename)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	if _, err = io.Copy(part, file); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	if err = writer.Close(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	// Send request
 	attachment := new(Attachment)
-	err = c.getParsedResponse("POST",
+	resp, err := c.getParsedResponse("POST",
 		fmt.Sprintf("/repos/%s/%s/releases/%d/assets", user, repo, release),
 		http.Header{"Content-Type": {writer.FormDataContentType()}}, body, &attachment)
-	return attachment, err
+	return attachment, resp, err
 }
 
 // EditAttachmentOptions options for editing attachments
@@ -79,17 +79,18 @@ type EditAttachmentOptions struct {
 }
 
 // EditReleaseAttachment updates the given attachment with the given options
-func (c *Client) EditReleaseAttachment(user, repo string, release int64, attachment int64, form EditAttachmentOptions) (*Attachment, error) {
+func (c *Client) EditReleaseAttachment(user, repo string, release int64, attachment int64, form EditAttachmentOptions) (*Attachment, *Response, error) {
 	body, err := json.Marshal(&form)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	attach := new(Attachment)
-	return attach, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, attachment), jsonHeader, bytes.NewReader(body), attach)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, attachment), jsonHeader, bytes.NewReader(body), attach)
+	return attach, resp, err
 }
 
 // DeleteReleaseAttachment deletes the given attachment including the uploaded file
-func (c *Client) DeleteReleaseAttachment(user, repo string, release int64, id int64) error {
+func (c *Client) DeleteReleaseAttachment(user, repo string, release int64, id int64) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, id), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, id), nil, nil)
-	return err
+	return resp, err
 }

gitea/client.go

@@ -38,6 +38,11 @@ type Client struct {
 	versionLock   sync.RWMutex
 }
 
+// Response represents the gitea response
+type Response struct {
+	*http.Response
+}
+
 // NewClient initializes and returns a API client.
 func NewClient(url, token string) *Client {
 	return &Client{
@@ -74,21 +79,22 @@ func (c *Client) SetSudo(sudo string) {
 	c.sudo = sudo
 }
 
-func (c *Client) getWebResponse(method, path string, body io.Reader) ([]byte, error) {
+func (c *Client) getWebResponse(method, path string, body io.Reader) ([]byte, *Response, error) {
 	req, err := http.NewRequest(method, c.url+path, body)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	defer resp.Body.Close()
-	return ioutil.ReadAll(resp.Body)
+	data, err := ioutil.ReadAll(resp.Body)
+	return data, &Response{resp}, nil
 }
 
-func (c *Client) doRequest(method, path string, header http.Header, body io.Reader) (*http.Response, error) {
+func (c *Client) doRequest(method, path string, header http.Header, body io.Reader) (*Response, error) {
 	req, err := http.NewRequest(method, c.url+"/api/v1"+path, body)
 	if err != nil {
 		return nil, err
@@ -109,30 +115,34 @@ func (c *Client) doRequest(method, path string, header http.Header, body io.Read
 		req.Header[k] = v
 	}
 
-	return c.client.Do(req)
+	resp, err := c.client.Do(req)
-}
-
-func (c *Client) getResponse(method, path string, header http.Header, body io.Reader) ([]byte, error) {
-	resp, err := c.doRequest(method, path, header, body)
 	if err != nil {
 		return nil, err
 	}
+	return &Response{resp}, nil
+}
+
+func (c *Client) getResponse(method, path string, header http.Header, body io.Reader) ([]byte, *Response, error) {
+	resp, err := c.doRequest(method, path, header, body)
+	if err != nil {
+		return nil, nil, err
+	}
 	defer resp.Body.Close()
 
 	data, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return nil, err
+		return nil, resp, err
 	}
 
 	switch resp.StatusCode {
 	case 403:
-		return nil, errors.New("403 Forbidden")
+		return data, resp, errors.New("403 Forbidden")
 	case 404:
-		return nil, errors.New("404 Not Found")
+		return data, resp, errors.New("404 Not Found")
 	case 409:
-		return nil, errors.New("409 Conflict")
+		return data, resp, errors.New("409 Conflict")
 	case 422:
-		return nil, fmt.Errorf("422 Unprocessable Entity: %s", string(data))
+		return data, resp, fmt.Errorf("422 Unprocessable Entity: %s", string(data))
 	}
 
 	if resp.StatusCode/100 != 2 {
@@ -140,28 +150,28 @@ func (c *Client) getResponse(method, path string, header http.Header, body io.Re
 		if err = json.Unmarshal(data, &errMap); err != nil {
 			// when the JSON can't be parsed, data was probably empty or a plain string,
 			// so we try to return a helpful error anyway
-			return nil, fmt.Errorf("Unknown API Error: %d\nRequest: '%s' with '%s' method '%s' header and '%s' body", resp.StatusCode, path, method, header, string(data))
+			return data, resp, fmt.Errorf("Unknown API Error: %d\nRequest: '%s' with '%s' method '%s' header and '%s' body", resp.StatusCode, path, method, header, string(data))
 		}
-		return nil, errors.New(errMap["message"].(string))
+		return data, resp, errors.New(errMap["message"].(string))
 	}
 
-	return data, nil
+	return data, resp, nil
 }
 
-func (c *Client) getParsedResponse(method, path string, header http.Header, body io.Reader, obj interface{}) error {
+func (c *Client) getParsedResponse(method, path string, header http.Header, body io.Reader, obj interface{}) (*Response, error) {
-	data, err := c.getResponse(method, path, header, body)
+	data, resp, err := c.getResponse(method, path, header, body)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	return json.Unmarshal(data, obj)
+	return resp, json.Unmarshal(data, obj)
 }
 
-func (c *Client) getStatusCode(method, path string, header http.Header, body io.Reader) (int, error) {
+func (c *Client) getStatusCode(method, path string, header http.Header, body io.Reader) (int, *Response, error) {
 	resp, err := c.doRequest(method, path, header, body)
 	if err != nil {
-		return -1, err
+		return -1, resp, err
 	}
 	defer resp.Body.Close()
 
-	return resp.StatusCode, nil
+	return resp.StatusCode, resp, nil
 }

gitea/fork.go

@@ -16,12 +16,13 @@ type ListForksOptions struct {
 }
 
 // ListForks list a repository's forks
-func (c *Client) ListForks(user string, repo string, opt ListForksOptions) ([]*Repository, error) {
+func (c *Client) ListForks(user string, repo string, opt ListForksOptions) ([]*Repository, *Response, error) {
 	opt.setDefaults()
 	forks := make([]*Repository, opt.PageSize)
-	return forks, c.getParsedResponse("GET",
+	resp, err := c.getParsedResponse("GET",
 		fmt.Sprintf("/repos/%s/%s/forks?%s", user, repo, opt.getURLQuery().Encode()),
 		nil, nil, &forks)
+	return forks, resp, err
 }
 
 // CreateForkOption options for creating a fork
@@ -31,11 +32,12 @@ type CreateForkOption struct {
 }
 
 // CreateFork create a fork of a repository
-func (c *Client) CreateFork(user, repo string, form CreateForkOption) (*Repository, error) {
+func (c *Client) CreateFork(user, repo string, form CreateForkOption) (*Repository, *Response, error) {
 	body, err := json.Marshal(form)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	fork := new(Repository)
-	return fork, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/forks", user, repo), jsonHeader, bytes.NewReader(body), &fork)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/forks", user, repo), jsonHeader, bytes.NewReader(body), &fork)
+	return fork, resp, err
 }

gitea/git_blob.go

@@ -18,7 +18,8 @@ type GitBlobResponse struct {
 }
 
 // GetBlob get the blob of a repository file
-func (c *Client) GetBlob(user, repo, sha string) (*GitBlobResponse, error) {
+func (c *Client) GetBlob(user, repo, sha string) (*GitBlobResponse, *Response, error) {
 	blob := new(GitBlobResponse)
-	return blob, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/blobs/%s", user, repo, sha), nil, nil, blob)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/blobs/%s", user, repo, sha), nil, nil, blob)
+	return blob, resp, err
 }

gitea/git_hook.go

@@ -23,16 +23,18 @@ type ListRepoGitHooksOptions struct {
 }
 
 // ListRepoGitHooks list all the Git hooks of one repository
-func (c *Client) ListRepoGitHooks(user, repo string, opt ListRepoGitHooksOptions) ([]*GitHook, error) {
+func (c *Client) ListRepoGitHooks(user, repo string, opt ListRepoGitHooksOptions) ([]*GitHook, *Response, error) {
 	opt.setDefaults()
 	hooks := make([]*GitHook, 0, opt.PageSize)
-	return hooks, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/git?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &hooks)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/git?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &hooks)
+	return hooks, resp, err
 }
 
 // GetRepoGitHook get a Git hook of a repository
-func (c *Client) GetRepoGitHook(user, repo, id string) (*GitHook, error) {
+func (c *Client) GetRepoGitHook(user, repo, id string) (*GitHook, *Response, error) {
 	h := new(GitHook)
-	return h, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), nil, nil, h)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), nil, nil, h)
+	return h, resp, err
 }
 
 // EditGitHookOption options when modifying one Git hook
@@ -41,17 +43,17 @@ type EditGitHookOption struct {
 }
 
 // EditRepoGitHook modify one Git hook of a repository
-func (c *Client) EditRepoGitHook(user, repo, id string, opt EditGitHookOption) error {
+func (c *Client) EditRepoGitHook(user, repo, id string, opt EditGitHookOption) (*Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("PATCH", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), jsonHeader, bytes.NewReader(body))
+	_, resp, err := c.getResponse("PATCH", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), jsonHeader, bytes.NewReader(body))
-	return err
+	return resp, err
 }
 
 // DeleteRepoGitHook delete one Git hook from a repository
-func (c *Client) DeleteRepoGitHook(user, repo, id string) error {
+func (c *Client) DeleteRepoGitHook(user, repo, id string) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/hooks/git/%s", user, repo, id), nil, nil)
-	return err
+	return resp, err
 }

gitea/hook.go

@@ -30,29 +30,33 @@ type ListHooksOptions struct {
 }
 
 // ListOrgHooks list all the hooks of one organization
-func (c *Client) ListOrgHooks(org string, opt ListHooksOptions) ([]*Hook, error) {
+func (c *Client) ListOrgHooks(org string, opt ListHooksOptions) ([]*Hook, *Response, error) {
 	opt.setDefaults()
 	hooks := make([]*Hook, 0, opt.PageSize)
-	return hooks, c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/hooks?%s", org, opt.getURLQuery().Encode()), nil, nil, &hooks)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/hooks?%s", org, opt.getURLQuery().Encode()), nil, nil, &hooks)
+	return hooks, resp, err
 }
 
 // ListRepoHooks list all the hooks of one repository
-func (c *Client) ListRepoHooks(user, repo string, opt ListHooksOptions) ([]*Hook, error) {
+func (c *Client) ListRepoHooks(user, repo string, opt ListHooksOptions) ([]*Hook, *Response, error) {
 	opt.setDefaults()
 	hooks := make([]*Hook, 0, opt.PageSize)
-	return hooks, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &hooks)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &hooks)
+	return hooks, resp, err
 }
 
 // GetOrgHook get a hook of an organization
-func (c *Client) GetOrgHook(org string, id int64) (*Hook, error) {
+func (c *Client) GetOrgHook(org string, id int64) (*Hook, *Response, error) {
 	h := new(Hook)
-	return h, c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), nil, nil, h)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), nil, nil, h)
+	return h, resp, err
 }
 
 // GetRepoHook get a hook of a repository
-func (c *Client) GetRepoHook(user, repo string, id int64) (*Hook, error) {
+func (c *Client) GetRepoHook(user, repo string, id int64) (*Hook, *Response, error) {
 	h := new(Hook)
-	return h, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), nil, nil, h)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), nil, nil, h)
+	return h, resp, err
 }
 
 // CreateHookOption options when create a hook
@@ -73,26 +77,28 @@ func (opt CreateHookOption) Validate() error {
 }
 
 // CreateOrgHook create one hook for an organization, with options
-func (c *Client) CreateOrgHook(org string, opt CreateHookOption) (*Hook, error) {
+func (c *Client) CreateOrgHook(org string, opt CreateHookOption) (*Hook, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	h := new(Hook)
-	return h, c.getParsedResponse("POST", fmt.Sprintf("/orgs/%s/hooks", org), jsonHeader, bytes.NewReader(body), h)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/orgs/%s/hooks", org), jsonHeader, bytes.NewReader(body), h)
+	return h, resp, err
 }
 
 // CreateRepoHook create one hook for a repository, with options
-func (c *Client) CreateRepoHook(user, repo string, opt CreateHookOption) (*Hook, error) {
+func (c *Client) CreateRepoHook(user, repo string, opt CreateHookOption) (*Hook, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	h := new(Hook)
-	return h, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/hooks", user, repo), jsonHeader, bytes.NewReader(body), h)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/hooks", user, repo), jsonHeader, bytes.NewReader(body), h)
+	return h, resp, err
 }
 
 // EditHookOption options when modify one hook
@@ -104,33 +110,33 @@ type EditHookOption struct {
 }
 
 // EditOrgHook modify one hook of an organization, with hook id and options
-func (c *Client) EditOrgHook(org string, id int64, opt EditHookOption) error {
+func (c *Client) EditOrgHook(org string, id int64, opt EditHookOption) (*Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("PATCH", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), jsonHeader, bytes.NewReader(body))
+	_, resp, err := c.getResponse("PATCH", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), jsonHeader, bytes.NewReader(body))
-	return err
+	return resp, err
 }
 
 // EditRepoHook modify one hook of a repository, with hook id and options
-func (c *Client) EditRepoHook(user, repo string, id int64, opt EditHookOption) error {
+func (c *Client) EditRepoHook(user, repo string, id int64, opt EditHookOption) (*Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("PATCH", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), jsonHeader, bytes.NewReader(body))
+	_, resp, err := c.getResponse("PATCH", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), jsonHeader, bytes.NewReader(body))
-	return err
+	return resp, err
 }
 
 // DeleteOrgHook delete one hook from an organization, with hook id
-func (c *Client) DeleteOrgHook(org string, id int64) error {
+func (c *Client) DeleteOrgHook(org string, id int64) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s/hooks/%d", org, id), nil, nil)
-	return err
+	return resp, err
 }
 
 // DeleteRepoHook delete one hook from a repository, with hook id
-func (c *Client) DeleteRepoHook(user, repo string, id int64) error {
+func (c *Client) DeleteRepoHook(user, repo string, id int64) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/hooks/%d", user, repo, id), nil, nil)
-	return err
+	return resp, err
 }

gitea/issue.go

@@ -114,13 +114,13 @@ func (opt *ListIssueOption) QueryEncode() string {
 }
 
 // ListIssues returns all issues assigned the authenticated user
-func (c *Client) ListIssues(opt ListIssueOption) ([]*Issue, error) {
+func (c *Client) ListIssues(opt ListIssueOption) ([]*Issue, *Response, error) {
 	opt.setDefaults()
 	issues := make([]*Issue, 0, opt.PageSize)
 
 	link, _ := url.Parse("/repos/issues/search")
 	link.RawQuery = opt.QueryEncode()
-	err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &issues)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &issues)
 	if e := c.CheckServerVersionConstraint(">=1.12.0"); e != nil {
 		for i := 0; i < len(issues); i++ {
 			if issues[i].Repository != nil {
@@ -128,17 +128,17 @@ func (c *Client) ListIssues(opt ListIssueOption) ([]*Issue, error) {
 			}
 		}
 	}
-	return issues, err
+	return issues, resp, err
 }
 
 // ListRepoIssues returns all issues for a given repository
-func (c *Client) ListRepoIssues(owner, repo string, opt ListIssueOption) ([]*Issue, error) {
+func (c *Client) ListRepoIssues(owner, repo string, opt ListIssueOption) ([]*Issue, *Response, error) {
 	opt.setDefaults()
 	issues := make([]*Issue, 0, opt.PageSize)
 
 	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues", owner, repo))
 	link.RawQuery = opt.QueryEncode()
-	err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &issues)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &issues)
 	if e := c.CheckServerVersionConstraint(">=1.12.0"); e != nil {
 		for i := 0; i < len(issues); i++ {
 			if issues[i].Repository != nil {
@@ -146,17 +146,17 @@ func (c *Client) ListRepoIssues(owner, repo string, opt ListIssueOption) ([]*Iss
 			}
 		}
 	}
-	return issues, err
+	return issues, resp, err
 }
 
 // GetIssue returns a single issue for a given repository
-func (c *Client) GetIssue(owner, repo string, index int64) (*Issue, error) {
+func (c *Client) GetIssue(owner, repo string, index int64) (*Issue, *Response, error) {
 	issue := new(Issue)
-	err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index), nil, nil, issue)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index), nil, nil, issue)
 	if e := c.CheckServerVersionConstraint(">=1.12.0"); e != nil && issue.Repository != nil {
 		issue.Repository.Owner = strings.Split(issue.Repository.FullName, "/")[0]
 	}
-	return issue, err
+	return issue, resp, err
 }
 
 // CreateIssueOption options to create one issue
@@ -183,17 +183,18 @@ func (opt CreateIssueOption) Validate() error {
 }
 
 // CreateIssue create a new issue for a given repository
-func (c *Client) CreateIssue(owner, repo string, opt CreateIssueOption) (*Issue, error) {
+func (c *Client) CreateIssue(owner, repo string, opt CreateIssueOption) (*Issue, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	issue := new(Issue)
-	return issue, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues", owner, repo),
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues", owner, repo),
 		jsonHeader, bytes.NewReader(body), issue)
+	return issue, resp, err
 }
 
 // EditIssueOption options for editing an issue
@@ -216,15 +217,17 @@ func (opt EditIssueOption) Validate() error {
 }
 
 // EditIssue modify an existing issue for a given repository
-func (c *Client) EditIssue(owner, repo string, index int64, opt EditIssueOption) (*Issue, error) {
+func (c *Client) EditIssue(owner, repo string, index int64, opt EditIssueOption) (*Issue, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	issue := new(Issue)
-	return issue, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index),
+	resp, err := c.getParsedResponse("PATCH",
+		fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index),
 		jsonHeader, bytes.NewReader(body), issue)
+	return issue, resp, err
 }

gitea/issue_comment.go

@@ -46,30 +46,33 @@ func (opt *ListIssueCommentOptions) QueryEncode() string {
 }
 
 // ListIssueComments list comments on an issue.
-func (c *Client) ListIssueComments(owner, repo string, index int64, opt ListIssueCommentOptions) ([]*Comment, error) {
+func (c *Client) ListIssueComments(owner, repo string, index int64, opt ListIssueCommentOptions) ([]*Comment, *Response, error) {
 	opt.setDefaults()
 	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index))
 	link.RawQuery = opt.QueryEncode()
 	comments := make([]*Comment, 0, opt.PageSize)
-	return comments, c.getParsedResponse("GET", link.String(), nil, nil, &comments)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &comments)
+	return comments, resp, err
 }
 
 // ListRepoIssueComments list comments for a given repo.
-func (c *Client) ListRepoIssueComments(owner, repo string, opt ListIssueCommentOptions) ([]*Comment, error) {
+func (c *Client) ListRepoIssueComments(owner, repo string, opt ListIssueCommentOptions) ([]*Comment, *Response, error) {
 	opt.setDefaults()
 	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/issues/comments", owner, repo))
 	link.RawQuery = opt.QueryEncode()
 	comments := make([]*Comment, 0, opt.PageSize)
-	return comments, c.getParsedResponse("GET", link.String(), nil, nil, &comments)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &comments)
+	return comments, resp, err
 }
 
 // GetIssueComment get a comment for a given repo by id.
-func (c *Client) GetIssueComment(owner, repo string, id int64) (*Comment, error) {
+func (c *Client) GetIssueComment(owner, repo string, id int64) (*Comment, *Response, error) {
 	comment := new(Comment)
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return comment, err
+		return comment, nil, err
 	}
-	return comment, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, id), nil, nil, &comment)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, id), nil, nil, &comment)
+	return comment, resp, err
 }
 
 // CreateIssueCommentOption options for creating a comment on an issue
@@ -86,16 +89,17 @@ func (opt CreateIssueCommentOption) Validate() error {
 }
 
 // CreateIssueComment create comment on an issue.
-func (c *Client) CreateIssueComment(owner, repo string, index int64, opt CreateIssueCommentOption) (*Comment, error) {
+func (c *Client) CreateIssueComment(owner, repo string, index int64, opt CreateIssueCommentOption) (*Comment, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	comment := new(Comment)
-	return comment, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index), jsonHeader, bytes.NewReader(body), comment)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index), jsonHeader, bytes.NewReader(body), comment)
+	return comment, resp, err
 }
 
 // EditIssueCommentOption options for editing a comment
@@ -112,20 +116,21 @@ func (opt EditIssueCommentOption) Validate() error {
 }
 
 // EditIssueComment edits an issue comment.
-func (c *Client) EditIssueComment(owner, repo string, commentID int64, opt EditIssueCommentOption) (*Comment, error) {
+func (c *Client) EditIssueComment(owner, repo string, commentID int64, opt EditIssueCommentOption) (*Comment, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	comment := new(Comment)
-	return comment, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, commentID), jsonHeader, bytes.NewReader(body), comment)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, commentID), jsonHeader, bytes.NewReader(body), comment)
+	return comment, resp, err
 }
 
 // DeleteIssueComment deletes an issue comment.
-func (c *Client) DeleteIssueComment(owner, repo string, commentID int64) error {
+func (c *Client) DeleteIssueComment(owner, repo string, commentID int64) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, commentID), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/comments/%d", owner, repo, commentID), nil, nil)
-	return err
+	return resp, err
 }

gitea/issue_comment_test.go

@@ -16,15 +16,15 @@ func TestIssueComment(t *testing.T) {
 
 	c := newTestClient()
 
-	user, err := c.GetMyUserInfo()
+	user, _, err := c.GetMyUserInfo()
 
 	assert.NoError(t, err)
 	repo, err := createTestRepo(t, "TestIssueCommentRepo", c)
 	assert.NoError(t, err)
-	issue1, err := c.CreateIssue(user.UserName, repo.Name, CreateIssueOption{Title: "issue1", Body: "body", Closed: false})
+	issue1, _, err := c.CreateIssue(user.UserName, repo.Name, CreateIssueOption{Title: "issue1", Body: "body", Closed: false})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, issue1.Index)
-	issue2, err := c.CreateIssue(user.UserName, repo.Name, CreateIssueOption{Title: "issue1", Body: "body", Closed: false})
+	issue2, _, err := c.CreateIssue(user.UserName, repo.Name, CreateIssueOption{Title: "issue1", Body: "body", Closed: false})
 	assert.EqualValues(t, 2, issue2.Index)
 	assert.NoError(t, err)
 	tUser2 := createTestUser(t, "Commenter2", c)
@@ -32,7 +32,7 @@ func TestIssueComment(t *testing.T) {
 
 	createOne := func(u *User, issue int64, text string) {
 		c.sudo = u.UserName
-		comment, e := c.CreateIssueComment(user.UserName, repo.Name, issue, CreateIssueCommentOption{Body: text})
+		comment, _, e := c.CreateIssueComment(user.UserName, repo.Name, issue, CreateIssueCommentOption{Body: text})
 		c.sudo = ""
 		assert.NoError(t, e)
 		assert.NotEmpty(t, comment)
@@ -49,34 +49,36 @@ func TestIssueComment(t *testing.T) {
 	createOne(tUser2, 2, "second")
 	createOne(user, 2, "3")
 
-	assert.NoError(t, c.AdminDeleteUser(tUser3.UserName))
+	_, err = c.AdminDeleteUser(tUser3.UserName)
+	assert.NoError(t, err)
 
 	// ListRepoIssueComments
-	comments, err := c.ListRepoIssueComments(user.UserName, repo.Name, ListIssueCommentOptions{})
+	comments, _, err := c.ListRepoIssueComments(user.UserName, repo.Name, ListIssueCommentOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, comments, 7)
 
 	// ListIssueComments
-	comments, err = c.ListIssueComments(user.UserName, repo.Name, 2, ListIssueCommentOptions{})
+	comments, _, err = c.ListIssueComments(user.UserName, repo.Name, 2, ListIssueCommentOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, comments, 3)
 
 	// GetIssueComment
-	comment, err := c.GetIssueComment(user.UserName, repo.Name, comments[1].ID)
+	comment, _, err := c.GetIssueComment(user.UserName, repo.Name, comments[1].ID)
 	assert.NoError(t, err)
 	assert.EqualValues(t, comment.Poster.ID, comments[1].Poster.ID)
 	assert.EqualValues(t, comment.Body, comments[1].Body)
 	assert.EqualValues(t, comment.Updated.Unix(), comments[1].Updated.Unix())
 
 	// EditIssueComment
-	comment, err = c.EditIssueComment(user.UserName, repo.Name, comments[1].ID, EditIssueCommentOption{
+	comment, _, err = c.EditIssueComment(user.UserName, repo.Name, comments[1].ID, EditIssueCommentOption{
 		Body: "changed my mind",
 	})
 	assert.NoError(t, err)
 	assert.EqualValues(t, "changed my mind", comment.Body)
 
 	// DeleteIssueComment
-	assert.NoError(t, c.DeleteIssueComment(user.UserName, repo.Name, comments[1].ID))
+	_, err = c.DeleteIssueComment(user.UserName, repo.Name, comments[1].ID)
-	_, err = c.GetIssueComment(user.UserName, repo.Name, comments[1].ID)
+	assert.NoError(t, err)
+	_, _, err = c.GetIssueComment(user.UserName, repo.Name, comments[1].ID)
 	assert.Error(t, err)
 }

gitea/issue_label.go

@@ -28,16 +28,18 @@ type ListLabelsOptions struct {
 }
 
 // ListRepoLabels list labels of one repository
-func (c *Client) ListRepoLabels(owner, repo string, opt ListLabelsOptions) ([]*Label, error) {
+func (c *Client) ListRepoLabels(owner, repo string, opt ListLabelsOptions) ([]*Label, *Response, error) {
 	opt.setDefaults()
 	labels := make([]*Label, 0, opt.PageSize)
-	return labels, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/labels?%s", owner, repo, opt.getURLQuery().Encode()), nil, nil, &labels)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/labels?%s", owner, repo, opt.getURLQuery().Encode()), nil, nil, &labels)
+	return labels, resp, err
 }
 
 // GetRepoLabel get one label of repository by repo it
-func (c *Client) GetRepoLabel(owner, repo string, id int64) (*Label, error) {
+func (c *Client) GetRepoLabel(owner, repo string, id int64) (*Label, *Response, error) {
 	label := new(Label)
-	return label, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), nil, nil, label)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), nil, nil, label)
+	return label, resp, err
 }
 
 // CreateLabelOption options for creating a label
@@ -64,9 +66,9 @@ func (opt CreateLabelOption) Validate() error {
 }
 
 // CreateLabel create one label of repository
-func (c *Client) CreateLabel(owner, repo string, opt CreateLabelOption) (*Label, error) {
+func (c *Client) CreateLabel(owner, repo string, opt CreateLabelOption) (*Label, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	if len(opt.Color) == 6 {
 		if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
@@ -75,11 +77,13 @@ func (c *Client) CreateLabel(owner, repo string, opt CreateLabelOption) (*Label,
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	label := new(Label)
-	return label, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/labels", owner, repo),
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/labels", owner, repo),
 		jsonHeader, bytes.NewReader(body), label)
+	return label, resp, err
 }
 
 // EditLabelOption options for editing a label
@@ -109,28 +113,30 @@ func (opt EditLabelOption) Validate() error {
 }
 
 // EditLabel modify one label with options
-func (c *Client) EditLabel(owner, repo string, id int64, opt EditLabelOption) (*Label, error) {
+func (c *Client) EditLabel(owner, repo string, id int64, opt EditLabelOption) (*Label, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	label := new(Label)
-	return label, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), jsonHeader, bytes.NewReader(body), label)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), jsonHeader, bytes.NewReader(body), label)
+	return label, resp, err
 }
 
 // DeleteLabel delete one label of repository by id
-func (c *Client) DeleteLabel(owner, repo string, id int64) error {
+func (c *Client) DeleteLabel(owner, repo string, id int64) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/labels/%d", owner, repo, id), nil, nil)
-	return err
+	return resp, err
 }
 
 // GetIssueLabels get labels of one issue via issue id
-func (c *Client) GetIssueLabels(owner, repo string, index int64, opts ListLabelsOptions) ([]*Label, error) {
+func (c *Client) GetIssueLabels(owner, repo string, index int64, opts ListLabelsOptions) ([]*Label, *Response, error) {
 	labels := make([]*Label, 0, 5)
-	return labels, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/labels?%s", owner, repo, index, opts.getURLQuery().Encode()), nil, nil, &labels)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/labels?%s", owner, repo, index, opts.getURLQuery().Encode()), nil, nil, &labels)
+	return labels, resp, err
 }
 
 // IssueLabelsOption a collection of labels
@@ -140,34 +146,36 @@ type IssueLabelsOption struct {
 }
 
 // AddIssueLabels add one or more labels to one issue
-func (c *Client) AddIssueLabels(owner, repo string, index int64, opt IssueLabelsOption) ([]*Label, error) {
+func (c *Client) AddIssueLabels(owner, repo string, index int64, opt IssueLabelsOption) ([]*Label, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	var labels []*Label
-	return labels, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), jsonHeader, bytes.NewReader(body), &labels)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), jsonHeader, bytes.NewReader(body), &labels)
+	return labels, resp, err
 }
 
 // ReplaceIssueLabels replace old labels of issue with new labels
-func (c *Client) ReplaceIssueLabels(owner, repo string, index int64, opt IssueLabelsOption) ([]*Label, error) {
+func (c *Client) ReplaceIssueLabels(owner, repo string, index int64, opt IssueLabelsOption) ([]*Label, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	var labels []*Label
-	return labels, c.getParsedResponse("PUT", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), jsonHeader, bytes.NewReader(body), &labels)
+	resp, err := c.getParsedResponse("PUT", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), jsonHeader, bytes.NewReader(body), &labels)
+	return labels, resp, err
 }
 
 // DeleteIssueLabel delete one label of one issue by issue id and label id
 // TODO: maybe we need delete by label name and issue id
-func (c *Client) DeleteIssueLabel(owner, repo string, index, label int64) error {
+func (c *Client) DeleteIssueLabel(owner, repo string, index, label int64) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/labels/%d", owner, repo, index, label), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/labels/%d", owner, repo, index, label), nil, nil)
-	return err
+	return resp, err
 }
 
 // ClearIssueLabels delete all the labels of one issue.
-func (c *Client) ClearIssueLabels(owner, repo string, index int64) error {
+func (c *Client) ClearIssueLabels(owner, repo string, index int64) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/labels", owner, repo, index), nil, nil)
-	return err
+	return resp, err
 }

gitea/issue_milestone.go

@@ -48,19 +48,21 @@ func (opt *ListMilestoneOption) QueryEncode() string {
 }
 
 // ListRepoMilestones list all the milestones of one repository
-func (c *Client) ListRepoMilestones(owner, repo string, opt ListMilestoneOption) ([]*Milestone, error) {
+func (c *Client) ListRepoMilestones(owner, repo string, opt ListMilestoneOption) ([]*Milestone, *Response, error) {
 	opt.setDefaults()
 	milestones := make([]*Milestone, 0, opt.PageSize)
 
 	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/milestones", owner, repo))
 	link.RawQuery = opt.QueryEncode()
-	return milestones, c.getParsedResponse("GET", link.String(), nil, nil, &milestones)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &milestones)
+	return milestones, resp, err
 }
 
 // GetMilestone get one milestone by repo name and milestone id
-func (c *Client) GetMilestone(owner, repo string, id int64) (*Milestone, error) {
+func (c *Client) GetMilestone(owner, repo string, id int64) (*Milestone, *Response, error) {
 	milestone := new(Milestone)
-	return milestone, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), nil, nil, milestone)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), nil, nil, milestone)
+	return milestone, resp, err
 }
 
 // CreateMilestoneOption options for creating a milestone
@@ -80,16 +82,16 @@ func (opt CreateMilestoneOption) Validate() error {
 }
 
 // CreateMilestone create one milestone with options
-func (c *Client) CreateMilestone(owner, repo string, opt CreateMilestoneOption) (*Milestone, error) {
+func (c *Client) CreateMilestone(owner, repo string, opt CreateMilestoneOption) (*Milestone, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	milestone := new(Milestone)
-	err = c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/milestones", owner, repo), jsonHeader, bytes.NewReader(body), milestone)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/milestones", owner, repo), jsonHeader, bytes.NewReader(body), milestone)
 
 	// make creating closed milestones need gitea >= v1.13.0
 	// this make it backwards compatible
@@ -100,7 +102,7 @@ func (c *Client) CreateMilestone(owner, repo string, opt CreateMilestoneOption)
 		})
 	}
 
-	return milestone, err
+	return milestone, resp, err
 }
 
 // EditMilestoneOption options for editing a milestone
@@ -120,20 +122,21 @@ func (opt EditMilestoneOption) Validate() error {
 }
 
 // EditMilestone modify milestone with options
-func (c *Client) EditMilestone(owner, repo string, id int64, opt EditMilestoneOption) (*Milestone, error) {
+func (c *Client) EditMilestone(owner, repo string, id int64, opt EditMilestoneOption) (*Milestone, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	milestone := new(Milestone)
-	return milestone, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), jsonHeader, bytes.NewReader(body), milestone)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), jsonHeader, bytes.NewReader(body), milestone)
+	return milestone, resp, err
 }
 
 // DeleteMilestone delete one milestone by milestone id
-func (c *Client) DeleteMilestone(owner, repo string, id int64) error {
+func (c *Client) DeleteMilestone(owner, repo string, id int64) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/milestones/%d", owner, repo, id), nil, nil)
-	return err
+	return resp, err
 }

gitea/issue_milestone_test.go

@@ -23,41 +23,42 @@ func TestMilestones(t *testing.T) {
 	sClosed := StateClosed
 
 	// CreateMilestone 4x
-	m1, err := c.CreateMilestone(repo.Owner.UserName, repo.Name, CreateMilestoneOption{Title: "v1.0", Description: "First Version", Deadline: &now})
+	m1, _, err := c.CreateMilestone(repo.Owner.UserName, repo.Name, CreateMilestoneOption{Title: "v1.0", Description: "First Version", Deadline: &now})
 	assert.NoError(t, err)
-	_, err = c.CreateMilestone(repo.Owner.UserName, repo.Name, CreateMilestoneOption{Title: "v2.0", Description: "Second Version", Deadline: &future})
+	_, _, err = c.CreateMilestone(repo.Owner.UserName, repo.Name, CreateMilestoneOption{Title: "v2.0", Description: "Second Version", Deadline: &future})
 	assert.NoError(t, err)
-	_, err = c.CreateMilestone(repo.Owner.UserName, repo.Name, CreateMilestoneOption{Title: "v3.0", Description: "Third Version", Deadline: nil})
+	_, _, err = c.CreateMilestone(repo.Owner.UserName, repo.Name, CreateMilestoneOption{Title: "v3.0", Description: "Third Version", Deadline: nil})
 	assert.NoError(t, err)
-	m4, err := c.CreateMilestone(repo.Owner.UserName, repo.Name, CreateMilestoneOption{Title: "temp", Description: "part time milestone"})
+	m4, _, err := c.CreateMilestone(repo.Owner.UserName, repo.Name, CreateMilestoneOption{Title: "temp", Description: "part time milestone"})
 	assert.NoError(t, err)
 
 	// EditMilestone
-	m1, err = c.EditMilestone(repo.Owner.UserName, repo.Name, m1.ID, EditMilestoneOption{Description: &closed, State: &sClosed})
+	m1, _, err = c.EditMilestone(repo.Owner.UserName, repo.Name, m1.ID, EditMilestoneOption{Description: &closed, State: &sClosed})
 	assert.NoError(t, err)
 
 	// DeleteMilestone
-	assert.NoError(t, c.DeleteMilestone(repo.Owner.UserName, repo.Name, m4.ID))
+	_, err = c.DeleteMilestone(repo.Owner.UserName, repo.Name, m4.ID)
+	assert.NoError(t, err)
 
 	// ListRepoMilestones
-	ml, err := c.ListRepoMilestones(repo.Owner.UserName, repo.Name, ListMilestoneOption{})
+	ml, _, err := c.ListRepoMilestones(repo.Owner.UserName, repo.Name, ListMilestoneOption{})
 	assert.NoError(t, err)
 	assert.Len(t, ml, 2)
-	ml, err = c.ListRepoMilestones(repo.Owner.UserName, repo.Name, ListMilestoneOption{State: StateClosed})
+	ml, _, err = c.ListRepoMilestones(repo.Owner.UserName, repo.Name, ListMilestoneOption{State: StateClosed})
 	assert.NoError(t, err)
 	assert.Len(t, ml, 1)
-	ml, err = c.ListRepoMilestones(repo.Owner.UserName, repo.Name, ListMilestoneOption{State: StateAll})
+	ml, _, err = c.ListRepoMilestones(repo.Owner.UserName, repo.Name, ListMilestoneOption{State: StateAll})
 	assert.NoError(t, err)
 	assert.Len(t, ml, 3)
-	ml, err = c.ListRepoMilestones(repo.Owner.UserName, repo.Name, ListMilestoneOption{State: StateAll, Name: "V3.0"})
+	ml, _, err = c.ListRepoMilestones(repo.Owner.UserName, repo.Name, ListMilestoneOption{State: StateAll, Name: "V3.0"})
 	assert.NoError(t, err)
 	assert.Len(t, ml, 1)
 	assert.EqualValues(t, "v3.0", ml[0].Title)
 
 	// GetMilestone
-	_, err = c.GetMilestone(repo.Owner.UserName, repo.Name, m4.ID)
+	_, _, err = c.GetMilestone(repo.Owner.UserName, repo.Name, m4.ID)
 	assert.Error(t, err)
-	m, err := c.GetMilestone(repo.Owner.UserName, repo.Name, m1.ID)
+	m, _, err := c.GetMilestone(repo.Owner.UserName, repo.Name, m1.ID)
 	assert.NoError(t, err)
 	assert.EqualValues(t, m1, m)
 }

gitea/issue_reaction.go

@@ -19,21 +19,23 @@ type Reaction struct {
 }
 
 // GetIssueReactions get a list reactions of an issue
-func (c *Client) GetIssueReactions(owner, repo string, index int64) ([]*Reaction, error) {
+func (c *Client) GetIssueReactions(owner, repo string, index int64) ([]*Reaction, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	reactions := make([]*Reaction, 0, 10)
-	return reactions, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/reactions", owner, repo, index), nil, nil, &reactions)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/reactions", owner, repo, index), nil, nil, &reactions)
+	return reactions, resp, err
 }
 
 // GetIssueCommentReactions get a list of reactions from a comment of an issue
-func (c *Client) GetIssueCommentReactions(owner, repo string, commentID int64) ([]*Reaction, error) {
+func (c *Client) GetIssueCommentReactions(owner, repo string, commentID int64) ([]*Reaction, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	reactions := make([]*Reaction, 0, 10)
-	return reactions, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/comments/%d/reactions", owner, repo, commentID), nil, nil, &reactions)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/comments/%d/reactions", owner, repo, commentID), nil, nil, &reactions)
+	return reactions, resp, err
 }
 
 // editReactionOption contain the reaction type
@@ -42,57 +44,61 @@ type editReactionOption struct {
 }
 
 // PostIssueReaction add a reaction to an issue
-func (c *Client) PostIssueReaction(owner, repo string, index int64, reaction string) (*Reaction, error) {
+func (c *Client) PostIssueReaction(owner, repo string, index int64, reaction string) (*Reaction, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	reactionResponse := new(Reaction)
 	body, err := json.Marshal(&editReactionOption{Reaction: reaction})
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
-	return reactionResponse, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/reactions", owner, repo, index),
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/reactions", owner, repo, index),
 		jsonHeader, bytes.NewReader(body), reactionResponse)
+	return reactionResponse, resp, err
 }
 
 // DeleteIssueReaction remove a reaction from an issue
-func (c *Client) DeleteIssueReaction(owner, repo string, index int64, reaction string) error {
+func (c *Client) DeleteIssueReaction(owner, repo string, index int64, reaction string) (*Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return err
+		return nil, err
 	}
 	body, err := json.Marshal(&editReactionOption{Reaction: reaction})
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/reactions", owner, repo, index), jsonHeader, bytes.NewReader(body))
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/reactions", owner, repo, index), jsonHeader, bytes.NewReader(body))
-	return err
+	return resp, err
 }
 
 // PostIssueCommentReaction add a reaction to a comment of an issue
-func (c *Client) PostIssueCommentReaction(owner, repo string, commentID int64, reaction string) (*Reaction, error) {
+func (c *Client) PostIssueCommentReaction(owner, repo string, commentID int64, reaction string) (*Reaction, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	reactionResponse := new(Reaction)
 	body, err := json.Marshal(&editReactionOption{Reaction: reaction})
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
-	return reactionResponse, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/comments/%d/reactions", owner, repo, commentID),
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/issues/comments/%d/reactions", owner, repo, commentID),
 		jsonHeader, bytes.NewReader(body), reactionResponse)
+	return reactionResponse, resp, err
 }
 
 // DeleteIssueCommentReaction remove a reaction from a comment of an issue
-func (c *Client) DeleteIssueCommentReaction(owner, repo string, commentID int64, reaction string) error {
+func (c *Client) DeleteIssueCommentReaction(owner, repo string, commentID int64, reaction string) (*Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return err
+		return nil, err
 	}
-	// swagger:operation DELETE /repos/{owner}/{repo}/issues/comments/{id}/reactions issue issueDeleteCommentReaction
 	body, err := json.Marshal(&editReactionOption{Reaction: reaction})
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/comments/%d/reactions", owner, repo, commentID),
+	_, resp, err := c.getResponse("DELETE",
+		fmt.Sprintf("/repos/%s/%s/issues/comments/%d/reactions", owner, repo, commentID),
 		jsonHeader, bytes.NewReader(body))
-	return err
+	return resp, err
 }

gitea/issue_stopwatch.go

@@ -16,27 +16,28 @@ type StopWatch struct {
 }
 
 // GetMyStopwatches list all stopwatches
-func (c *Client) GetMyStopwatches() ([]*StopWatch, error) {
+func (c *Client) GetMyStopwatches() ([]*StopWatch, *Response, error) {
 	stopwatches := make([]*StopWatch, 0, 1)
-	return stopwatches, c.getParsedResponse("GET", "/user/stopwatches", nil, nil, &stopwatches)
+	resp, err := c.getParsedResponse("GET", "/user/stopwatches", nil, nil, &stopwatches)
+	return stopwatches, resp, err
 }
 
 // DeleteIssueStopwatch delete / cancel a specific stopwatch
-func (c *Client) DeleteIssueStopwatch(owner, repo string, index int64) error {
+func (c *Client) DeleteIssueStopwatch(owner, repo string, index int64) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/delete", owner, repo, index), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/delete", owner, repo, index), nil, nil)
-	return err
+	return resp, err
 }
 
 // StartIssueStopWatch starts a stopwatch for an existing issue for a given
 // repository
-func (c *Client) StartIssueStopWatch(owner, repo string, index int64) error {
+func (c *Client) StartIssueStopWatch(owner, repo string, index int64) (*Response, error) {
-	_, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/start", owner, repo, index), nil, nil)
+	_, resp, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/start", owner, repo, index), nil, nil)
-	return err
+	return resp, err
 }
 
 // StopIssueStopWatch stops an existing stopwatch for an issue in a given
 // repository
-func (c *Client) StopIssueStopWatch(owner, repo string, index int64) error {
+func (c *Client) StopIssueStopWatch(owner, repo string, index int64) (*Response, error) {
-	_, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/stop", owner, repo, index), nil, nil)
+	_, resp, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/stopwatch/stop", owner, repo, index), nil, nil)
-	return err
+	return resp, err
 }

gitea/issue_subscription.go

@@ -10,73 +10,75 @@ import (
 )
 
 // GetIssueSubscribers get list of users who subscribed on an issue
-func (c *Client) GetIssueSubscribers(owner, repo string, index int64) ([]*User, error) {
+func (c *Client) GetIssueSubscribers(owner, repo string, index int64) ([]*User, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	subscribers := make([]*User, 0, 10)
-	return subscribers, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions", owner, repo, index), nil, nil, &subscribers)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions", owner, repo, index), nil, nil, &subscribers)
+	return subscribers, resp, err
 }
 
 // AddIssueSubscription Subscribe user to issue
-func (c *Client) AddIssueSubscription(owner, repo string, index int64, user string) error {
+func (c *Client) AddIssueSubscription(owner, repo string, index int64, user string) (*Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return err
+		return nil, err
 	}
-	status, err := c.getStatusCode("PUT", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/%s", owner, repo, index, user), nil, nil)
+	status, resp, err := c.getStatusCode("PUT", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/%s", owner, repo, index, user), nil, nil)
 	if err != nil {
-		return err
+		return resp, err
 	}
 	if status == http.StatusCreated {
-		return nil
+		return resp, nil
 	}
 	if status == http.StatusOK {
-		return fmt.Errorf("already subscribed")
+		return resp, fmt.Errorf("already subscribed")
 	}
-	return fmt.Errorf("unexpected Status: %d", status)
+	return resp, fmt.Errorf("unexpected Status: %d", status)
 }
 
 // DeleteIssueSubscription unsubscribe user from issue
-func (c *Client) DeleteIssueSubscription(owner, repo string, index int64, user string) error {
+func (c *Client) DeleteIssueSubscription(owner, repo string, index int64, user string) (*Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return err
+		return nil, err
 	}
-	status, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/%s", owner, repo, index, user), nil, nil)
+	status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/%s", owner, repo, index, user), nil, nil)
 	if err != nil {
-		return err
+		return resp, err
 	}
 	if status == http.StatusCreated {
-		return nil
+		return resp, nil
 	}
 	if status == http.StatusOK {
-		return fmt.Errorf("already unsubscribed")
+		return resp, fmt.Errorf("already unsubscribed")
 	}
-	return fmt.Errorf("unexpected Status: %d", status)
+	return resp, fmt.Errorf("unexpected Status: %d", status)
 }
 
 // CheckIssueSubscription check if current user is subscribed to an issue
-func (c *Client) CheckIssueSubscription(owner, repo string, index int64) (*WatchInfo, error) {
+func (c *Client) CheckIssueSubscription(owner, repo string, index int64) (*WatchInfo, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	wi := new(WatchInfo)
-	return wi, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/check", owner, repo, index), nil, nil, wi)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/subscriptions/check", owner, repo, index), nil, nil, wi)
+	return wi, resp, err
 }
 
 // IssueSubscribe subscribe current user to an issue
-func (c *Client) IssueSubscribe(owner, repo string, index int64) error {
+func (c *Client) IssueSubscribe(owner, repo string, index int64) (*Response, error) {
-	u, err := c.GetMyUserInfo()
+	u, _, err := c.GetMyUserInfo()
 	if err != nil {
-		return err
+		return nil, err
 	}
 	return c.AddIssueSubscription(owner, repo, index, u.UserName)
 }
 
 // IssueUnSubscribe unsubscribe current user from an issue
-func (c *Client) IssueUnSubscribe(owner, repo string, index int64) error {
+func (c *Client) IssueUnSubscribe(owner, repo string, index int64) (*Response, error) {
-	u, err := c.GetMyUserInfo()
+	u, _, err := c.GetMyUserInfo()
 	if err != nil {
-		return err
+		return nil, err
 	}
 	return c.DeleteIssueSubscription(owner, repo, index, u.UserName)
 }

gitea/issue_subscription_test.go

@@ -20,30 +20,33 @@ func TestIssueSubscription(t *testing.T) {
 	repo, _ := createTestRepo(t, "IssueWatch", c)
 	createTestIssue(t, c, repo.Name, "First Issue", "", nil, nil, 0, nil, false, false)
 
-	wi, err := c.CheckIssueSubscription(repo.Owner.UserName, repo.Name, 1)
+	wi, _, err := c.CheckIssueSubscription(repo.Owner.UserName, repo.Name, 1)
 	assert.NoError(t, err)
 	assert.True(t, wi.Subscribed)
 
-	assert.NoError(t, c.UnWatchRepo(repo.Owner.UserName, repo.Name))
+	_, err = c.UnWatchRepo(repo.Owner.UserName, repo.Name)
-	wi, err = c.CheckIssueSubscription(repo.Owner.UserName, repo.Name, 1)
+	assert.NoError(t, err)
+	wi, _, err = c.CheckIssueSubscription(repo.Owner.UserName, repo.Name, 1)
 	assert.NoError(t, err)
 	assert.True(t, wi.Subscribed)
 
-	err = c.IssueSubscribe(repo.Owner.UserName, repo.Name, 1)
+	_, err = c.IssueSubscribe(repo.Owner.UserName, repo.Name, 1)
 	if assert.Error(t, err) {
 		assert.EqualValues(t, "already subscribed", err.Error())
 	}
-	wi, err = c.CheckIssueSubscription(repo.Owner.UserName, repo.Name, 1)
+	wi, _, err = c.CheckIssueSubscription(repo.Owner.UserName, repo.Name, 1)
 	assert.NoError(t, err)
 	assert.True(t, wi.Subscribed)
 
-	assert.NoError(t, c.IssueUnSubscribe(repo.Owner.UserName, repo.Name, 1))
+	_, err = c.IssueUnSubscribe(repo.Owner.UserName, repo.Name, 1)
-	wi, err = c.CheckIssueSubscription(repo.Owner.UserName, repo.Name, 1)
+	assert.NoError(t, err)
+	wi, _, err = c.CheckIssueSubscription(repo.Owner.UserName, repo.Name, 1)
 	assert.NoError(t, err)
 	assert.False(t, wi.Subscribed)
 
-	assert.NoError(t, c.WatchRepo(repo.Owner.UserName, repo.Name))
+	_, err = c.WatchRepo(repo.Owner.UserName, repo.Name)
-	wi, err = c.CheckIssueSubscription(repo.Owner.UserName, repo.Name, 1)
+	assert.NoError(t, err)
+	wi, _, err = c.CheckIssueSubscription(repo.Owner.UserName, repo.Name, 1)
 	assert.NoError(t, err)
 	assert.False(t, wi.Subscribed)
 }

gitea/issue_test.go

@@ -27,14 +27,14 @@ func TestIssue(t *testing.T) {
 func createIssue(t *testing.T, c *Client) {
 	log.Println("== TestCreateIssues ==")
 
-	user, err := c.GetMyUserInfo()
+	user, _, err := c.GetMyUserInfo()
 	assert.NoError(t, err)
 	repo, _ := createTestRepo(t, "IssueTestsRepo", c)
 
 	nowTime := time.Now()
-	mile, _ := c.CreateMilestone(user.UserName, repo.Name, CreateMilestoneOption{Title: "mile1"})
+	mile, _, _ := c.CreateMilestone(user.UserName, repo.Name, CreateMilestoneOption{Title: "mile1"})
-	label1, _ := c.CreateLabel(user.UserName, repo.Name, CreateLabelOption{Name: "Label1", Description: "a", Color: "#ee0701"})
+	label1, _, _ := c.CreateLabel(user.UserName, repo.Name, CreateLabelOption{Name: "Label1", Description: "a", Color: "#ee0701"})
-	label2, _ := c.CreateLabel(user.UserName, repo.Name, CreateLabelOption{Name: "Label2", Description: "b", Color: "#128a0c"})
+	label2, _, _ := c.CreateLabel(user.UserName, repo.Name, CreateLabelOption{Name: "Label2", Description: "b", Color: "#128a0c"})
 
 	createTestIssue(t, c, repo.Name, "First Issue", "", nil, nil, 0, nil, false, false)
 	createTestIssue(t, c, repo.Name, "Issue 2", "closed isn't it?", nil, nil, 0, nil, true, false)
@@ -49,14 +49,14 @@ func createIssue(t *testing.T, c *Client) {
 
 func editIssues(t *testing.T, c *Client) {
 	log.Println("== TestEditIssues ==")
-	il, err := c.ListIssues(ListIssueOption{KeyWord: "soon"})
+	il, _, err := c.ListIssues(ListIssueOption{KeyWord: "soon"})
 	assert.NoError(t, err)
-	issue, err := c.GetIssue(il[0].Poster.UserName, il[0].Repository.Name, il[0].Index)
+	issue, _, err := c.GetIssue(il[0].Poster.UserName, il[0].Repository.Name, il[0].Index)
 	assert.NoError(t, err)
 
 	body := "123 test and go"
 	state := StateClosed
-	issueNew, err := c.EditIssue(issue.Poster.UserName, issue.Repository.Name, issue.Index, EditIssueOption{
+	issueNew, _, err := c.EditIssue(issue.Poster.UserName, issue.Repository.Name, issue.Index, EditIssueOption{
 		Title: "Edited",
 		Body:  &body,
 		State: &state,
@@ -70,7 +70,7 @@ func editIssues(t *testing.T, c *Client) {
 func listIssues(t *testing.T, c *Client) {
 	log.Println("== TestListIssues ==")
 
-	issues, err := c.ListRepoIssues("test01", "IssueTestsRepo", ListIssueOption{
+	issues, _, err := c.ListRepoIssues("test01", "IssueTestsRepo", ListIssueOption{
 		Labels:  []string{"Label1", "Label2"},
 		KeyWord: "",
 		State:   "all",
@@ -78,7 +78,7 @@ func listIssues(t *testing.T, c *Client) {
 	assert.NoError(t, err)
 	assert.Len(t, issues, 1)
 
-	issues, err = c.ListIssues(ListIssueOption{
+	issues, _, err = c.ListIssues(ListIssueOption{
 		Labels:  []string{"Label2"},
 		KeyWord: "Done",
 		State:   "all",
@@ -86,7 +86,7 @@ func listIssues(t *testing.T, c *Client) {
 	assert.NoError(t, err)
 	assert.Len(t, issues, 1)
 
-	issues, err = c.ListRepoIssues("test01", "IssueTestsRepo", ListIssueOption{
+	issues, _, err = c.ListRepoIssues("test01", "IssueTestsRepo", ListIssueOption{
 		Milestones: []string{"mile1"},
 		State:      "all",
 	})
@@ -98,15 +98,15 @@ func listIssues(t *testing.T, c *Client) {
 		}
 	}
 
-	issues, err = c.ListRepoIssues("test01", "IssueTestsRepo", ListIssueOption{})
+	issues, _, err = c.ListRepoIssues("test01", "IssueTestsRepo", ListIssueOption{})
 	assert.NoError(t, err)
 	assert.Len(t, issues, 3)
 }
 
 func createTestIssue(t *testing.T, c *Client, repoName, title, body string, assignees []string, deadline *time.Time, milestone int64, labels []int64, closed, shouldFail bool) {
-	user, err := c.GetMyUserInfo()
+	user, _, err := c.GetMyUserInfo()
 	assert.NoError(t, err)
-	issue, e := c.CreateIssue(user.UserName, repoName, CreateIssueOption{
+	issue, _, e := c.CreateIssue(user.UserName, repoName, CreateIssueOption{
 		Title:     title,
 		Body:      body,
 		Assignees: assignees,

gitea/issue_tracked_time.go

@@ -26,30 +26,33 @@ type TrackedTime struct {
 }
 
 // GetUserTrackedTimes list tracked times of a user
-func (c *Client) GetUserTrackedTimes(owner, repo, user string) ([]*TrackedTime, error) {
+func (c *Client) GetUserTrackedTimes(owner, repo, user string) ([]*TrackedTime, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	times := make([]*TrackedTime, 0, 10)
-	return times, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/times/%s", owner, repo, user), nil, nil, &times)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/times/%s", owner, repo, user), nil, nil, &times)
+	return times, resp, err
 }
 
 // GetRepoTrackedTimes list tracked times of a repository
-func (c *Client) GetRepoTrackedTimes(owner, repo string) ([]*TrackedTime, error) {
+func (c *Client) GetRepoTrackedTimes(owner, repo string) ([]*TrackedTime, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	times := make([]*TrackedTime, 0, 10)
-	return times, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/times", owner, repo), nil, nil, &times)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/times", owner, repo), nil, nil, &times)
+	return times, resp, err
 }
 
 // GetMyTrackedTimes list tracked times of the current user
-func (c *Client) GetMyTrackedTimes() ([]*TrackedTime, error) {
+func (c *Client) GetMyTrackedTimes() ([]*TrackedTime, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	times := make([]*TrackedTime, 0, 10)
-	return times, c.getParsedResponse("GET", "/user/times", nil, nil, &times)
+	resp, err := c.getParsedResponse("GET", "/user/times", nil, nil, &times)
+	return times, resp, err
 }
 
 // AddTimeOption options for adding time to an issue
@@ -71,20 +74,22 @@ func (opt AddTimeOption) Validate() error {
 }
 
 // AddTime adds time to issue with the given index
-func (c *Client) AddTime(owner, repo string, index int64, opt AddTimeOption) (*TrackedTime, error) {
+func (c *Client) AddTime(owner, repo string, index int64, opt AddTimeOption) (*TrackedTime, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	t := new(TrackedTime)
-	return t, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index),
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index),
 		jsonHeader, bytes.NewReader(body), t)
+	return t, resp, err
 }
 
 // ListTrackedTimesOptions options for listing repository's tracked times
@@ -93,29 +98,30 @@ type ListTrackedTimesOptions struct {
 }
 
 // ListTrackedTimes list tracked times of a single issue for a given repository
-func (c *Client) ListTrackedTimes(owner, repo string, index int64, opt ListTrackedTimesOptions) ([]*TrackedTime, error) {
+func (c *Client) ListTrackedTimes(owner, repo string, index int64, opt ListTrackedTimesOptions) ([]*TrackedTime, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	opt.setDefaults()
 	times := make([]*TrackedTime, 0, opt.PageSize)
-	return times, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/times?%s", owner, repo, index, opt.getURLQuery().Encode()), nil, nil, &times)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/issues/%d/times?%s", owner, repo, index, opt.getURLQuery().Encode()), nil, nil, &times)
+	return times, resp, err
 }
 
 // ResetIssueTime reset tracked time of a single issue for a given repository
-func (c *Client) ResetIssueTime(owner, repo string, index int64) error {
+func (c *Client) ResetIssueTime(owner, repo string, index int64) (*Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return err
+		return nil, err
 	}
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/times", owner, repo, index), nil, nil)
-	return err
+	return resp, err
 }
 
 // DeleteTime delete a specific tracked time by id of a single issue for a given repository
-func (c *Client) DeleteTime(owner, repo string, index, timeID int64) error {
+func (c *Client) DeleteTime(owner, repo string, index, timeID int64) (*Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.11.0"); err != nil {
-		return err
+		return nil, err
 	}
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/times/%d", owner, repo, index, timeID), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/issues/%d/times/%d", owner, repo, index, timeID), nil, nil)
-	return err
+	return resp, err
 }

gitea/notifications.go

@@ -103,92 +103,96 @@ func (opt MarkNotificationOptions) Validate(c *Client) error {
 }
 
 // CheckNotifications list users's notification threads
-func (c *Client) CheckNotifications() (int64, error) {
+func (c *Client) CheckNotifications() (int64, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return 0, err
+		return 0, nil, err
 	}
 	new := struct {
 		New int64 `json:"new"`
 	}{}
 
-	return new.New, c.getParsedResponse("GET", "/notifications/new", jsonHeader, nil, &new)
+	resp, err := c.getParsedResponse("GET", "/notifications/new", jsonHeader, nil, &new)
+	return new.New, resp, err
 }
 
 // GetNotification get notification thread by ID
-func (c *Client) GetNotification(id int64) (*NotificationThread, error) {
+func (c *Client) GetNotification(id int64) (*NotificationThread, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	thread := new(NotificationThread)
-	return thread, c.getParsedResponse("GET", fmt.Sprintf("/notifications/threads/%d", id), nil, nil, thread)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/notifications/threads/%d", id), nil, nil, thread)
+	return thread, resp, err
 }
 
 // ReadNotification mark notification thread as read by ID
 // It optionally takes a second argument if status has to be set other than 'read'
-func (c *Client) ReadNotification(id int64, status ...NotifyStatus) error {
+func (c *Client) ReadNotification(id int64, status ...NotifyStatus) (*Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return err
+		return nil, err
 	}
 	link := fmt.Sprintf("/notifications/threads/%d", id)
 	if len(status) != 0 {
 		link += fmt.Sprintf("?to-status=%s", status[0])
 	}
-	_, err := c.getResponse("PATCH", link, nil, nil)
+	_, resp, err := c.getResponse("PATCH", link, nil, nil)
-	return err
+	return resp, err
 }
 
 // ListNotifications list users's notification threads
-func (c *Client) ListNotifications(opt ListNotificationOptions) ([]*NotificationThread, error) {
+func (c *Client) ListNotifications(opt ListNotificationOptions) ([]*NotificationThread, *Response, error) {
-	if err := opt.Validate(c); err != nil {
-		return nil, err
-	}
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, nil, err
 	}
 	link, _ := url.Parse("/notifications")
 	link.RawQuery = opt.QueryEncode()
 	threads := make([]*NotificationThread, 0, 10)
-	return threads, c.getParsedResponse("GET", link.String(), nil, nil, &threads)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &threads)
+	return threads, resp, err
 }
 
 // ReadNotifications mark notification threads as read
-func (c *Client) ReadNotifications(opt MarkNotificationOptions) error {
+func (c *Client) ReadNotifications(opt MarkNotificationOptions) (*Response, error) {
-	if err := opt.Validate(c); err != nil {
-		return err
-	}
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return err
+		return nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, err
 	}
 	link, _ := url.Parse("/notifications")
 	link.RawQuery = opt.QueryEncode()
-	_, err := c.getResponse("PUT", link.String(), nil, nil)
+	_, resp, err := c.getResponse("PUT", link.String(), nil, nil)
-	return err
+	return resp, err
 }
 
 // ListRepoNotifications list users's notification threads on a specific repo
-func (c *Client) ListRepoNotifications(owner, reponame string, opt ListNotificationOptions) ([]*NotificationThread, error) {
+func (c *Client) ListRepoNotifications(owner, reponame string, opt ListNotificationOptions) ([]*NotificationThread, *Response, error) {
-	if err := opt.Validate(c); err != nil {
-		return nil, err
-	}
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, nil, err
 	}
 	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/notifications", owner, reponame))
 	link.RawQuery = opt.QueryEncode()
 	threads := make([]*NotificationThread, 0, 10)
-	return threads, c.getParsedResponse("GET", link.String(), nil, nil, &threads)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &threads)
+	return threads, resp, err
 }
 
 // ReadRepoNotifications mark notification threads as read on a specific repo
-func (c *Client) ReadRepoNotifications(owner, reponame string, opt MarkNotificationOptions) error {
+func (c *Client) ReadRepoNotifications(owner, reponame string, opt MarkNotificationOptions) (*Response, error) {
-	if err := opt.Validate(c); err != nil {
-		return err
-	}
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return err
+		return nil, err
+	}
+	if err := opt.Validate(c); err != nil {
+		return nil, err
 	}
 	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/notifications", owner, reponame))
 	link.RawQuery = opt.QueryEncode()
-	_, err := c.getResponse("PUT", link.String(), nil, nil)
+	_, resp, err := c.getResponse("PUT", link.String(), nil, nil)
-	return err
+	return resp, err
 }

gitea/notifications_test.go

@@ -19,7 +19,7 @@ func TestNotifications(t *testing.T) {
 	// init user2
 	c := newTestClient()
 
-	user1, err := c.GetMyUserInfo()
+	user1, _, err := c.GetMyUserInfo()
 	assert.NoError(t, err)
 	user2 := createTestUser(t, "notify2", c)
 
@@ -30,30 +30,31 @@ func TestNotifications(t *testing.T) {
 	c.sudo = user2.UserName
 	repoB, err := createTestRepo(t, "TestNotifications_B", c)
 	assert.NoError(t, err)
-	err = c.WatchRepo(user1.UserName, repoA.Name)
+	_, err = c.WatchRepo(user1.UserName, repoA.Name)
 	c.sudo = ""
 	assert.NoError(t, err)
 
 	c.sudo = user2.UserName
-	assert.NoError(t, c.ReadNotifications(MarkNotificationOptions{}))
+	_, err = c.ReadNotifications(MarkNotificationOptions{})
-	count, err := c.CheckNotifications()
+	assert.NoError(t, err)
+	count, _, err := c.CheckNotifications()
 	assert.EqualValues(t, 0, count)
 	assert.NoError(t, err)
 	c.sudo = ""
-	_, err = c.CreateIssue(repoA.Owner.UserName, repoA.Name, CreateIssueOption{Title: "A Issue", Closed: false})
+	_, _, err = c.CreateIssue(repoA.Owner.UserName, repoA.Name, CreateIssueOption{Title: "A Issue", Closed: false})
 	assert.NoError(t, err)
-	issue, err := c.CreateIssue(repoB.Owner.UserName, repoB.Name, CreateIssueOption{Title: "B Issue", Closed: false})
+	issue, _, err := c.CreateIssue(repoB.Owner.UserName, repoB.Name, CreateIssueOption{Title: "B Issue", Closed: false})
 	assert.NoError(t, err)
 	time.Sleep(time.Second * 1)
 
 	// CheckNotifications of user2
 	c.sudo = user2.UserName
-	count, err = c.CheckNotifications()
+	count, _, err = c.CheckNotifications()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 2, count)
 
 	// ListNotifications
-	nList, err := c.ListNotifications(ListNotificationOptions{})
+	nList, _, err := c.ListNotifications(ListNotificationOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, nList, 2)
 	for _, n := range nList {
@@ -69,55 +70,58 @@ func TestNotifications(t *testing.T) {
 	}
 
 	// ListRepoNotifications
-	nList, err = c.ListRepoNotifications(repoA.Owner.UserName, repoA.Name, ListNotificationOptions{})
+	nList, _, err = c.ListRepoNotifications(repoA.Owner.UserName, repoA.Name, ListNotificationOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, nList, 1)
 	assert.EqualValues(t, "A Issue", nList[0].Subject.Title)
 	// ReadRepoNotifications
-	err = c.ReadRepoNotifications(repoA.Owner.UserName, repoA.Name, MarkNotificationOptions{})
+	_, err = c.ReadRepoNotifications(repoA.Owner.UserName, repoA.Name, MarkNotificationOptions{})
 	assert.NoError(t, err)
 
 	// GetThread
-	n, err := c.GetNotification(nList[0].ID)
+	n, _, err := c.GetNotification(nList[0].ID)
 	assert.NoError(t, err)
 	assert.EqualValues(t, false, n.Unread)
 	assert.EqualValues(t, "A Issue", n.Subject.Title)
 
 	// ReadNotifications
-	err = c.ReadNotifications(MarkNotificationOptions{})
+	_, err = c.ReadNotifications(MarkNotificationOptions{})
 	assert.NoError(t, err)
-	nList, err = c.ListNotifications(ListNotificationOptions{})
+	nList, _, err = c.ListNotifications(ListNotificationOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, nList, 0)
 
 	// ReadThread
 	iState := StateClosed
 	c.sudo = ""
-	_, err = c.EditIssue(repoB.Owner.UserName, repoB.Name, issue.Index, EditIssueOption{State: &iState})
+	_, _, err = c.EditIssue(repoB.Owner.UserName, repoB.Name, issue.Index, EditIssueOption{State: &iState})
 	assert.NoError(t, err)
 	time.Sleep(time.Second * 1)
 
 	c.sudo = user2.UserName
-	nList, err = c.ListNotifications(ListNotificationOptions{})
+	nList, _, err = c.ListNotifications(ListNotificationOptions{})
 	assert.NoError(t, err)
-	count, err = c.CheckNotifications()
+	count, _, err = c.CheckNotifications()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, count)
 	assert.Len(t, nList, 1)
 	if len(nList) > 0 {
-		assert.NoError(t, c.ReadNotification(nList[0].ID))
+		_, err = c.ReadNotification(nList[0].ID)
+		assert.NoError(t, err)
 	}
 
 	c.sudo = ""
-	err = c.ReadNotifications(MarkNotificationOptions{})
+	_, err = c.ReadNotifications(MarkNotificationOptions{})
 	assert.NoError(t, err)
-	nList, err = c.ListNotifications(ListNotificationOptions{Status: []NotifyStatus{NotifyStatusRead}})
+	nList, _, err = c.ListNotifications(ListNotificationOptions{Status: []NotifyStatus{NotifyStatusRead}})
 	assert.NoError(t, err)
 	assert.Len(t, nList, 4)
 
-	assert.NoError(t, c.ReadNotification(nList[2].ID, NotifyStatusPinned))
+	_, err = c.ReadNotification(nList[2].ID, NotifyStatusPinned)
-	assert.NoError(t, c.ReadNotification(nList[3].ID, NotifyStatusUnread))
+	assert.NoError(t, err)
-	nList, err = c.ListNotifications(ListNotificationOptions{Status: []NotifyStatus{NotifyStatusPinned, NotifyStatusUnread}})
+	_, err = c.ReadNotification(nList[3].ID, NotifyStatusUnread)
+	assert.NoError(t, err)
+	nList, _, err = c.ListNotifications(ListNotificationOptions{Status: []NotifyStatus{NotifyStatusPinned, NotifyStatusUnread}})
 	assert.NoError(t, err)
 	assert.Len(t, nList, 2)
 }

gitea/oauth2.go

@@ -33,55 +33,59 @@ type CreateOauth2Option struct {
 }
 
 // CreateOauth2 create an Oauth2 Application and returns a completed Oauth2 object.
-func (c *Client) CreateOauth2(opt CreateOauth2Option) (*Oauth2, error) {
+func (c *Client) CreateOauth2(opt CreateOauth2Option) (*Oauth2, *Response, error) {
-	if e := c.CheckServerVersionConstraint(">=1.12.0"); e != nil {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, e
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	oauth := new(Oauth2)
-	return oauth, c.getParsedResponse("POST", "/user/applications/oauth2", jsonHeader, bytes.NewReader(body), oauth)
+	resp, err := c.getParsedResponse("POST", "/user/applications/oauth2", jsonHeader, bytes.NewReader(body), oauth)
+	return oauth, resp, err
 }
 
 // UpdateOauth2 a specific Oauth2 Application by ID and return a completed Oauth2 object.
-func (c *Client) UpdateOauth2(oauth2id int64, opt CreateOauth2Option) (*Oauth2, error) {
+func (c *Client) UpdateOauth2(oauth2id int64, opt CreateOauth2Option) (*Oauth2, *Response, error) {
-	if e := c.CheckServerVersionConstraint(">=1.12.0"); e != nil {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, e
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	oauth := new(Oauth2)
-	return oauth, c.getParsedResponse("PATCH", fmt.Sprintf("/user/applications/oauth2/%d", oauth2id), jsonHeader, bytes.NewReader(body), oauth)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/user/applications/oauth2/%d", oauth2id), jsonHeader, bytes.NewReader(body), oauth)
+	return oauth, resp, err
 }
 
 // GetOauth2 a specific Oauth2 Application by ID.
-func (c *Client) GetOauth2(oauth2id int64) (*Oauth2, error) {
+func (c *Client) GetOauth2(oauth2id int64) (*Oauth2, *Response, error) {
-	if e := c.CheckServerVersionConstraint(">=1.12.0"); e != nil {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, e
+		return nil, nil, err
 	}
 	oauth2s := &Oauth2{}
-	return oauth2s, c.getParsedResponse("GET", fmt.Sprintf("/user/applications/oauth2/%d", oauth2id), nil, nil, &oauth2s)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/applications/oauth2/%d", oauth2id), nil, nil, &oauth2s)
+	return oauth2s, resp, err
 }
 
 // ListOauth2 all of your Oauth2 Applications.
-func (c *Client) ListOauth2(opt ListOauth2Option) ([]*Oauth2, error) {
+func (c *Client) ListOauth2(opt ListOauth2Option) ([]*Oauth2, *Response, error) {
-	if e := c.CheckServerVersionConstraint(">=1.12.0"); e != nil {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, e
+		return nil, nil, err
 	}
 	opt.setDefaults()
 	oauth2s := make([]*Oauth2, 0, opt.PageSize)
-	return oauth2s, c.getParsedResponse("GET", fmt.Sprintf("/user/applications/oauth2?%s", opt.getURLQuery().Encode()), nil, nil, &oauth2s)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/applications/oauth2?%s", opt.getURLQuery().Encode()), nil, nil, &oauth2s)
+	return oauth2s, resp, err
 }
 
 // DeleteOauth2 delete an Oauth2 application by ID
-func (c *Client) DeleteOauth2(oauth2id int64) error {
+func (c *Client) DeleteOauth2(oauth2id int64) (*Response, error) {
-	if e := c.CheckServerVersionConstraint(">=1.12.0"); e != nil {
+	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return e
+		return nil, err
 	}
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/user/applications/oauth2/%d", oauth2id), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/user/applications/oauth2/%d", oauth2id), nil, nil)
-	return err
+	return resp, err
 }

gitea/oauth2_test.go

@@ -18,26 +18,27 @@ func TestOauth2(t *testing.T) {
 	user := createTestUser(t, "oauth2_user", c)
 	c.SetSudo(user.UserName)
 
-	newApp, err := c.CreateOauth2(CreateOauth2Option{Name: "test", RedirectURIs: []string{"http://test/test"}})
+	newApp, _, err := c.CreateOauth2(CreateOauth2Option{Name: "test", RedirectURIs: []string{"http://test/test"}})
 	assert.NoError(t, err)
 	assert.NotNil(t, newApp)
 	assert.EqualValues(t, "test", newApp.Name)
 
-	a, err := c.ListOauth2(ListOauth2Option{})
+	a, _, err := c.ListOauth2(ListOauth2Option{})
 	assert.NoError(t, err)
 	assert.Len(t, a, 1)
 	assert.EqualValues(t, newApp.Name, a[0].Name)
 
-	b, err := c.GetOauth2(newApp.ID)
+	b, _, err := c.GetOauth2(newApp.ID)
 	assert.NoError(t, err)
 	assert.EqualValues(t, newApp.Name, b.Name)
 
-	b, err = c.UpdateOauth2(newApp.ID, CreateOauth2Option{Name: newApp.Name, RedirectURIs: []string{"https://test/login"}})
+	b, _, err = c.UpdateOauth2(newApp.ID, CreateOauth2Option{Name: newApp.Name, RedirectURIs: []string{"https://test/login"}})
 	assert.NoError(t, err)
 	assert.EqualValues(t, newApp.Name, b.Name)
 	assert.EqualValues(t, "https://test/login", b.RedirectURIs[0])
 	assert.EqualValues(t, newApp.ID, b.ID)
 	assert.NotEqual(t, newApp.ClientSecret, b.ClientSecret)
 
-	assert.NoError(t, c.DeleteOauth2(newApp.ID))
+	_, err = c.DeleteOauth2(newApp.ID)
+	assert.NoError(t, err)
 }

gitea/org.go

@@ -43,23 +43,26 @@ type ListOrgsOptions struct {
 }
 
 // ListMyOrgs list all of current user's organizations
-func (c *Client) ListMyOrgs(opt ListOrgsOptions) ([]*Organization, error) {
+func (c *Client) ListMyOrgs(opt ListOrgsOptions) ([]*Organization, *Response, error) {
 	opt.setDefaults()
 	orgs := make([]*Organization, 0, opt.PageSize)
-	return orgs, c.getParsedResponse("GET", fmt.Sprintf("/user/orgs?%s", opt.getURLQuery().Encode()), nil, nil, &orgs)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/orgs?%s", opt.getURLQuery().Encode()), nil, nil, &orgs)
+	return orgs, resp, err
 }
 
 // ListUserOrgs list all of some user's organizations
-func (c *Client) ListUserOrgs(user string, opt ListOrgsOptions) ([]*Organization, error) {
+func (c *Client) ListUserOrgs(user string, opt ListOrgsOptions) ([]*Organization, *Response, error) {
 	opt.setDefaults()
 	orgs := make([]*Organization, 0, opt.PageSize)
-	return orgs, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/orgs?%s", user, opt.getURLQuery().Encode()), nil, nil, &orgs)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/orgs?%s", user, opt.getURLQuery().Encode()), nil, nil, &orgs)
+	return orgs, resp, err
 }
 
 // GetOrg get one organization by name
-func (c *Client) GetOrg(orgname string) (*Organization, error) {
+func (c *Client) GetOrg(orgname string) (*Organization, *Response, error) {
 	org := new(Organization)
-	return org, c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s", orgname), nil, nil, org)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s", orgname), nil, nil, org)
+	return org, resp, err
 }
 
 // CreateOrgOption options for creating an organization
@@ -89,16 +92,17 @@ func (opt CreateOrgOption) Validate() error {
 }
 
 // CreateOrg creates an organization
-func (c *Client) CreateOrg(opt CreateOrgOption) (*Organization, error) {
+func (c *Client) CreateOrg(opt CreateOrgOption) (*Organization, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	org := new(Organization)
-	return org, c.getParsedResponse("POST", "/orgs", jsonHeader, bytes.NewReader(body), org)
+	resp, err := c.getParsedResponse("POST", "/orgs", jsonHeader, bytes.NewReader(body), org)
+	return org, resp, err
 }
 
 // EditOrgOption options for editing an organization
@@ -119,20 +123,20 @@ func (opt EditOrgOption) Validate() error {
 }
 
 // EditOrg modify one organization via options
-func (c *Client) EditOrg(orgname string, opt EditOrgOption) error {
+func (c *Client) EditOrg(orgname string, opt EditOrgOption) (*Response, error) {
 	if err := opt.Validate(); err != nil {
-		return err
+		return nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("PATCH", fmt.Sprintf("/orgs/%s", orgname), jsonHeader, bytes.NewReader(body))
+	_, resp, err := c.getResponse("PATCH", fmt.Sprintf("/orgs/%s", orgname), jsonHeader, bytes.NewReader(body))
-	return err
+	return resp, err
 }
 
 // DeleteOrg deletes an organization
-func (c *Client) DeleteOrg(orgname string) error {
+func (c *Client) DeleteOrg(orgname string) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s", orgname), jsonHeader, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s", orgname), jsonHeader, nil)
-	return err
+	return resp, err
 }

gitea/org_member.go

@@ -11,9 +11,9 @@ import (
 )
 
 // DeleteOrgMembership remove a member from an organization
-func (c *Client) DeleteOrgMembership(org, user string) error {
+func (c *Client) DeleteOrgMembership(org, user string) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s/members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/orgs/%s/members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
-	return err
+	return resp, err
 }
 
 // ListOrgMembershipOption list OrgMembership options
@@ -22,77 +22,80 @@ type ListOrgMembershipOption struct {
 }
 
 // ListOrgMembership list an organization's members
-func (c *Client) ListOrgMembership(org string, opt ListOrgMembershipOption) ([]*User, error) {
+func (c *Client) ListOrgMembership(org string, opt ListOrgMembershipOption) ([]*User, *Response, error) {
 	opt.setDefaults()
 	users := make([]*User, 0, opt.PageSize)
 
 	link, _ := url.Parse(fmt.Sprintf("/orgs/%s/members", url.PathEscape(org)))
 	link.RawQuery = opt.getURLQuery().Encode()
-	return users, c.getParsedResponse("GET", link.String(), jsonHeader, nil, &users)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &users)
+	return users, resp, err
 }
 
 // ListPublicOrgMembership list an organization's members
-func (c *Client) ListPublicOrgMembership(org string, opt ListOrgMembershipOption) ([]*User, error) {
+func (c *Client) ListPublicOrgMembership(org string, opt ListOrgMembershipOption) ([]*User, *Response, error) {
 	opt.setDefaults()
 	users := make([]*User, 0, opt.PageSize)
 
 	link, _ := url.Parse(fmt.Sprintf("/orgs/%s/public_members", url.PathEscape(org)))
 	link.RawQuery = opt.getURLQuery().Encode()
-	return users, c.getParsedResponse("GET", link.String(), jsonHeader, nil, &users)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &users)
+	return users, resp, err
 }
 
 // CheckOrgMembership Check if a user is a member of an organization
-func (c *Client) CheckOrgMembership(org, user string) (bool, error) {
+func (c *Client) CheckOrgMembership(org, user string) (bool, *Response, error) {
-	status, err := c.getStatusCode("GET", fmt.Sprintf("/orgs/%s/members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/orgs/%s/members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
 	if err != nil {
-		return false, err
+		return false, resp, err
 	}
 	switch status {
 	case http.StatusNoContent:
-		return true, nil
+		return true, resp, nil
 	case http.StatusNotFound:
-		return false, nil
+		return false, resp, nil
 	default:
-		return false, fmt.Errorf("unexpected Status: %d", status)
+		return false, resp, fmt.Errorf("unexpected Status: %d", status)
 	}
 }
 
 // CheckPublicOrgMembership Check if a user is a member of an organization
-func (c *Client) CheckPublicOrgMembership(org, user string) (bool, error) {
+func (c *Client) CheckPublicOrgMembership(org, user string) (bool, *Response, error) {
-	status, err := c.getStatusCode("GET", fmt.Sprintf("/orgs/%s/public_members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/orgs/%s/public_members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
 	if err != nil {
-		return false, err
+		return false, resp, err
 	}
 	switch status {
 	case http.StatusNoContent:
-		return true, nil
+		return true, resp, nil
 	case http.StatusNotFound:
-		return false, nil
+		return false, resp, nil
 	default:
-		return false, fmt.Errorf("unexpected Status: %d", status)
+		return false, resp, fmt.Errorf("unexpected Status: %d", status)
 	}
 }
 
 // SetPublicOrgMembership publicize/conceal a user's membership
-func (c *Client) SetPublicOrgMembership(org, user string, visible bool) error {
+func (c *Client) SetPublicOrgMembership(org, user string, visible bool) (*Response, error) {
 	var (
 		status int
 		err    error
+		resp   *Response
 	)
 	if visible {
-		status, err = c.getStatusCode("PUT", fmt.Sprintf("/orgs/%s/public_members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+		status, resp, err = c.getStatusCode("PUT", fmt.Sprintf("/orgs/%s/public_members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
 	} else {
-		status, err = c.getStatusCode("DELETE", fmt.Sprintf("/orgs/%s/public_members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
+		status, resp, err = c.getStatusCode("DELETE", fmt.Sprintf("/orgs/%s/public_members/%s", url.PathEscape(org), url.PathEscape(user)), nil, nil)
 	}
 	if err != nil {
-		return err
+		return resp, err
 	}
 	switch status {
 	case http.StatusNoContent:
-		return nil
+		return resp, nil
 	case http.StatusNotFound:
-		return fmt.Errorf("forbidden")
+		return resp, fmt.Errorf("forbidden")
 	default:
-		return fmt.Errorf("unexpected Status: %d", status)
+		return resp, fmt.Errorf("unexpected Status: %d", status)
 	}
 }

gitea/org_member_test.go

@@ -23,37 +23,41 @@ func TestOrgMembership(t *testing.T) {
 
 	user := createTestUser(t, "org_mem_user", c)
 	c.SetSudo(user.UserName)
-	newOrg, err := c.CreateOrg(CreateOrgOption{Name: "MemberOrg"})
+	newOrg, _, err := c.CreateOrg(CreateOrgOption{Name: "MemberOrg"})
 	assert.NoError(t, err)
 	assert.NotNil(t, newOrg)
 
 	// Check func
-	check, err := c.CheckPublicOrgMembership(newOrg.UserName, user.UserName)
+	check, _, err := c.CheckPublicOrgMembership(newOrg.UserName, user.UserName)
 	assert.NoError(t, err)
 	assert.False(t, check)
-	check, err = c.CheckOrgMembership(newOrg.UserName, user.UserName)
+	check, _, err = c.CheckOrgMembership(newOrg.UserName, user.UserName)
 	assert.NoError(t, err)
 	assert.True(t, check)
 
-	err = c.SetPublicOrgMembership(newOrg.UserName, user.UserName, true)
+	_, err = c.SetPublicOrgMembership(newOrg.UserName, user.UserName, true)
 	assert.NoError(t, err)
-	check, err = c.CheckPublicOrgMembership(newOrg.UserName, user.UserName)
+	check, _, err = c.CheckPublicOrgMembership(newOrg.UserName, user.UserName)
 	assert.NoError(t, err)
 	assert.True(t, check)
 
-	u, err := c.ListOrgMembership(newOrg.UserName, ListOrgMembershipOption{})
+	u, _, err := c.ListOrgMembership(newOrg.UserName, ListOrgMembershipOption{})
 	assert.NoError(t, err)
 	assert.Len(t, u, 1)
 	assert.EqualValues(t, user.UserName, u[0].UserName)
-	u, err = c.ListPublicOrgMembership(newOrg.UserName, ListOrgMembershipOption{})
+	u, _, err = c.ListPublicOrgMembership(newOrg.UserName, ListOrgMembershipOption{})
 	assert.NoError(t, err)
 	assert.Len(t, u, 1)
 	assert.EqualValues(t, user.UserName, u[0].UserName)
 
-	assert.Error(t, c.DeleteOrgMembership(newOrg.UserName, user.UserName))
+	_, err = c.DeleteOrgMembership(newOrg.UserName, user.UserName)
+	assert.Error(t, err)
 
 	c.sudo = ""
-	assert.Error(t, c.AdminDeleteUser(user.UserName))
+	_, err = c.AdminDeleteUser(user.UserName)
-	assert.NoError(t, c.DeleteOrg(newOrg.UserName))
+	assert.Error(t, err)
-	assert.NoError(t, c.AdminDeleteUser(user.UserName))
+	_, err = c.DeleteOrg(newOrg.UserName)
+	assert.NoError(t, err)
+	_, err = c.AdminDeleteUser(user.UserName)
+	assert.NoError(t, err)
 }

gitea/org_team.go

@@ -29,23 +29,26 @@ type ListTeamsOptions struct {
 }
 
 // ListOrgTeams lists all teams of an organization
-func (c *Client) ListOrgTeams(org string, opt ListTeamsOptions) ([]*Team, error) {
+func (c *Client) ListOrgTeams(org string, opt ListTeamsOptions) ([]*Team, *Response, error) {
 	opt.setDefaults()
 	teams := make([]*Team, 0, opt.PageSize)
-	return teams, c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/teams?%s", org, opt.getURLQuery().Encode()), nil, nil, &teams)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/teams?%s", org, opt.getURLQuery().Encode()), nil, nil, &teams)
+	return teams, resp, err
 }
 
 // ListMyTeams lists all the teams of the current user
-func (c *Client) ListMyTeams(opt *ListTeamsOptions) ([]*Team, error) {
+func (c *Client) ListMyTeams(opt *ListTeamsOptions) ([]*Team, *Response, error) {
 	opt.setDefaults()
 	teams := make([]*Team, 0, opt.PageSize)
-	return teams, c.getParsedResponse("GET", fmt.Sprintf("/user/teams?%s", opt.getURLQuery().Encode()), nil, nil, &teams)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/teams?%s", opt.getURLQuery().Encode()), nil, nil, &teams)
+	return teams, resp, err
 }
 
 // GetTeam gets a team by ID
-func (c *Client) GetTeam(id int64) (*Team, error) {
+func (c *Client) GetTeam(id int64) (*Team, *Response, error) {
 	t := new(Team)
-	return t, c.getParsedResponse("GET", fmt.Sprintf("/teams/%d", id), nil, nil, t)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d", id), nil, nil, t)
+	return t, resp, err
 }
 
 // CreateTeamOption options for creating a team
@@ -79,16 +82,17 @@ func (opt CreateTeamOption) Validate() error {
 }
 
 // CreateTeam creates a team for an organization
-func (c *Client) CreateTeam(org string, opt CreateTeamOption) (*Team, error) {
+func (c *Client) CreateTeam(org string, opt CreateTeamOption) (*Team, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	t := new(Team)
-	return t, c.getParsedResponse("POST", fmt.Sprintf("/orgs/%s/teams", org), jsonHeader, bytes.NewReader(body), t)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/orgs/%s/teams", org), jsonHeader, bytes.NewReader(body), t)
+	return t, resp, err
 }
 
 // EditTeamOption options for editing a team
@@ -122,22 +126,22 @@ func (opt EditTeamOption) Validate() error {
 }
 
 // EditTeam edits a team of an organization
-func (c *Client) EditTeam(id int64, opt EditTeamOption) error {
+func (c *Client) EditTeam(id int64, opt EditTeamOption) (*Response, error) {
 	if err := opt.Validate(); err != nil {
-		return err
+		return nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("PATCH", fmt.Sprintf("/teams/%d", id), jsonHeader, bytes.NewReader(body))
+	_, resp, err := c.getResponse("PATCH", fmt.Sprintf("/teams/%d", id), jsonHeader, bytes.NewReader(body))
-	return err
+	return resp, err
 }
 
 // DeleteTeam deletes a team of an organization
-func (c *Client) DeleteTeam(id int64) error {
+func (c *Client) DeleteTeam(id int64) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d", id), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d", id), nil, nil)
-	return err
+	return resp, err
 }
 
 // ListTeamMembersOptions options for listing team's members
@@ -146,28 +150,30 @@ type ListTeamMembersOptions struct {
 }
 
 // ListTeamMembers lists all members of a team
-func (c *Client) ListTeamMembers(id int64, opt ListTeamMembersOptions) ([]*User, error) {
+func (c *Client) ListTeamMembers(id int64, opt ListTeamMembersOptions) ([]*User, *Response, error) {
 	opt.setDefaults()
 	members := make([]*User, 0, opt.PageSize)
-	return members, c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/members?%s", id, opt.getURLQuery().Encode()), nil, nil, &members)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/members?%s", id, opt.getURLQuery().Encode()), nil, nil, &members)
+	return members, resp, err
 }
 
 // GetTeamMember gets a member of a team
-func (c *Client) GetTeamMember(id int64, user string) (*User, error) {
+func (c *Client) GetTeamMember(id int64, user string) (*User, *Response, error) {
 	m := new(User)
-	return m, c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil, m)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil, m)
+	return m, resp, err
 }
 
 // AddTeamMember adds a member to a team
-func (c *Client) AddTeamMember(id int64, user string) error {
+func (c *Client) AddTeamMember(id int64, user string) (*Response, error) {
-	_, err := c.getResponse("PUT", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil)
+	_, resp, err := c.getResponse("PUT", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil)
-	return err
+	return resp, err
 }
 
 // RemoveTeamMember removes a member from a team
-func (c *Client) RemoveTeamMember(id int64, user string) error {
+func (c *Client) RemoveTeamMember(id int64, user string) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d/members/%s", id, user), nil, nil)
-	return err
+	return resp, err
 }
 
 // ListTeamRepositoriesOptions options for listing team's repositories
@@ -176,20 +182,21 @@ type ListTeamRepositoriesOptions struct {
 }
 
 // ListTeamRepositories lists all repositories of a team
-func (c *Client) ListTeamRepositories(id int64, opt ListTeamRepositoriesOptions) ([]*Repository, error) {
+func (c *Client) ListTeamRepositories(id int64, opt ListTeamRepositoriesOptions) ([]*Repository, *Response, error) {
 	opt.setDefaults()
 	repos := make([]*Repository, 0, opt.PageSize)
-	return repos, c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/repos?%s", id, opt.getURLQuery().Encode()), nil, nil, &repos)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/teams/%d/repos?%s", id, opt.getURLQuery().Encode()), nil, nil, &repos)
+	return repos, resp, err
 }
 
 // AddTeamRepository adds a repository to a team
-func (c *Client) AddTeamRepository(id int64, org, repo string) error {
+func (c *Client) AddTeamRepository(id int64, org, repo string) (*Response, error) {
-	_, err := c.getResponse("PUT", fmt.Sprintf("/teams/%d/repos/%s/%s", id, org, repo), nil, nil)
+	_, resp, err := c.getResponse("PUT", fmt.Sprintf("/teams/%d/repos/%s/%s", id, org, repo), nil, nil)
-	return err
+	return resp, err
 }
 
 // RemoveTeamRepository removes a repository from a team
-func (c *Client) RemoveTeamRepository(id int64, org, repo string) error {
+func (c *Client) RemoveTeamRepository(id int64, org, repo string) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d/repos/%s/%s", id, org, repo), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/teams/%d/repos/%s/%s", id, org, repo), nil, nil)
-	return err
+	return resp, err
 }

gitea/pull.go

@@ -98,19 +98,21 @@ func (opt *ListPullRequestsOptions) QueryEncode() string {
 }
 
 // ListRepoPullRequests list PRs of one repository
-func (c *Client) ListRepoPullRequests(owner, repo string, opt ListPullRequestsOptions) ([]*PullRequest, error) {
+func (c *Client) ListRepoPullRequests(owner, repo string, opt ListPullRequestsOptions) ([]*PullRequest, *Response, error) {
 	opt.setDefaults()
 	prs := make([]*PullRequest, 0, opt.PageSize)
 
 	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/pulls", owner, repo))
 	link.RawQuery = opt.QueryEncode()
-	return prs, c.getParsedResponse("GET", link.String(), jsonHeader, nil, &prs)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &prs)
+	return prs, resp, err
 }
 
 // GetPullRequest get information of one PR
-func (c *Client) GetPullRequest(owner, repo string, index int64) (*PullRequest, error) {
+func (c *Client) GetPullRequest(owner, repo string, index int64) (*PullRequest, *Response, error) {
 	pr := new(PullRequest)
-	return pr, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d", owner, repo, index), nil, nil, pr)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d", owner, repo, index), nil, nil, pr)
+	return pr, resp, err
 }
 
 // CreatePullRequestOption options when creating a pull request
@@ -127,14 +129,16 @@ type CreatePullRequestOption struct {
 }
 
 // CreatePullRequest create pull request with options
-func (c *Client) CreatePullRequest(owner, repo string, opt CreatePullRequestOption) (*PullRequest, error) {
+func (c *Client) CreatePullRequest(owner, repo string, opt CreatePullRequestOption) (*PullRequest, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	pr := new(PullRequest)
-	return pr, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/pulls", owner, repo),
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls", owner, repo),
 		jsonHeader, bytes.NewReader(body), pr)
+	return pr, resp, err
 }
 
 // EditPullRequestOption options when modify pull request
@@ -164,17 +168,19 @@ func (opt EditPullRequestOption) Validate(c *Client) error {
 }
 
 // EditPullRequest modify pull request with PR id and options
-func (c *Client) EditPullRequest(owner, repo string, index int64, opt EditPullRequestOption) (*PullRequest, error) {
+func (c *Client) EditPullRequest(owner, repo string, index int64, opt EditPullRequestOption) (*PullRequest, *Response, error) {
 	if err := opt.Validate(c); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	pr := new(PullRequest)
-	return pr, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/pulls/%d", owner, repo, index),
+	resp, err := c.getParsedResponse("PATCH",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d", owner, repo, index),
 		jsonHeader, bytes.NewReader(body), pr)
+	return pr, resp, err
 }
 
 // MergePullRequestOption options when merging a pull request
@@ -195,41 +201,41 @@ func (opt MergePullRequestOption) Validate(c *Client) error {
 }
 
 // MergePullRequest merge a PR to repository by PR id
-func (c *Client) MergePullRequest(owner, repo string, index int64, opt MergePullRequestOption) (bool, error) {
+func (c *Client) MergePullRequest(owner, repo string, index int64, opt MergePullRequestOption) (bool, *Response, error) {
 	if err := opt.Validate(c); err != nil {
-		return false, err
+		return false, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return false, err
+		return false, nil, err
 	}
-	status, err := c.getStatusCode("POST", fmt.Sprintf("/repos/%s/%s/pulls/%d/merge", owner, repo, index), jsonHeader, bytes.NewReader(body))
+	status, resp, err := c.getStatusCode("POST", fmt.Sprintf("/repos/%s/%s/pulls/%d/merge", owner, repo, index), jsonHeader, bytes.NewReader(body))
 	if err != nil {
-		return false, err
+		return false, resp, err
 	}
-	return status == 200, nil
+	return status == 200, resp, nil
 }
 
 // IsPullRequestMerged test if one PR is merged to one repository
-func (c *Client) IsPullRequestMerged(owner, repo string, index int64) (bool, error) {
+func (c *Client) IsPullRequestMerged(owner, repo string, index int64) (bool, *Response, error) {
-	statusCode, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d/merge", owner, repo, index), nil, nil)
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d/merge", owner, repo, index), nil, nil)
 
 	if err != nil {
-		return false, err
+		return false, resp, err
 	}
 
-	return statusCode == 204, nil
+	return status == 204, resp, nil
 }
 
 // getPullRequestDiffOrPatch gets the patch or diff file as bytes for a PR
-func (c *Client) getPullRequestDiffOrPatch(owner, repo, kind string, index int64) ([]byte, error) {
+func (c *Client) getPullRequestDiffOrPatch(owner, repo, kind string, index int64) ([]byte, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
-		r, err2 := c.GetRepo(owner, repo)
+		r, _, err2 := c.GetRepo(owner, repo)
 		if err2 != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		if r.Private {
-			return nil, err
+			return nil, nil, err
 		}
 		return c.getWebResponse("GET", fmt.Sprintf("/%s/%s/pulls/%d.%s", owner, repo, index, kind), nil)
 	}
@@ -237,11 +243,11 @@ func (c *Client) getPullRequestDiffOrPatch(owner, repo, kind string, index int64
 }
 
 // GetPullRequestPatch gets the .patch file as bytes for a PR
-func (c *Client) GetPullRequestPatch(owner, repo string, index int64) ([]byte, error) {
+func (c *Client) GetPullRequestPatch(owner, repo string, index int64) ([]byte, *Response, error) {
 	return c.getPullRequestDiffOrPatch(owner, repo, "patch", index)
 }
 
 // GetPullRequestDiff gets the .diff file as bytes for a PR
-func (c *Client) GetPullRequestDiff(owner, repo string, index int64) ([]byte, error) {
+func (c *Client) GetPullRequestDiff(owner, repo string, index int64) ([]byte, *Response, error) {
 	return c.getPullRequestDiffOrPatch(owner, repo, "diff", index)
 }

gitea/pull_review.go

@@ -131,9 +131,9 @@ func (opt CreatePullReviewComment) Validate() error {
 }
 
 // ListPullReviews lists all reviews of a pull request
-func (c *Client) ListPullReviews(owner, repo string, index int64, opt ListPullReviewsOptions) ([]*PullReview, error) {
+func (c *Client) ListPullReviews(owner, repo string, index int64, opt ListPullReviewsOptions) ([]*PullReview, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	opt.setDefaults()
 	rs := make([]*PullReview, 0, opt.PageSize)
@@ -141,72 +141,79 @@ func (c *Client) ListPullReviews(owner, repo string, index int64, opt ListPullRe
 	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews", owner, repo, index))
 	link.RawQuery = opt.ListOptions.getURLQuery().Encode()
 
-	return rs, c.getParsedResponse("GET", link.String(), jsonHeader, nil, &rs)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &rs)
+	return rs, resp, err
 }
 
 // GetPullReview gets a specific review of a pull request
-func (c *Client) GetPullReview(owner, repo string, index, id int64) (*PullReview, error) {
+func (c *Client) GetPullReview(owner, repo string, index, id int64) (*PullReview, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	r := new(PullReview)
-	return r, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d", owner, repo, index, id), jsonHeader, nil, &r)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d", owner, repo, index, id), jsonHeader, nil, &r)
+	return r, resp, err
 }
 
 // ListPullReviewComments lists all comments of a pull request review
-func (c *Client) ListPullReviewComments(owner, repo string, index, id int64) ([]*PullReviewComment, error) {
+func (c *Client) ListPullReviewComments(owner, repo string, index, id int64) ([]*PullReviewComment, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	rcl := make([]*PullReviewComment, 0, 4)
 	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d/comments", owner, repo, index, id))
 
-	return rcl, c.getParsedResponse("GET", link.String(), jsonHeader, nil, &rcl)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &rcl)
+	return rcl, resp, err
 }
 
 // DeletePullReview delete a specific review from a pull request
-func (c *Client) DeletePullReview(owner, repo string, index, id int64) error {
+func (c *Client) DeletePullReview(owner, repo string, index, id int64) (*Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return err
+		return nil, err
 	}
 
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d", owner, repo, index, id), jsonHeader, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d", owner, repo, index, id), jsonHeader, nil)
-	return err
+	return resp, err
 }
 
 // CreatePullReview create a review to an pull request
-func (c *Client) CreatePullReview(owner, repo string, index int64, opt CreatePullReviewOptions) (*PullReview, error) {
+func (c *Client) CreatePullReview(owner, repo string, index int64, opt CreatePullReviewOptions) (*PullReview, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	r := new(PullReview)
-	return r, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews", owner, repo, index),
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews", owner, repo, index),
 		jsonHeader, bytes.NewReader(body), r)
+	return r, resp, err
 }
 
 // SubmitPullReview submit a pending review to an pull request
-func (c *Client) SubmitPullReview(owner, repo string, index, id int64, opt SubmitPullReviewOptions) (*PullReview, error) {
+func (c *Client) SubmitPullReview(owner, repo string, index, id int64, opt SubmitPullReviewOptions) (*PullReview, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	r := new(PullReview)
-	return r, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d", owner, repo, index, id),
+	resp, err := c.getParsedResponse("POST",
+		fmt.Sprintf("/repos/%s/%s/pulls/%d/reviews/%d", owner, repo, index, id),
 		jsonHeader, bytes.NewReader(body), r)
+	return r, resp, err
 }

gitea/pull_review_test.go

@@ -24,7 +24,7 @@ func TestPullReview(t *testing.T) {
 	defer c.AdminDeleteUser(submitter.UserName)
 
 	// CreatePullReview
-	r1, err := c.CreatePullReview(repo.Owner.UserName, repo.Name, pull.Index, CreatePullReviewOptions{
+	r1, _, err := c.CreatePullReview(repo.Owner.UserName, repo.Name, pull.Index, CreatePullReviewOptions{
 		State: ReviewStateComment,
 		Body:  "I'll have a look at it later",
 	})
@@ -35,12 +35,12 @@ func TestPullReview(t *testing.T) {
 	}
 
 	c.SetSudo(submitter.UserName)
-	r2, err := c.CreatePullReview(repo.Owner.UserName, repo.Name, pull.Index, CreatePullReviewOptions{
+	r2, _, err := c.CreatePullReview(repo.Owner.UserName, repo.Name, pull.Index, CreatePullReviewOptions{
 		State: ReviewStateApproved,
 		Body:  "lgtm it myself",
 	})
 	assert.Error(t, err)
-	r2, err = c.CreatePullReview(repo.Owner.UserName, repo.Name, pull.Index, CreatePullReviewOptions{
+	r2, _, err = c.CreatePullReview(repo.Owner.UserName, repo.Name, pull.Index, CreatePullReviewOptions{
 		State: ReviewStateComment,
 		Body:  "no seriously please have a look at it",
 	})
@@ -48,7 +48,7 @@ func TestPullReview(t *testing.T) {
 	assert.NotNil(t, r2)
 
 	c.SetSudo(reviewer.UserName)
-	r3, err := c.CreatePullReview(repo.Owner.UserName, repo.Name, pull.Index, CreatePullReviewOptions{
+	r3, _, err := c.CreatePullReview(repo.Owner.UserName, repo.Name, pull.Index, CreatePullReviewOptions{
 		State: ReviewStateApproved,
 		Body:  "lgtm",
 		Comments: []CreatePullReviewComment{{
@@ -63,7 +63,7 @@ func TestPullReview(t *testing.T) {
 
 	// ListPullReviews
 	c.SetSudo("")
-	rl, err := c.ListPullReviews(repo.Owner.UserName, repo.Name, pull.Index, ListPullReviewsOptions{})
+	rl, _, err := c.ListPullReviews(repo.Owner.UserName, repo.Name, pull.Index, ListPullReviewsOptions{})
 	if !assert.NoError(t, err) {
 		return
 	}
@@ -76,20 +76,20 @@ func TestPullReview(t *testing.T) {
 	}
 
 	// GetPullReview
-	rNew, err := c.GetPullReview(repo.Owner.UserName, repo.Name, pull.Index, r3.ID)
+	rNew, _, err := c.GetPullReview(repo.Owner.UserName, repo.Name, pull.Index, r3.ID)
 	assert.NoError(t, err)
 	assert.EqualValues(t, r3, rNew)
 
 	// DeletePullReview
 	c.SetSudo(submitter.UserName)
-	err = c.DeletePullReview(repo.Owner.UserName, repo.Name, pull.Index, r2.ID)
+	_, err = c.DeletePullReview(repo.Owner.UserName, repo.Name, pull.Index, r2.ID)
 	assert.NoError(t, err)
-	err = c.DeletePullReview(repo.Owner.UserName, repo.Name, pull.Index, r3.ID)
+	_, err = c.DeletePullReview(repo.Owner.UserName, repo.Name, pull.Index, r3.ID)
 	assert.Error(t, err)
 
 	// SubmitPullReview
 	c.SetSudo("")
-	r4, err := c.CreatePullReview(repo.Owner.UserName, repo.Name, pull.Index, CreatePullReviewOptions{
+	r4, _, err := c.CreatePullReview(repo.Owner.UserName, repo.Name, pull.Index, CreatePullReviewOptions{
 		Body: "...",
 		Comments: []CreatePullReviewComment{{
 			Path:       "WOW-file",
@@ -99,7 +99,7 @@ func TestPullReview(t *testing.T) {
 		},
 	})
 	assert.NoError(t, err)
-	r5, err := c.CreatePullReview(repo.Owner.UserName, repo.Name, pull.Index, CreatePullReviewOptions{
+	r5, _, err := c.CreatePullReview(repo.Owner.UserName, repo.Name, pull.Index, CreatePullReviewOptions{
 		Body: "...",
 		Comments: []CreatePullReviewComment{{
 			Path:       "WOW-file",
@@ -111,7 +111,7 @@ func TestPullReview(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, r4.ID, r5.ID)
 
-	r, err := c.SubmitPullReview(repo.Owner.UserName, repo.Name, pull.Index, r4.ID, SubmitPullReviewOptions{
+	r, _, err := c.SubmitPullReview(repo.Owner.UserName, repo.Name, pull.Index, r4.ID, SubmitPullReviewOptions{
 		State: ReviewStateRequestChanges,
 		Body:  "one nit",
 	})
@@ -120,7 +120,7 @@ func TestPullReview(t *testing.T) {
 	assert.EqualValues(t, ReviewStateRequestChanges, r.State)
 
 	// ListPullReviewComments
-	rcl, err := c.ListPullReviewComments(repo.Owner.UserName, repo.Name, pull.Index, r.ID)
+	rcl, _, err := c.ListPullReviewComments(repo.Owner.UserName, repo.Name, pull.Index, r.ID)
 	assert.NoError(t, err)
 	assert.EqualValues(t, r.CodeCommentsCount, len(rcl))
 	for _, rc := range rcl {
@@ -143,14 +143,14 @@ func preparePullReviewTest(t *testing.T, c *Client, repoName string) (*Repositor
 
 	pullSubmitter := createTestUser(t, "pull_submitter", c)
 	write := AccessModeWrite
-	err = c.AddCollaborator(repo.Owner.UserName, repo.Name, pullSubmitter.UserName, AddCollaboratorOption{
+	_, err = c.AddCollaborator(repo.Owner.UserName, repo.Name, pullSubmitter.UserName, AddCollaboratorOption{
 		Permission: &write,
 	})
 	assert.NoError(t, err)
 
 	c.SetSudo("pull_submitter")
 
-	newFile, err := c.CreateFile(repo.Owner.UserName, repo.Name, "WOW-file", CreateFileOptions{
+	newFile, _, err := c.CreateFile(repo.Owner.UserName, repo.Name, "WOW-file", CreateFileOptions{
 		Content: "QSBuZXcgRmlsZQoKYW5kIHNvbWUgbGluZXMK",
 		FileOptions: FileOptions{
 			Message:       "creat a new file",
@@ -163,7 +163,7 @@ func preparePullReviewTest(t *testing.T, c *Client, repoName string) (*Repositor
 		return nil, nil, nil, nil, false
 	}
 
-	pull, err := c.CreatePullRequest(c.username, repoName, CreatePullRequestOption{
+	pull, _, err := c.CreatePullRequest(c.username, repoName, CreatePullRequestOption{
 		Base:  "master",
 		Head:  "new_file",
 		Title: "Creat a NewFile",
@@ -175,7 +175,7 @@ func preparePullReviewTest(t *testing.T, c *Client, repoName string) (*Repositor
 
 	reviewer := createTestUser(t, "pull_reviewer", c)
 	admin := AccessModeAdmin
-	err = c.AddCollaborator(repo.Owner.UserName, repo.Name, pullSubmitter.UserName, AddCollaboratorOption{
+	_, err = c.AddCollaborator(repo.Owner.UserName, repo.Name, pullSubmitter.UserName, AddCollaboratorOption{
 		Permission: &admin,
 	})
 	assert.NoError(t, err)

gitea/pull_test.go

@@ -14,7 +14,7 @@ import (
 func TestPull(t *testing.T) {
 	log.Println("== TestPull ==")
 	c := newTestClient()
-	user, err := c.GetMyUserInfo()
+	user, _, err := c.GetMyUserInfo()
 	assert.NoError(t, err)
 
 	var repoName = "repo_pull_test"
@@ -24,11 +24,11 @@ func TestPull(t *testing.T) {
 	}
 
 	// ListRepoPullRequests list PRs of one repository
-	pulls, err := c.ListRepoPullRequests(user.UserName, repoName, ListPullRequestsOptions{})
+	pulls, _, err := c.ListRepoPullRequests(user.UserName, repoName, ListPullRequestsOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, pulls, 0)
 
-	pullUpdateFile, err := c.CreatePullRequest(c.username, repoName, CreatePullRequestOption{
+	pullUpdateFile, _, err := c.CreatePullRequest(c.username, repoName, CreatePullRequestOption{
 		Base:  "master",
 		Head:  forkOrg + ":overwrite_licence",
 		Title: "overwrite a file",
@@ -36,7 +36,7 @@ func TestPull(t *testing.T) {
 	assert.NoError(t, err)
 	assert.NotNil(t, pullUpdateFile)
 
-	pullNewFile, err := c.CreatePullRequest(c.username, repoName, CreatePullRequestOption{
+	pullNewFile, _, err := c.CreatePullRequest(c.username, repoName, CreatePullRequestOption{
 		Base:  "master",
 		Head:  forkOrg + ":new_file",
 		Title: "create a file",
@@ -44,7 +44,7 @@ func TestPull(t *testing.T) {
 	assert.NoError(t, err)
 	assert.NotNil(t, pullNewFile)
 
-	pullConflict, err := c.CreatePullRequest(c.username, repoName, CreatePullRequestOption{
+	pullConflict, _, err := c.CreatePullRequest(c.username, repoName, CreatePullRequestOption{
 		Base:  "master",
 		Head:  forkOrg + ":will_conflict",
 		Title: "this pull will conflict",
@@ -52,33 +52,33 @@ func TestPull(t *testing.T) {
 	assert.NoError(t, err)
 	assert.NotNil(t, pullConflict)
 
-	pulls, err = c.ListRepoPullRequests(user.UserName, repoName, ListPullRequestsOptions{})
+	pulls, _, err = c.ListRepoPullRequests(user.UserName, repoName, ListPullRequestsOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, pulls, 3)
 
-	diff, err := c.GetPullRequestDiff(c.username, repoName, pullUpdateFile.Index)
+	diff, _, err := c.GetPullRequestDiff(c.username, repoName, pullUpdateFile.Index)
 	assert.NoError(t, err)
 	assert.Len(t, diff, 1310)
-	patch, err := c.GetPullRequestPatch(c.username, repoName, pullUpdateFile.Index)
+	patch, _, err := c.GetPullRequestPatch(c.username, repoName, pullUpdateFile.Index)
 	assert.NoError(t, err)
 	assert.True(t, len(patch) > len(diff))
 
 	// test Update pull
-	pr, err := c.GetPullRequest(user.UserName, repoName, pullUpdateFile.Index)
+	pr, _, err := c.GetPullRequest(user.UserName, repoName, pullUpdateFile.Index)
 	assert.NoError(t, err)
 	assert.False(t, pullUpdateFile.HasMerged)
 	assert.True(t, pullUpdateFile.Mergeable)
-	merged, err := c.MergePullRequest(user.UserName, repoName, pullUpdateFile.Index, MergePullRequestOption{
+	merged, _, err := c.MergePullRequest(user.UserName, repoName, pullUpdateFile.Index, MergePullRequestOption{
 		Style:   MergeStyleSquash,
 		Title:   pullUpdateFile.Title,
 		Message: "squash: " + pullUpdateFile.Title,
 	})
 	assert.NoError(t, err)
 	assert.True(t, merged)
-	merged, err = c.IsPullRequestMerged(user.UserName, repoName, pullUpdateFile.Index)
+	merged, _, err = c.IsPullRequestMerged(user.UserName, repoName, pullUpdateFile.Index)
 	assert.NoError(t, err)
 	assert.True(t, merged)
-	pr, err = c.GetPullRequest(user.UserName, repoName, pullUpdateFile.Index)
+	pr, _, err = c.GetPullRequest(user.UserName, repoName, pullUpdateFile.Index)
 	assert.NoError(t, err)
 	assert.EqualValues(t, pullUpdateFile.Head.Name, pr.Head.Name)
 	assert.EqualValues(t, pullUpdateFile.Base.Name, pr.Base.Name)
@@ -87,34 +87,34 @@ func TestPull(t *testing.T) {
 	assert.True(t, pr.HasMerged)
 
 	// test conflict pull
-	pr, err = c.GetPullRequest(user.UserName, repoName, pullConflict.Index)
+	pr, _, err = c.GetPullRequest(user.UserName, repoName, pullConflict.Index)
 	assert.NoError(t, err)
 	assert.False(t, pullConflict.HasMerged)
 	assert.False(t, pullConflict.Mergeable)
-	merged, err = c.MergePullRequest(user.UserName, repoName, pullConflict.Index, MergePullRequestOption{
+	merged, _, err = c.MergePullRequest(user.UserName, repoName, pullConflict.Index, MergePullRequestOption{
 		Style:   MergeStyleMerge,
 		Title:   "pullConflict",
 		Message: "pullConflict Msg",
 	})
 	assert.NoError(t, err)
 	assert.False(t, merged)
-	merged, err = c.IsPullRequestMerged(user.UserName, repoName, pullConflict.Index)
+	merged, _, err = c.IsPullRequestMerged(user.UserName, repoName, pullConflict.Index)
 	assert.NoError(t, err)
 	assert.False(t, merged)
-	pr, err = c.GetPullRequest(user.UserName, repoName, pullConflict.Index)
+	pr, _, err = c.GetPullRequest(user.UserName, repoName, pullConflict.Index)
 	assert.NoError(t, err)
 	assert.Nil(t, pr.MergedCommitID)
 	assert.False(t, pr.HasMerged)
 
 	state := StateClosed
-	pr, err = c.EditPullRequest(user.UserName, repoName, pullConflict.Index, EditPullRequestOption{
+	pr, _, err = c.EditPullRequest(user.UserName, repoName, pullConflict.Index, EditPullRequestOption{
 		Title: "confl",
 		State: &state,
 	})
 	assert.NoError(t, err)
 	assert.EqualValues(t, state, pr.State)
 
-	pulls, err = c.ListRepoPullRequests(user.UserName, repoName, ListPullRequestsOptions{
+	pulls, _, err = c.ListRepoPullRequests(user.UserName, repoName, ListPullRequestsOptions{
 		State: StateClosed,
 		Sort:  "leastupdate",
 	})
@@ -123,26 +123,26 @@ func TestPull(t *testing.T) {
 }
 
 func preparePullTest(t *testing.T, c *Client, repoName, forkOrg string) bool {
-	_ = c.DeleteRepo(forkOrg, repoName)
+	_, _ = c.DeleteRepo(forkOrg, repoName)
-	_ = c.DeleteRepo(c.username, repoName)
+	_, _ = c.DeleteRepo(c.username, repoName)
-	_ = c.DeleteOrg(forkOrg)
+	_, _ = c.DeleteOrg(forkOrg)
 
 	origRepo, err := createTestRepo(t, repoName, c)
 	if !assert.NoError(t, err) {
 		return false
 	}
-	org, err := c.CreateOrg(CreateOrgOption{Name: forkOrg})
+	org, _, err := c.CreateOrg(CreateOrgOption{Name: forkOrg})
 	assert.NoError(t, err)
-	forkRepo, err := c.CreateFork(origRepo.Owner.UserName, origRepo.Name, CreateForkOption{Organization: &org.UserName})
+	forkRepo, _, err := c.CreateFork(origRepo.Owner.UserName, origRepo.Name, CreateForkOption{Organization: &org.UserName})
 	assert.NoError(t, err)
 	assert.NotNil(t, forkRepo)
 
-	masterLicence, err := c.GetContents(forkRepo.Owner.UserName, forkRepo.Name, "master", "LICENSE")
+	masterLicence, _, err := c.GetContents(forkRepo.Owner.UserName, forkRepo.Name, "master", "LICENSE")
 	if !assert.NoError(t, err) || !assert.NotNil(t, masterLicence) {
 		return false
 	}
 
-	updatedFile, err := c.UpdateFile(forkRepo.Owner.UserName, forkRepo.Name, "LICENSE", UpdateFileOptions{
+	updatedFile, _, err := c.UpdateFile(forkRepo.Owner.UserName, forkRepo.Name, "LICENSE", UpdateFileOptions{
 		FileOptions: FileOptions{
 			Message:       "Overwrite",
 			BranchName:    "master",
@@ -155,7 +155,7 @@ func preparePullTest(t *testing.T, c *Client, repoName, forkOrg string) bool {
 		return false
 	}
 
-	newFile, err := c.CreateFile(forkRepo.Owner.UserName, forkRepo.Name, "WOW-file", CreateFileOptions{
+	newFile, _, err := c.CreateFile(forkRepo.Owner.UserName, forkRepo.Name, "WOW-file", CreateFileOptions{
 		Content: "QSBuZXcgRmlsZQo=",
 		FileOptions: FileOptions{
 			Message:       "creat a new file",
@@ -167,7 +167,7 @@ func preparePullTest(t *testing.T, c *Client, repoName, forkOrg string) bool {
 		return false
 	}
 
-	conflictFile1, err := c.CreateFile(origRepo.Owner.UserName, origRepo.Name, "bad-file", CreateFileOptions{
+	conflictFile1, _, err := c.CreateFile(origRepo.Owner.UserName, origRepo.Name, "bad-file", CreateFileOptions{
 		Content: "U3RhcnQgQ29uZmxpY3QK",
 		FileOptions: FileOptions{
 			Message:    "Start Conflict",
@@ -178,7 +178,7 @@ func preparePullTest(t *testing.T, c *Client, repoName, forkOrg string) bool {
 		return false
 	}
 
-	conflictFile2, err := c.CreateFile(forkRepo.Owner.UserName, forkRepo.Name, "bad-file", CreateFileOptions{
+	conflictFile2, _, err := c.CreateFile(forkRepo.Owner.UserName, forkRepo.Name, "bad-file", CreateFileOptions{
 		Content: "V2lsbEhhdmUgQ29uZmxpY3QK",
 		FileOptions: FileOptions{
 			Message:       "creat a new file witch will conflict",

gitea/release.go

@@ -36,22 +36,22 @@ type ListReleasesOptions struct {
 }
 
 // ListReleases list releases of a repository
-func (c *Client) ListReleases(user, repo string, opt ListReleasesOptions) ([]*Release, error) {
+func (c *Client) ListReleases(user, repo string, opt ListReleasesOptions) ([]*Release, *Response, error) {
 	opt.setDefaults()
 	releases := make([]*Release, 0, opt.PageSize)
-	err := c.getParsedResponse("GET",
+	resp, err := c.getParsedResponse("GET",
 		fmt.Sprintf("/repos/%s/%s/releases?%s", user, repo, opt.getURLQuery().Encode()),
 		nil, nil, &releases)
-	return releases, err
+	return releases, resp, err
 }
 
 // GetRelease get a release of a repository
-func (c *Client) GetRelease(user, repo string, id int64) (*Release, error) {
+func (c *Client) GetRelease(user, repo string, id int64) (*Release, *Response, error) {
 	r := new(Release)
-	err := c.getParsedResponse("GET",
+	resp, err := c.getParsedResponse("GET",
 		fmt.Sprintf("/repos/%s/%s/releases/%d", user, repo, id),
 		nil, nil, &r)
-	return r, err
+	return r, resp, err
 }
 
 // CreateReleaseOption options when creating a release
@@ -73,19 +73,19 @@ func (opt CreateReleaseOption) Validate() error {
 }
 
 // CreateRelease create a release
-func (c *Client) CreateRelease(user, repo string, opt CreateReleaseOption) (*Release, error) {
+func (c *Client) CreateRelease(user, repo string, opt CreateReleaseOption) (*Release, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	r := new(Release)
-	err = c.getParsedResponse("POST",
+	resp, err := c.getParsedResponse("POST",
 		fmt.Sprintf("/repos/%s/%s/releases", user, repo),
 		jsonHeader, bytes.NewReader(body), r)
-	return r, err
+	return r, resp, err
 }
 
 // EditReleaseOption options when editing a release
@@ -99,22 +99,22 @@ type EditReleaseOption struct {
 }
 
 // EditRelease edit a release
-func (c *Client) EditRelease(user, repo string, id int64, form EditReleaseOption) (*Release, error) {
+func (c *Client) EditRelease(user, repo string, id int64, form EditReleaseOption) (*Release, *Response, error) {
 	body, err := json.Marshal(form)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	r := new(Release)
-	err = c.getParsedResponse("PATCH",
+	resp, err := c.getParsedResponse("PATCH",
 		fmt.Sprintf("/repos/%s/%s/releases/%d", user, repo, id),
 		jsonHeader, bytes.NewReader(body), r)
-	return r, err
+	return r, resp, err
 }
 
 // DeleteRelease delete a release from a repository
-func (c *Client) DeleteRelease(user, repo string, id int64) error {
+func (c *Client) DeleteRelease(user, repo string, id int64) (*Response, error) {
-	_, err := c.getResponse("DELETE",
+	_, resp, err := c.getResponse("DELETE",
 		fmt.Sprintf("/repos/%s/%s/releases/%d", user, repo, id),
 		nil, nil)
-	return err
+	return resp, err
 }

gitea/repo.go

@@ -79,17 +79,19 @@ type ListReposOptions struct {
 }
 
 // ListMyRepos lists all repositories for the authenticated user that has access to.
-func (c *Client) ListMyRepos(opt ListReposOptions) ([]*Repository, error) {
+func (c *Client) ListMyRepos(opt ListReposOptions) ([]*Repository, *Response, error) {
 	opt.setDefaults()
 	repos := make([]*Repository, 0, opt.PageSize)
-	return repos, c.getParsedResponse("GET", fmt.Sprintf("/user/repos?%s", opt.getURLQuery().Encode()), nil, nil, &repos)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/repos?%s", opt.getURLQuery().Encode()), nil, nil, &repos)
+	return repos, resp, err
 }
 
 // ListUserRepos list all repositories of one user by user's name
-func (c *Client) ListUserRepos(user string, opt ListReposOptions) ([]*Repository, error) {
+func (c *Client) ListUserRepos(user string, opt ListReposOptions) ([]*Repository, *Response, error) {
 	opt.setDefaults()
 	repos := make([]*Repository, 0, opt.PageSize)
-	return repos, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/repos?%s", user, opt.getURLQuery().Encode()), nil, nil, &repos)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/repos?%s", user, opt.getURLQuery().Encode()), nil, nil, &repos)
+	return repos, resp, err
 }
 
 // ListOrgReposOptions options for a organization's repositories
@@ -98,10 +100,11 @@ type ListOrgReposOptions struct {
 }
 
 // ListOrgRepos list all repositories of one organization by organization's name
-func (c *Client) ListOrgRepos(org string, opt ListOrgReposOptions) ([]*Repository, error) {
+func (c *Client) ListOrgRepos(org string, opt ListOrgReposOptions) ([]*Repository, *Response, error) {
 	opt.setDefaults()
 	repos := make([]*Repository, 0, opt.PageSize)
-	return repos, c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/repos?%s", org, opt.getURLQuery().Encode()), nil, nil, &repos)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/orgs/%s/repos?%s", org, opt.getURLQuery().Encode()), nil, nil, &repos)
+	return repos, resp, err
 }
 
 // SearchRepoOptions options for searching repositories
@@ -210,9 +213,9 @@ type searchRepoResponse struct {
 }
 
 // SearchRepos searches for repositories matching the given filters
-func (c *Client) SearchRepos(opt SearchRepoOptions) ([]*Repository, error) {
+func (c *Client) SearchRepos(opt SearchRepoOptions) ([]*Repository, *Response, error) {
 	opt.setDefaults()
-	resp := new(searchRepoResponse)
+	repos := new(searchRepoResponse)
 
 	link, _ := url.Parse("/repos/search")
 
@@ -224,14 +227,14 @@ func (c *Client) SearchRepos(opt SearchRepoOptions) ([]*Repository, error) {
 		if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil && opt.IsPrivate != nil {
 			if *opt.IsPrivate {
 				// private repos only not supported on gitea <= 1.11.x
-				return nil, err
+				return nil, nil, err
 			}
 			link.Query().Add("private", "false")
 		}
 	}
 
-	err := c.getParsedResponse("GET", link.String(), nil, nil, &resp)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &repos)
-	return resp.Repos, err
+	return repos.Repos, resp, err
 }
 
 // CreateRepoOption options when creating repository
@@ -265,35 +268,38 @@ func (opt CreateRepoOption) Validate() error {
 }
 
 // CreateRepo creates a repository for authenticated user.
-func (c *Client) CreateRepo(opt CreateRepoOption) (*Repository, error) {
+func (c *Client) CreateRepo(opt CreateRepoOption) (*Repository, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	repo := new(Repository)
-	return repo, c.getParsedResponse("POST", "/user/repos", jsonHeader, bytes.NewReader(body), repo)
+	resp, err := c.getParsedResponse("POST", "/user/repos", jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
 }
 
 // CreateOrgRepo creates an organization repository for authenticated user.
-func (c *Client) CreateOrgRepo(org string, opt CreateRepoOption) (*Repository, error) {
+func (c *Client) CreateOrgRepo(org string, opt CreateRepoOption) (*Repository, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	repo := new(Repository)
-	return repo, c.getParsedResponse("POST", fmt.Sprintf("/org/%s/repos", org), jsonHeader, bytes.NewReader(body), repo)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/org/%s/repos", org), jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
 }
 
 // GetRepo returns information of a repository of given owner.
-func (c *Client) GetRepo(owner, reponame string) (*Repository, error) {
+func (c *Client) GetRepo(owner, reponame string) (*Repository, *Response, error) {
 	repo := new(Repository)
-	return repo, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s", owner, reponame), nil, nil, repo)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s", owner, reponame), nil, nil, repo)
+	return repo, resp, err
 }
 
 // EditRepoOption options when editing a repository's properties
@@ -331,39 +337,40 @@ type EditRepoOption struct {
 }
 
 // EditRepo edit the properties of a repository
-func (c *Client) EditRepo(owner, reponame string, opt EditRepoOption) (*Repository, error) {
+func (c *Client) EditRepo(owner, reponame string, opt EditRepoOption) (*Repository, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	repo := new(Repository)
-	return repo, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s", owner, reponame), jsonHeader, bytes.NewReader(body), repo)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s", owner, reponame), jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
 }
 
 // DeleteRepo deletes a repository of user or organization.
-func (c *Client) DeleteRepo(owner, repo string) error {
+func (c *Client) DeleteRepo(owner, repo string) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s", owner, repo), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s", owner, repo), nil, nil)
-	return err
+	return resp, err
 }
 
 // MirrorSync adds a mirrored repository to the mirror sync queue.
-func (c *Client) MirrorSync(owner, repo string) error {
+func (c *Client) MirrorSync(owner, repo string) (*Response, error) {
-	_, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/mirror-sync", owner, repo), nil, nil)
+	_, resp, err := c.getResponse("POST", fmt.Sprintf("/repos/%s/%s/mirror-sync", owner, repo), nil, nil)
-	return err
+	return resp, err
 }
 
 // GetRepoLanguages return language stats of a repo
-func (c *Client) GetRepoLanguages(owner, repo string) (map[string]int64, error) {
+func (c *Client) GetRepoLanguages(owner, repo string) (map[string]int64, *Response, error) {
 	langMap := make(map[string]int64)
 
-	data, err := c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/languages", owner, repo), jsonHeader, nil)
+	data, resp, err := c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/languages", owner, repo), jsonHeader, nil)
 	if err != nil {
-		return nil, err
+		return nil, resp, err
 	}
 	if err = json.Unmarshal(data, &langMap); err != nil {
-		return nil, err
+		return nil, resp, err
 	}
-	return langMap, nil
+	return langMap, resp, nil
 }
 
 // ArchiveType represent supported archive formats by gitea
@@ -378,6 +385,6 @@ const (
 
 // GetArchive get an archive of a repository by git reference
 // e.g.: ref -> master, 70b7c74b33, v1.2.1, ...
-func (c *Client) GetArchive(owner, repo, ref string, ext ArchiveType) ([]byte, error) {
+func (c *Client) GetArchive(owner, repo, ref string, ext ArchiveType) ([]byte, *Response, error) {
 	return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/archive/%s%s", owner, repo, url.PathEscape(ref), ext), nil, nil)
 }

gitea/repo_branch.go

@@ -65,31 +65,33 @@ type ListRepoBranchesOptions struct {
 }
 
 // ListRepoBranches list all the branches of one repository
-func (c *Client) ListRepoBranches(user, repo string, opt ListRepoBranchesOptions) ([]*Branch, error) {
+func (c *Client) ListRepoBranches(user, repo string, opt ListRepoBranchesOptions) ([]*Branch, *Response, error) {
 	opt.setDefaults()
 	branches := make([]*Branch, 0, opt.PageSize)
-	return branches, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branches?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &branches)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branches?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &branches)
+	return branches, resp, err
 }
 
 // GetRepoBranch get one branch's information of one repository
-func (c *Client) GetRepoBranch(user, repo, branch string) (*Branch, error) {
+func (c *Client) GetRepoBranch(user, repo, branch string) (*Branch, *Response, error) {
 	b := new(Branch)
-	if err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branches/%s", user, repo, branch), nil, nil, &b); err != nil {
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branches/%s", user, repo, branch), nil, nil, &b)
-		return nil, err
+	if err != nil {
+		return nil, resp, err
 	}
-	return b, nil
+	return b, resp, nil
 }
 
 // DeleteRepoBranch delete a branch in a repository
-func (c *Client) DeleteRepoBranch(user, repo, branch string) (bool, error) {
+func (c *Client) DeleteRepoBranch(user, repo, branch string) (bool, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return false, err
+		return false, nil, err
 	}
-	status, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/branches/%s", user, repo, branch), nil, nil)
+	status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/branches/%s", user, repo, branch), nil, nil)
 	if err != nil {
-		return false, err
+		return false, resp, err
 	}
-	return status == 204, nil
+	return status == 204, resp, nil
 }
 
 // CreateBranchOption options when creating a branch in a repository
@@ -115,17 +117,18 @@ func (opt CreateBranchOption) Validate() error {
 }
 
 // CreateBranch creates a branch for a user's repository
-func (c *Client) CreateBranch(owner, repo string, opt CreateBranchOption) (*Branch, error) {
+func (c *Client) CreateBranch(owner, repo string, opt CreateBranchOption) (*Branch, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	branch := new(Branch)
-	return branch, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/branches", owner, repo), jsonHeader, bytes.NewReader(body), branch)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/branches", owner, repo), jsonHeader, bytes.NewReader(body), branch)
+	return branch, resp, err
 }

gitea/repo_branch_protection.go

@@ -91,56 +91,60 @@ type ListBranchProtectionsOptions struct {
 }
 
 // ListBranchProtections list branch protections for a repo
-func (c *Client) ListBranchProtections(owner, repo string, opt ListBranchProtectionsOptions) ([]*BranchProtection, error) {
+func (c *Client) ListBranchProtections(owner, repo string, opt ListBranchProtectionsOptions) ([]*BranchProtection, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
-	bps := make([]*BranchProtection, 0, 5)
+	bps := make([]*BranchProtection, 0, opt.PageSize)
 	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/branch_protections", owner, repo))
 	link.RawQuery = opt.getURLQuery().Encode()
-	return bps, c.getParsedResponse("GET", link.String(), jsonHeader, nil, &bps)
+	resp, err := c.getParsedResponse("GET", link.String(), jsonHeader, nil, &bps)
+	return bps, resp, err
 }
 
 // GetBranchProtection gets a branch protection
-func (c *Client) GetBranchProtection(owner, repo, name string) (*BranchProtection, error) {
+func (c *Client) GetBranchProtection(owner, repo, name string) (*BranchProtection, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	bp := new(BranchProtection)
-	return bp, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branch_protections/%s", owner, repo, name), jsonHeader, nil, bp)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/branch_protections/%s", owner, repo, name), jsonHeader, nil, bp)
+	return bp, resp, err
 }
 
 // CreateBranchProtection creates a branch protection for a repo
-func (c *Client) CreateBranchProtection(owner, repo string, opt CreateBranchProtectionOption) (*BranchProtection, error) {
+func (c *Client) CreateBranchProtection(owner, repo string, opt CreateBranchProtectionOption) (*BranchProtection, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	bp := new(BranchProtection)
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
-	return bp, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/branch_protections", owner, repo), jsonHeader, bytes.NewReader(body), bp)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/branch_protections", owner, repo), jsonHeader, bytes.NewReader(body), bp)
+	return bp, resp, err
 }
 
 // EditBranchProtection edits a branch protection for a repo
-func (c *Client) EditBranchProtection(owner, repo, name string, opt EditBranchProtectionOption) (*BranchProtection, error) {
+func (c *Client) EditBranchProtection(owner, repo, name string, opt EditBranchProtectionOption) (*BranchProtection, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	bp := new(BranchProtection)
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
-	return bp, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/branch_protections/%s", owner, repo, name), jsonHeader, bytes.NewReader(body), bp)
+	resp, err := c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/branch_protections/%s", owner, repo, name), jsonHeader, bytes.NewReader(body), bp)
+	return bp, resp, err
 }
 
 // DeleteBranchProtection deletes a branch protection for a repo
-func (c *Client) DeleteBranchProtection(owner, repo, name string) error {
+func (c *Client) DeleteBranchProtection(owner, repo, name string) (*Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return err
+		return nil, err
 	}
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/branch_protections/%s", owner, repo, name), jsonHeader, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/branch_protections/%s", owner, repo, name), jsonHeader, nil)
-	return err
+	return resp, err
 }

gitea/repo_branch_test.go

@@ -21,37 +21,37 @@ func TestRepoBranches(t *testing.T) {
 		return
 	}
 
-	bl, err := c.ListRepoBranches(repo.Owner.UserName, repo.Name, ListRepoBranchesOptions{})
+	bl, _, err := c.ListRepoBranches(repo.Owner.UserName, repo.Name, ListRepoBranchesOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, bl, 3)
 	assert.EqualValues(t, "feature", bl[0].Name)
 	assert.EqualValues(t, "master", bl[1].Name)
 	assert.EqualValues(t, "update", bl[2].Name)
 
-	b, err := c.GetRepoBranch(repo.Owner.UserName, repo.Name, "update")
+	b, _, err := c.GetRepoBranch(repo.Owner.UserName, repo.Name, "update")
 	assert.NoError(t, err)
 	assert.EqualValues(t, bl[2].Commit.ID, b.Commit.ID)
 	assert.EqualValues(t, bl[2].Commit.Added, b.Commit.Added)
 
-	s, err := c.DeleteRepoBranch(repo.Owner.UserName, repo.Name, "master")
+	s, _, err := c.DeleteRepoBranch(repo.Owner.UserName, repo.Name, "master")
 	assert.NoError(t, err)
 	assert.False(t, s)
-	s, err = c.DeleteRepoBranch(repo.Owner.UserName, repo.Name, "feature")
+	s, _, err = c.DeleteRepoBranch(repo.Owner.UserName, repo.Name, "feature")
 	assert.NoError(t, err)
 	assert.True(t, s)
 
-	bl, err = c.ListRepoBranches(repo.Owner.UserName, repo.Name, ListRepoBranchesOptions{})
+	bl, _, err = c.ListRepoBranches(repo.Owner.UserName, repo.Name, ListRepoBranchesOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, bl, 2)
 
-	b, err = c.GetRepoBranch(repo.Owner.UserName, repo.Name, "feature")
+	b, _, err = c.GetRepoBranch(repo.Owner.UserName, repo.Name, "feature")
 	assert.Error(t, err)
 	assert.Nil(t, b)
 
-	bNew, err := c.CreateBranch(repo.Owner.UserName, repo.Name, CreateBranchOption{BranchName: "NewBranch"})
+	bNew, _, err := c.CreateBranch(repo.Owner.UserName, repo.Name, CreateBranchOption{BranchName: "NewBranch"})
 	assert.NoError(t, err)
 
-	b, err = c.GetRepoBranch(repo.Owner.UserName, repo.Name, bNew.Name)
+	b, _, err = c.GetRepoBranch(repo.Owner.UserName, repo.Name, bNew.Name)
 	assert.NoError(t, err)
 	assert.EqualValues(t, bNew, b)
 }
@@ -68,12 +68,12 @@ func TestRepoBranchProtection(t *testing.T) {
 	assert.NotNil(t, repo)
 
 	// ListBranchProtections
-	bpl, err := c.ListBranchProtections(repo.Owner.UserName, repo.Name, ListBranchProtectionsOptions{})
+	bpl, _, err := c.ListBranchProtections(repo.Owner.UserName, repo.Name, ListBranchProtectionsOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, bpl, 0)
 
 	// CreateBranchProtection
-	bp, err := c.CreateBranchProtection(repo.Owner.UserName, repo.Name, CreateBranchProtectionOption{
+	bp, _, err := c.CreateBranchProtection(repo.Owner.UserName, repo.Name, CreateBranchProtectionOption{
 		BranchName:              "master",
 		EnablePush:              true,
 		EnablePushWhitelist:     true,
@@ -89,7 +89,7 @@ func TestRepoBranchProtection(t *testing.T) {
 	assert.EqualValues(t, true, bp.EnablePushWhitelist)
 	assert.EqualValues(t, []string{"test01"}, bp.PushWhitelistUsernames)
 
-	bp, err = c.CreateBranchProtection(repo.Owner.UserName, repo.Name, CreateBranchProtectionOption{
+	bp, _, err = c.CreateBranchProtection(repo.Owner.UserName, repo.Name, CreateBranchProtectionOption{
 		BranchName:              "update",
 		EnablePush:              false,
 		EnableMergeWhitelist:    true,
@@ -98,12 +98,12 @@ func TestRepoBranchProtection(t *testing.T) {
 	assert.NoError(t, err)
 	assert.NotNil(t, bp)
 
-	bpl, err = c.ListBranchProtections(repo.Owner.UserName, repo.Name, ListBranchProtectionsOptions{})
+	bpl, _, err = c.ListBranchProtections(repo.Owner.UserName, repo.Name, ListBranchProtectionsOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, bpl, 2)
 
 	// GetBranchProtection
-	bp, err = c.GetBranchProtection(repo.Owner.UserName, repo.Name, bpl[0].BranchName)
+	bp, _, err = c.GetBranchProtection(repo.Owner.UserName, repo.Name, bpl[0].BranchName)
 	assert.NoError(t, err)
 	assert.EqualValues(t, bpl[0], bp)
 
@@ -112,7 +112,7 @@ func TestRepoBranchProtection(t *testing.T) {
 	one := int64(1)
 
 	// EditBranchProtection
-	bp, err = c.EditBranchProtection(repo.Owner.UserName, repo.Name, bpl[0].BranchName, EditBranchProtectionOption{
+	bp, _, err = c.EditBranchProtection(repo.Owner.UserName, repo.Name, bpl[0].BranchName, EditBranchProtectionOption{
 		EnablePush:                  &optFalse,
 		EnablePushWhitelist:         &optFalse,
 		PushWhitelistUsernames:      nil,
@@ -127,9 +127,9 @@ func TestRepoBranchProtection(t *testing.T) {
 	assert.EqualValues(t, bpl[0].Created, bp.Created)
 
 	// DeleteBranchProtection
-	err = c.DeleteBranchProtection(repo.Owner.UserName, repo.Name, bpl[1].BranchName)
+	_, err = c.DeleteBranchProtection(repo.Owner.UserName, repo.Name, bpl[1].BranchName)
 	assert.NoError(t, err)
-	bpl, err = c.ListBranchProtections(repo.Owner.UserName, repo.Name, ListBranchProtectionsOptions{})
+	bpl, _, err = c.ListBranchProtections(repo.Owner.UserName, repo.Name, ListBranchProtectionsOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, bpl, 1)
 }
@@ -140,12 +140,12 @@ func prepareBranchTest(t *testing.T, c *Client, repoName string) *Repository {
 		return nil
 	}
 
-	masterLicence, err := c.GetContents(origRepo.Owner.UserName, origRepo.Name, "master", "README.md")
+	masterLicence, _, err := c.GetContents(origRepo.Owner.UserName, origRepo.Name, "master", "README.md")
 	if !assert.NoError(t, err) || !assert.NotNil(t, masterLicence) {
 		return nil
 	}
 
-	updatedFile, err := c.UpdateFile(origRepo.Owner.UserName, origRepo.Name, "README.md", UpdateFileOptions{
+	updatedFile, _, err := c.UpdateFile(origRepo.Owner.UserName, origRepo.Name, "README.md", UpdateFileOptions{
 		FileOptions: FileOptions{
 			Message:       "update it",
 			BranchName:    "master",
@@ -158,7 +158,7 @@ func prepareBranchTest(t *testing.T, c *Client, repoName string) *Repository {
 		return nil
 	}
 
-	newFile, err := c.CreateFile(origRepo.Owner.UserName, origRepo.Name, "WOW-file", CreateFileOptions{
+	newFile, _, err := c.CreateFile(origRepo.Owner.UserName, origRepo.Name, "WOW-file", CreateFileOptions{
 		Content: "QSBuZXcgRmlsZQo=",
 		FileOptions: FileOptions{
 			Message:       "creat a new file",

gitea/repo_collaborator.go

@@ -16,24 +16,25 @@ type ListCollaboratorsOptions struct {
 }
 
 // ListCollaborators list a repository's collaborators
-func (c *Client) ListCollaborators(user, repo string, opt ListCollaboratorsOptions) ([]*User, error) {
+func (c *Client) ListCollaborators(user, repo string, opt ListCollaboratorsOptions) ([]*User, *Response, error) {
 	opt.setDefaults()
 	collaborators := make([]*User, 0, opt.PageSize)
-	return collaborators, c.getParsedResponse("GET",
+	resp, err := c.getParsedResponse("GET",
 		fmt.Sprintf("/repos/%s/%s/collaborators?%s", user, repo, opt.getURLQuery().Encode()),
 		nil, nil, &collaborators)
+	return collaborators, resp, err
 }
 
 // IsCollaborator check if a user is a collaborator of a repository
-func (c *Client) IsCollaborator(user, repo, collaborator string) (bool, error) {
+func (c *Client) IsCollaborator(user, repo, collaborator string) (bool, *Response, error) {
-	status, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), nil, nil)
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), nil, nil)
 	if err != nil {
-		return false, err
+		return false, resp, err
 	}
 	if status == 204 {
-		return true, nil
+		return true, resp, nil
 	}
-	return false, nil
+	return false, resp, nil
 }
 
 // AddCollaboratorOption options when adding a user as a collaborator of a repository
@@ -76,21 +77,21 @@ func (opt AddCollaboratorOption) Validate() error {
 }
 
 // AddCollaborator add some user as a collaborator of a repository
-func (c *Client) AddCollaborator(user, repo, collaborator string, opt AddCollaboratorOption) error {
+func (c *Client) AddCollaborator(user, repo, collaborator string, opt AddCollaboratorOption) (*Response, error) {
 	if err := opt.Validate(); err != nil {
-		return err
+		return nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("PUT", fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), jsonHeader, bytes.NewReader(body))
+	_, resp, err := c.getResponse("PUT", fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), jsonHeader, bytes.NewReader(body))
-	return err
+	return resp, err
 }
 
 // DeleteCollaborator remove a collaborator from a repository
-func (c *Client) DeleteCollaborator(user, repo, collaborator string) error {
+func (c *Client) DeleteCollaborator(user, repo, collaborator string) (*Response, error) {
-	_, err := c.getResponse("DELETE",
+	_, resp, err := c.getResponse("DELETE",
 		fmt.Sprintf("/repos/%s/%s/collaborators/%s", user, repo, collaborator), nil, nil)
-	return err
+	return resp, err
 }

gitea/repo_commit.go

@@ -55,9 +55,10 @@ type CommitDateOptions struct {
 }
 
 // GetSingleCommit returns a single commit
-func (c *Client) GetSingleCommit(user, repo, commitID string) (*Commit, error) {
+func (c *Client) GetSingleCommit(user, repo, commitID string) (*Commit, *Response, error) {
 	commit := new(Commit)
-	return commit, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/commits/%s", user, repo, commitID), nil, nil, &commit)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/commits/%s", user, repo, commitID), nil, nil, &commit)
+	return commit, resp, err
 }
 
 // ListCommitOptions list commit options
@@ -77,10 +78,11 @@ func (opt *ListCommitOptions) QueryEncode() string {
 }
 
 // ListRepoCommits return list of commits from a repo
-func (c *Client) ListRepoCommits(user, repo string, opt ListCommitOptions) ([]*Commit, error) {
+func (c *Client) ListRepoCommits(user, repo string, opt ListCommitOptions) ([]*Commit, *Response, error) {
 	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/commits", user, repo))
 	opt.setDefaults()
 	commits := make([]*Commit, 0, opt.PageSize)
 	link.RawQuery = opt.QueryEncode()
-	return commits, c.getParsedResponse("GET", link.String(), nil, nil, &commits)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &commits)
+	return commits, resp, err
 }

gitea/repo_commit_test.go

@@ -18,7 +18,7 @@ func TestListRepoCommits(t *testing.T) {
 	repo, err := createTestRepo(t, "ListRepoCommits", c)
 	assert.NoError(t, err)
 
-	l, err := c.ListRepoCommits(repo.Owner.UserName, repo.Name, ListCommitOptions{})
+	l, _, err := c.ListRepoCommits(repo.Owner.UserName, repo.Name, ListCommitOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, l, 1)
 	assert.EqualValues(t, "Initial commit\n", l[0].RepoCommit.Message)

gitea/repo_file.go

@@ -114,74 +114,76 @@ type FileDeleteResponse struct {
 
 // GetFile downloads a file of repository, ref can be branch/tag/commit.
 // e.g.: ref -> master, tree -> macaron.go(no leading slash)
-func (c *Client) GetFile(user, repo, ref, tree string) ([]byte, error) {
+func (c *Client) GetFile(user, repo, ref, tree string) ([]byte, *Response, error) {
 	return c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/raw/%s/%s", user, repo, ref, tree), nil, nil)
 }
 
 // GetContents get the metadata and contents (if a file) of an entry in a repository, or a list of entries if a dir
 // ref is optional
-func (c *Client) GetContents(owner, repo, ref, filepath string) (*ContentsResponse, error) {
+func (c *Client) GetContents(owner, repo, ref, filepath string) (*ContentsResponse, *Response, error) {
 	cr := new(ContentsResponse)
-	return cr, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/contents/%s?ref=%s", owner, repo, filepath, ref), jsonHeader, nil, cr)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/contents/%s?ref=%s", owner, repo, filepath, ref), jsonHeader, nil, cr)
-
+	return cr, resp, err
 }
 
 // CreateFile create a file in a repository
-func (c *Client) CreateFile(owner, repo, filepath string, opt CreateFileOptions) (*FileResponse, error) {
+func (c *Client) CreateFile(owner, repo, filepath string, opt CreateFileOptions) (*FileResponse, *Response, error) {
 	var err error
 	if opt.BranchName, err = c.setDefaultBranchForOldVersions(owner, repo, opt.BranchName); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	fr := new(FileResponse)
-	return fr, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/contents/%s", owner, repo, filepath), jsonHeader, bytes.NewReader(body), fr)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/contents/%s", owner, repo, filepath), jsonHeader, bytes.NewReader(body), fr)
+	return fr, resp, err
 }
 
 // UpdateFile update a file in a repository
-func (c *Client) UpdateFile(owner, repo, filepath string, opt UpdateFileOptions) (*FileResponse, error) {
+func (c *Client) UpdateFile(owner, repo, filepath string, opt UpdateFileOptions) (*FileResponse, *Response, error) {
 	var err error
 	if opt.BranchName, err = c.setDefaultBranchForOldVersions(owner, repo, opt.BranchName); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	fr := new(FileResponse)
-	return fr, c.getParsedResponse("PUT", fmt.Sprintf("/repos/%s/%s/contents/%s", owner, repo, filepath), jsonHeader, bytes.NewReader(body), fr)
+	resp, err := c.getParsedResponse("PUT", fmt.Sprintf("/repos/%s/%s/contents/%s", owner, repo, filepath), jsonHeader, bytes.NewReader(body), fr)
+	return fr, resp, err
 }
 
 // DeleteFile delete a file from repository
-func (c *Client) DeleteFile(owner, repo, filepath string, opt DeleteFileOptions) error {
+func (c *Client) DeleteFile(owner, repo, filepath string, opt DeleteFileOptions) (*Response, error) {
 	var err error
 	if opt.BranchName, err = c.setDefaultBranchForOldVersions(owner, repo, opt.BranchName); err != nil {
-		return err
+		return nil, err
 	}
 
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	status, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/contents/%s", owner, repo, filepath), jsonHeader, bytes.NewReader(body))
+	status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/contents/%s", owner, repo, filepath), jsonHeader, bytes.NewReader(body))
 	if err != nil {
-		return err
+		return resp, err
 	}
 	if status != 200 && status != 204 {
-		return fmt.Errorf("unexpected Status: %d", status)
+		return resp, fmt.Errorf("unexpected Status: %d", status)
 	}
-	return nil
+	return resp, nil
 }
 
 func (c *Client) setDefaultBranchForOldVersions(owner, repo, branch string) (string, error) {
 	if len(branch) == 0 {
 		// Gitea >= 1.12.0 Use DefaultBranch on "", mimic this for older versions
-		if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
+		if c.CheckServerVersionConstraint(">=1.12.0") != nil {
-			r, err := c.GetRepo(owner, repo)
+			r, _, err := c.GetRepo(owner, repo)
 			if err != nil {
 				return "", err
 			}

gitea/repo_file_test.go

@@ -20,21 +20,21 @@ func TestFileCreateUpdateGet(t *testing.T) {
 	assert.NoError(t, err)
 	assert.NotNil(t, repo)
 
-	raw, err := c.GetFile(repo.Owner.UserName, repo.Name, "master", "README.md")
+	raw, _, err := c.GetFile(repo.Owner.UserName, repo.Name, "master", "README.md")
 	assert.NoError(t, err)
 	assert.EqualValues(t, "IyBDaGFuZ2VGaWxlcwoKQSB0ZXN0IFJlcG86IENoYW5nZUZpbGVz", base64.StdEncoding.EncodeToString(raw))
 
-	newFile, err := c.CreateFile(repo.Owner.UserName, repo.Name, "A", CreateFileOptions{
+	newFile, _, err := c.CreateFile(repo.Owner.UserName, repo.Name, "A", CreateFileOptions{
 		FileOptions: FileOptions{
 			Message: "create file A",
 		},
 		Content: "ZmlsZUEK",
 	})
 	assert.NoError(t, err)
-	raw, _ = c.GetFile(repo.Owner.UserName, repo.Name, "master", "A")
+	raw, _, _ = c.GetFile(repo.Owner.UserName, repo.Name, "master", "A")
 	assert.EqualValues(t, "ZmlsZUEK", base64.StdEncoding.EncodeToString(raw))
 
-	updatedFile, err := c.UpdateFile(repo.Owner.UserName, repo.Name, "A", UpdateFileOptions{
+	updatedFile, _, err := c.UpdateFile(repo.Owner.UserName, repo.Name, "A", UpdateFileOptions{
 		FileOptions: FileOptions{
 			Message: "add a new line",
 		},
@@ -44,18 +44,18 @@ func TestFileCreateUpdateGet(t *testing.T) {
 	assert.NoError(t, err)
 	assert.NotNil(t, updatedFile)
 
-	file, err := c.GetContents(repo.Owner.UserName, repo.Name, "master", "A")
+	file, _, err := c.GetContents(repo.Owner.UserName, repo.Name, "master", "A")
 	assert.NoError(t, err)
 	assert.EqualValues(t, updatedFile.Content.SHA, file.SHA)
 	assert.EqualValues(t, &updatedFile.Content.Content, &file.Content)
 
-	err = c.DeleteFile(repo.Owner.UserName, repo.Name, "A", DeleteFileOptions{
+	_, err = c.DeleteFile(repo.Owner.UserName, repo.Name, "A", DeleteFileOptions{
 		FileOptions: FileOptions{
 			Message: "Delete File A",
 		},
 		SHA: updatedFile.Content.SHA,
 	})
 	assert.NoError(t, err)
-	_, err = c.GetFile(repo.Owner.UserName, repo.Name, "master", "A")
+	_, _, err = c.GetFile(repo.Owner.UserName, repo.Name, "master", "A")
 	assert.EqualValues(t, "404 Not Found", err.Error())
 }

gitea/repo_key.go

@@ -45,32 +45,35 @@ func (opt *ListDeployKeysOptions) QueryEncode() string {
 }
 
 // ListDeployKeys list all the deploy keys of one repository
-func (c *Client) ListDeployKeys(user, repo string, opt ListDeployKeysOptions) ([]*DeployKey, error) {
+func (c *Client) ListDeployKeys(user, repo string, opt ListDeployKeysOptions) ([]*DeployKey, *Response, error) {
 	link, _ := url.Parse(fmt.Sprintf("/repos/%s/%s/keys", user, repo))
 	opt.setDefaults()
 	link.RawQuery = opt.QueryEncode()
 	keys := make([]*DeployKey, 0, opt.PageSize)
-	return keys, c.getParsedResponse("GET", link.String(), nil, nil, &keys)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &keys)
+	return keys, resp, err
 }
 
 // GetDeployKey get one deploy key with key id
-func (c *Client) GetDeployKey(user, repo string, keyID int64) (*DeployKey, error) {
+func (c *Client) GetDeployKey(user, repo string, keyID int64) (*DeployKey, *Response, error) {
 	key := new(DeployKey)
-	return key, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/keys/%d", user, repo, keyID), nil, nil, &key)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/keys/%d", user, repo, keyID), nil, nil, &key)
+	return key, resp, err
 }
 
 // CreateDeployKey options when create one deploy key
-func (c *Client) CreateDeployKey(user, repo string, opt CreateKeyOption) (*DeployKey, error) {
+func (c *Client) CreateDeployKey(user, repo string, opt CreateKeyOption) (*DeployKey, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	key := new(DeployKey)
-	return key, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/keys", user, repo), jsonHeader, bytes.NewReader(body), key)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/keys", user, repo), jsonHeader, bytes.NewReader(body), key)
+	return key, resp, err
 }
 
 // DeleteDeployKey delete deploy key with key id
-func (c *Client) DeleteDeployKey(owner, repo string, keyID int64) error {
+func (c *Client) DeleteDeployKey(owner, repo string, keyID int64) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/keys/%d", owner, repo, keyID), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/keys/%d", owner, repo, keyID), nil, nil)
-	return err
+	return resp, err
 }

gitea/repo_migrate.go

@@ -77,9 +77,9 @@ func (opt *MigrateRepoOption) Validate() error {
 //
 // To migrate a repository for a organization, the authenticated user must be a
 // owner of the specified organization.
-func (c *Client) MigrateRepo(opt MigrateRepoOption) (*Repository, error) {
+func (c *Client) MigrateRepo(opt MigrateRepoOption) (*Repository, *Response, error) {
 	if err := opt.Validate(); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
@@ -90,16 +90,16 @@ func (c *Client) MigrateRepo(opt MigrateRepoOption) (*Repository, error) {
 		}
 		if len(opt.RepoOwner) != 0 {
 			// gitea <= 1.12 dont understand RepoOwner
-			u, err := c.GetUserInfo(opt.RepoOwner)
+			u, _, err := c.GetUserInfo(opt.RepoOwner)
 			if err != nil {
-				return nil, err
+				return nil, nil, err
 			}
 			opt.RepoOwnerID = u.ID
 		} else if opt.RepoOwnerID == 0 {
 			// gitea <= 1.12 require RepoOwnerID
-			u, err := c.GetMyUserInfo()
+			u, _, err := c.GetMyUserInfo()
 			if err != nil {
-				return nil, err
+				return nil, nil, err
 			}
 			opt.RepoOwnerID = u.ID
 		}
@@ -107,8 +107,9 @@ func (c *Client) MigrateRepo(opt MigrateRepoOption) (*Repository, error) {
 
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	repo := new(Repository)
-	return repo, c.getParsedResponse("POST", "/repos/migrate", jsonHeader, bytes.NewReader(body), repo)
+	resp, err := c.getParsedResponse("POST", "/repos/migrate", jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
 }

gitea/repo_refs.go

@@ -26,44 +26,44 @@ type GitObject struct {
 }
 
 // GetRepoRef get one ref's information of one repository
-func (c *Client) GetRepoRef(user, repo, ref string) (*Reference, error) {
+func (c *Client) GetRepoRef(user, repo, ref string) (*Reference, *Response, error) {
 	ref = strings.TrimPrefix(ref, "refs/")
 	r := new(Reference)
-	err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/refs/%s", user, repo, ref), nil, nil, &r)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/git/refs/%s", user, repo, ref), nil, nil, &r)
 	if _, ok := err.(*json.UnmarshalTypeError); ok {
 		// Multiple refs
-		return nil, errors.New("no exact match found for this ref")
+		return nil, resp, errors.New("no exact match found for this ref")
 	} else if err != nil {
-		return nil, err
+		return nil, resp, err
 	}
 
-	return r, nil
+	return r, resp, nil
 }
 
 // GetRepoRefs get list of ref's information of one repository
-func (c *Client) GetRepoRefs(user, repo, ref string) ([]*Reference, error) {
+func (c *Client) GetRepoRefs(user, repo, ref string) ([]*Reference, *Response, error) {
 	ref = strings.TrimPrefix(ref, "refs/")
-	resp, err := c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/git/refs/%s", user, repo, ref), nil, nil)
+	data, resp, err := c.getResponse("GET", fmt.Sprintf("/repos/%s/%s/git/refs/%s", user, repo, ref), nil, nil)
 	if err != nil {
-		return nil, err
+		return nil, resp, err
 	}
 
 	// Attempt to unmarshal single returned ref.
 	r := new(Reference)
-	refErr := json.Unmarshal(resp, r)
+	refErr := json.Unmarshal(data, r)
 	if refErr == nil {
-		return []*Reference{r}, nil
+		return []*Reference{r}, resp, nil
 	}
 
 	// Attempt to unmarshal multiple refs.
 	var rs []*Reference
-	refsErr := json.Unmarshal(resp, &rs)
+	refsErr := json.Unmarshal(data, &rs)
 	if refsErr == nil {
 		if len(rs) == 0 {
-			return nil, errors.New("unexpected response: an array of refs with length 0")
+			return nil, resp, errors.New("unexpected response: an array of refs with length 0")
 		}
-		return rs, nil
+		return rs, resp, nil
 	}
 
-	return nil, fmt.Errorf("unmarshalling failed for both single and multiple refs: %s and %s", refErr, refsErr)
+	return nil, resp, fmt.Errorf("unmarshalling failed for both single and multiple refs: %s and %s", refErr, refsErr)
 }

gitea/repo_tag.go

@@ -23,8 +23,9 @@ type ListRepoTagsOptions struct {
 }
 
 // ListRepoTags list all the branches of one repository
-func (c *Client) ListRepoTags(user, repo string, opt ListRepoTagsOptions) ([]*Tag, error) {
+func (c *Client) ListRepoTags(user, repo string, opt ListRepoTagsOptions) ([]*Tag, *Response, error) {
 	opt.setDefaults()
 	tags := make([]*Tag, 0, opt.PageSize)
-	return tags, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/tags?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &tags)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/tags?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, &tags)
+	return tags, resp, err
 }

gitea/repo_test.go

@@ -15,34 +15,34 @@ import (
 func TestCreateRepo(t *testing.T) {
 	log.Println("== TestCreateRepo ==")
 	c := newTestClient()
-	user, err := c.GetMyUserInfo()
+	user, _, err := c.GetMyUserInfo()
 	assert.NoError(t, err)
 
 	var repoName = "test1"
-	_, err = c.GetRepo(user.UserName, repoName)
+	_, _, err = c.GetRepo(user.UserName, repoName)
 	if err != nil {
-		repo, err := c.CreateRepo(CreateRepoOption{
+		repo, _, err := c.CreateRepo(CreateRepoOption{
 			Name: repoName,
 		})
 		assert.NoError(t, err)
 		assert.NotNil(t, repo)
 	}
 
-	err = c.DeleteRepo(user.UserName, repoName)
+	_, err = c.DeleteRepo(user.UserName, repoName)
 	assert.NoError(t, err)
 }
 
 func TestRepoMigrateAndLanguages(t *testing.T) {
 	log.Println("== TestMigrateRepo ==")
 	c := newTestClient()
-	user, uErr := c.GetMyUserInfo()
+	user, _, uErr := c.GetMyUserInfo()
 	assert.NoError(t, uErr)
-	_, err := c.GetRepo(user.UserName, "sdk-mirror")
+	_, _, err := c.GetRepo(user.UserName, "sdk-mirror")
 	if err == nil {
-		_ = c.DeleteRepo(user.UserName, "sdk-mirror")
+		_, _ = c.DeleteRepo(user.UserName, "sdk-mirror")
 	}
 
-	repoM, err := c.MigrateRepo(MigrateRepoOption{
+	repoM, _, err := c.MigrateRepo(MigrateRepoOption{
 		CloneAddr:   "https://gitea.com/gitea/go-sdk.git",
 		RepoName:    "sdk-mirror",
 		RepoOwner:   user.UserName,
@@ -52,7 +52,7 @@ func TestRepoMigrateAndLanguages(t *testing.T) {
 	})
 	assert.NoError(t, err)
 
-	repoG, err := c.GetRepo(repoM.Owner.UserName, repoM.Name)
+	repoG, _, err := c.GetRepo(repoM.Owner.UserName, repoM.Name)
 	assert.NoError(t, err)
 	assert.EqualValues(t, repoM.ID, repoG.ID)
 	assert.EqualValues(t, "master", repoG.DefaultBranch)
@@ -62,7 +62,7 @@ func TestRepoMigrateAndLanguages(t *testing.T) {
 
 	log.Println("== TestRepoLanguages ==")
 	time.Sleep(time.Second)
-	lang, err := c.GetRepoLanguages(repoM.Owner.UserName, repoM.Name)
+	lang, _, err := c.GetRepoLanguages(repoM.Owner.UserName, repoM.Name)
 	assert.NoError(t, err)
 	assert.Len(t, lang, 2)
 	assert.True(t, 217441 < lang["Go"])
@@ -75,14 +75,17 @@ func TestSearchRepo(t *testing.T) {
 
 	repo, err := createTestRepo(t, "RepoSearch1", c)
 	assert.NoError(t, err)
-	assert.NoError(t, c.AddRepoTopic(repo.Owner.UserName, repo.Name, "TestTopic1"))
+	_, err = c.AddRepoTopic(repo.Owner.UserName, repo.Name, "TestTopic1")
-	assert.NoError(t, c.AddRepoTopic(repo.Owner.UserName, repo.Name, "TestTopic2"))
+	assert.NoError(t, err)
+	_, err = c.AddRepoTopic(repo.Owner.UserName, repo.Name, "TestTopic2")
+	assert.NoError(t, err)
 
 	repo, err = createTestRepo(t, "RepoSearch2", c)
 	assert.NoError(t, err)
-	assert.NoError(t, c.AddRepoTopic(repo.Owner.UserName, repo.Name, "TestTopic1"))
+	_, err = c.AddRepoTopic(repo.Owner.UserName, repo.Name, "TestTopic1")
+	assert.NoError(t, err)
 
-	repos, err := c.SearchRepos(SearchRepoOptions{
+	repos, _, err := c.SearchRepos(SearchRepoOptions{
 		Keyword:              "Search1",
 		KeywordInDescription: true,
 	})
@@ -90,7 +93,7 @@ func TestSearchRepo(t *testing.T) {
 	assert.NotNil(t, repos)
 	assert.Len(t, repos, 1)
 
-	repos, err = c.SearchRepos(SearchRepoOptions{
+	repos, _, err = c.SearchRepos(SearchRepoOptions{
 		Keyword:              "Search",
 		KeywordInDescription: true,
 	})
@@ -98,7 +101,7 @@ func TestSearchRepo(t *testing.T) {
 	assert.NotNil(t, repos)
 	assert.Len(t, repos, 2)
 
-	repos, err = c.SearchRepos(SearchRepoOptions{
+	repos, _, err = c.SearchRepos(SearchRepoOptions{
 		Keyword:              "TestTopic1",
 		KeywordInDescription: true,
 	})
@@ -106,7 +109,7 @@ func TestSearchRepo(t *testing.T) {
 	assert.NotNil(t, repos)
 	assert.Len(t, repos, 2)
 
-	repos, err = c.SearchRepos(SearchRepoOptions{
+	repos, _, err = c.SearchRepos(SearchRepoOptions{
 		Keyword:              "TestTopic2",
 		KeywordInDescription: true,
 	})
@@ -114,7 +117,7 @@ func TestSearchRepo(t *testing.T) {
 	assert.NotNil(t, repos)
 	assert.Len(t, repos, 1)
 
-	err = c.DeleteRepo(repo.Owner.UserName, repo.Name)
+	_, err = c.DeleteRepo(repo.Owner.UserName, repo.Name)
 	assert.NoError(t, err)
 }
 
@@ -122,7 +125,8 @@ func TestDeleteRepo(t *testing.T) {
 	log.Println("== TestDeleteRepo ==")
 	c := newTestClient()
 	repo, _ := createTestRepo(t, "TestDeleteRepo", c)
-	assert.NoError(t, c.DeleteRepo(repo.Owner.UserName, repo.Name))
+	_, err := c.DeleteRepo(repo.Owner.UserName, repo.Name)
+	assert.NoError(t, err)
 }
 
 func TestGetArchive(t *testing.T) {
@@ -130,20 +134,20 @@ func TestGetArchive(t *testing.T) {
 	c := newTestClient()
 	repo, _ := createTestRepo(t, "ToDownload", c)
 	time.Sleep(time.Second / 2)
-	archive, err := c.GetArchive(repo.Owner.UserName, repo.Name, "master", ZipArchive)
+	archive, _, err := c.GetArchive(repo.Owner.UserName, repo.Name, "master", ZipArchive)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1620, len(archive))
 }
 
 // standard func to create a init repo for test routines
 func createTestRepo(t *testing.T, name string, c *Client) (*Repository, error) {
-	user, uErr := c.GetMyUserInfo()
+	user, _, uErr := c.GetMyUserInfo()
 	assert.NoError(t, uErr)
-	_, err := c.GetRepo(user.UserName, name)
+	_, _, err := c.GetRepo(user.UserName, name)
 	if err == nil {
-		_ = c.DeleteRepo(user.UserName, name)
+		_, _ = c.DeleteRepo(user.UserName, name)
 	}
-	repo, err := c.CreateRepo(CreateRepoOption{
+	repo, _, err := c.CreateRepo(CreateRepoOption{
 		Name:        name,
 		Description: "A test Repo: " + name,
 		AutoInit:    true,

gitea/repo_topics.go

@@ -21,38 +21,38 @@ type topicsList struct {
 }
 
 // ListRepoTopics list all repository's topics
-func (c *Client) ListRepoTopics(user, repo string, opt ListRepoTopicsOptions) ([]string, error) {
+func (c *Client) ListRepoTopics(user, repo string, opt ListRepoTopicsOptions) ([]string, *Response, error) {
 	opt.setDefaults()
 
 	list := new(topicsList)
-	err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/topics?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, list)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/topics?%s", user, repo, opt.getURLQuery().Encode()), nil, nil, list)
 	if err != nil {
-		return nil, err
+		return nil, resp, err
 	}
-	return list.Topics, nil
+	return list.Topics, resp, nil
 }
 
 // SetRepoTopics replaces the list of repo's topics
-func (c *Client) SetRepoTopics(user, repo string, list []string) error {
+func (c *Client) SetRepoTopics(user, repo string, list []string) (*Response, error) {
 
 	l := topicsList{Topics: list}
 
 	body, err := json.Marshal(&l)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("PUT", fmt.Sprintf("/repos/%s/%s/topics", user, repo), jsonHeader, bytes.NewReader(body))
+	_, resp, err := c.getResponse("PUT", fmt.Sprintf("/repos/%s/%s/topics", user, repo), jsonHeader, bytes.NewReader(body))
-	return err
+	return resp, err
 }
 
 // AddRepoTopic adds a topic to a repo's topics list
-func (c *Client) AddRepoTopic(user, repo, topic string) error {
+func (c *Client) AddRepoTopic(user, repo, topic string) (*Response, error) {
-	_, err := c.getResponse("PUT", fmt.Sprintf("/repos/%s/%s/topics/%s", user, repo, topic), nil, nil)
+	_, resp, err := c.getResponse("PUT", fmt.Sprintf("/repos/%s/%s/topics/%s", user, repo, topic), nil, nil)
-	return err
+	return resp, err
 }
 
 // DeleteRepoTopic deletes a topic from repo's topics list
-func (c *Client) DeleteRepoTopic(user, repo, topic string) error {
+func (c *Client) DeleteRepoTopic(user, repo, topic string) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/topics/%s", user, repo, topic), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/topics/%s", user, repo, topic), nil, nil)
-	return err
+	return resp, err
 }

gitea/repo_topics_test.go

@@ -19,34 +19,34 @@ func TestRepoTopics(t *testing.T) {
 	assert.NoError(t, err)
 
 	// Add
-	err = c.AddRepoTopic(repo.Owner.UserName, repo.Name, "best")
+	_, err = c.AddRepoTopic(repo.Owner.UserName, repo.Name, "best")
 	assert.NoError(t, err)
-	err = c.AddRepoTopic(repo.Owner.UserName, repo.Name, "git")
+	_, err = c.AddRepoTopic(repo.Owner.UserName, repo.Name, "git")
 	assert.NoError(t, err)
-	err = c.AddRepoTopic(repo.Owner.UserName, repo.Name, "gitea")
+	_, err = c.AddRepoTopic(repo.Owner.UserName, repo.Name, "gitea")
 	assert.NoError(t, err)
-	err = c.AddRepoTopic(repo.Owner.UserName, repo.Name, "drone")
+	_, err = c.AddRepoTopic(repo.Owner.UserName, repo.Name, "drone")
 	assert.NoError(t, err)
 
 	// Get List
-	tl, err := c.ListRepoTopics(repo.Owner.UserName, repo.Name, ListRepoTopicsOptions{})
+	tl, _, err := c.ListRepoTopics(repo.Owner.UserName, repo.Name, ListRepoTopicsOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, tl, 4)
 
 	// Del
-	err = c.DeleteRepoTopic(repo.Owner.UserName, repo.Name, "drone")
+	_, err = c.DeleteRepoTopic(repo.Owner.UserName, repo.Name, "drone")
 	assert.NoError(t, err)
-	err = c.DeleteRepoTopic(repo.Owner.UserName, repo.Name, "best")
+	_, err = c.DeleteRepoTopic(repo.Owner.UserName, repo.Name, "best")
 	assert.NoError(t, err)
-	tl, err = c.ListRepoTopics(repo.Owner.UserName, repo.Name, ListRepoTopicsOptions{})
+	tl, _, err = c.ListRepoTopics(repo.Owner.UserName, repo.Name, ListRepoTopicsOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, tl, 2)
 
 	// Set List
 	newTopics := []string{"analog", "digital", "cat"}
-	err = c.SetRepoTopics(repo.Owner.UserName, repo.Name, newTopics)
+	_, err = c.SetRepoTopics(repo.Owner.UserName, repo.Name, newTopics)
 	assert.NoError(t, err)
-	tl, _ = c.ListRepoTopics(repo.Owner.UserName, repo.Name, ListRepoTopicsOptions{})
+	tl, _, _ = c.ListRepoTopics(repo.Owner.UserName, repo.Name, ListRepoTopicsOptions{})
 	assert.Len(t, tl, 3)
 
 	sort.Strings(tl)

gitea/repo_transfer.go

@@ -19,14 +19,15 @@ type TransferRepoOption struct {
 }
 
 // TransferRepo transfers the ownership of a repository
-func (c *Client) TransferRepo(owner, reponame string, opt TransferRepoOption) (*Repository, error) {
+func (c *Client) TransferRepo(owner, reponame string, opt TransferRepoOption) (*Repository, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.12.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	repo := new(Repository)
-	return repo, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/transfer", owner, reponame), jsonHeader, bytes.NewReader(body), repo)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/transfer", owner, reponame), jsonHeader, bytes.NewReader(body), repo)
+	return repo, resp, err
 }

gitea/repo_transfer_test.go

@@ -15,21 +15,24 @@ func TestRepoTransfer(t *testing.T) {
 	log.Printf("== TestRepoTransfer ==")
 	c := newTestClient()
 
-	org, err := c.AdminCreateOrg(c.username, CreateOrgOption{Name: "TransferOrg"})
+	org, _, err := c.AdminCreateOrg(c.username, CreateOrgOption{Name: "TransferOrg"})
 	assert.NoError(t, err)
 	repo, err := createTestRepo(t, "ToMove", c)
 	assert.NoError(t, err)
 
-	newRepo, err := c.TransferRepo(repo.Owner.UserName, repo.Name, TransferRepoOption{NewOwner: org.UserName})
+	newRepo, _, err := c.TransferRepo(repo.Owner.UserName, repo.Name, TransferRepoOption{NewOwner: org.UserName})
 	assert.NoError(t, err)
 	assert.NotNil(t, newRepo)
 
 	repo, err = createTestRepo(t, "ToMove", c)
 	assert.NoError(t, err)
-	_, err = c.TransferRepo(repo.Owner.UserName, repo.Name, TransferRepoOption{NewOwner: org.UserName})
+	_, _, err = c.TransferRepo(repo.Owner.UserName, repo.Name, TransferRepoOption{NewOwner: org.UserName})
 	assert.Error(t, err)
 
-	assert.NoError(t, c.DeleteRepo(repo.Owner.UserName, repo.Name))
+	_, err = c.DeleteRepo(repo.Owner.UserName, repo.Name)
-	assert.NoError(t, c.DeleteRepo(newRepo.Owner.UserName, newRepo.Name))
+	assert.NoError(t, err)
-	assert.NoError(t, c.DeleteOrg(org.UserName))
+	_, err = c.DeleteRepo(newRepo.Owner.UserName, newRepo.Name)
+	assert.NoError(t, err)
+	_, err = c.DeleteOrg(org.UserName)
+	assert.NoError(t, err)
 }

gitea/repo_tree.go

@@ -30,11 +30,12 @@ type GitTreeResponse struct {
 
 // GetTrees downloads a file of repository, ref can be branch/tag/commit.
 // e.g.: ref -> master, tree -> macaron.go(no leading slash)
-func (c *Client) GetTrees(user, repo, ref string, recursive bool) (*GitTreeResponse, error) {
+func (c *Client) GetTrees(user, repo, ref string, recursive bool) (*GitTreeResponse, *Response, error) {
 	trees := new(GitTreeResponse)
 	var path = fmt.Sprintf("/repos/%s/%s/git/trees/%s", user, repo, ref)
 	if recursive {
 		path += "?recursive=1"
 	}
-	return trees, c.getParsedResponse("GET", path, nil, nil, trees)
+	resp, err := c.getParsedResponse("GET", path, nil, nil, trees)
+	return trees, resp, err
 }

gitea/repo_watch.go

@@ -21,53 +21,55 @@ type WatchInfo struct {
 }
 
 // GetWatchedRepos list all the watched repos of user
-func (c *Client) GetWatchedRepos(user string) ([]*Repository, error) {
+func (c *Client) GetWatchedRepos(user string) ([]*Repository, *Response, error) {
 	repos := make([]*Repository, 0, 10)
-	return repos, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/subscriptions", user), nil, nil, &repos)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/subscriptions", user), nil, nil, &repos)
+	return repos, resp, err
 }
 
 // GetMyWatchedRepos list repositories watched by the authenticated user
-func (c *Client) GetMyWatchedRepos() ([]*Repository, error) {
+func (c *Client) GetMyWatchedRepos() ([]*Repository, *Response, error) {
 	repos := make([]*Repository, 0, 10)
-	return repos, c.getParsedResponse("GET", fmt.Sprintf("/user/subscriptions"), nil, nil, &repos)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/subscriptions"), nil, nil, &repos)
+	return repos, resp, err
 }
 
 // CheckRepoWatch check if the current user is watching a repo
-func (c *Client) CheckRepoWatch(repoUser, repoName string) (bool, error) {
+func (c *Client) CheckRepoWatch(repoUser, repoName string) (bool, *Response, error) {
-	status, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName), nil, nil)
+	status, resp, err := c.getStatusCode("GET", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName), nil, nil)
 	if err != nil {
-		return false, err
+		return false, resp, err
 	}
 	switch status {
 	case http.StatusNotFound:
-		return false, nil
+		return false, resp, nil
 	case http.StatusOK:
-		return true, nil
+		return true, resp, nil
 	default:
-		return false, fmt.Errorf("unexpected Status: %d", status)
+		return false, resp, fmt.Errorf("unexpected Status: %d", status)
 	}
 }
 
 // WatchRepo start to watch a repository
-func (c *Client) WatchRepo(repoUser, repoName string) error {
+func (c *Client) WatchRepo(repoUser, repoName string) (*Response, error) {
-	status, err := c.getStatusCode("PUT", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName), nil, nil)
+	status, resp, err := c.getStatusCode("PUT", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName), nil, nil)
 	if err != nil {
-		return err
+		return resp, err
 	}
 	if status == http.StatusOK {
-		return nil
+		return resp, nil
 	}
-	return fmt.Errorf("unexpected Status: %d", status)
+	return resp, fmt.Errorf("unexpected Status: %d", status)
 }
 
 // UnWatchRepo stop to watch a repository
-func (c *Client) UnWatchRepo(repoUser, repoName string) error {
+func (c *Client) UnWatchRepo(repoUser, repoName string) (*Response, error) {
-	status, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName), nil, nil)
+	status, resp, err := c.getStatusCode("DELETE", fmt.Sprintf("/repos/%s/%s/subscription", repoUser, repoName), nil, nil)
 	if err != nil {
-		return err
+		return resp, err
 	}
 	if status == http.StatusNoContent {
-		return nil
+		return resp, nil
 	}
-	return fmt.Errorf("unexpected Status: %d", status)
+	return resp, fmt.Errorf("unexpected Status: %d", status)
 }

gitea/repo_watch_test.go

@@ -14,7 +14,7 @@ import (
 func TestRepoWatch(t *testing.T) {
 	log.Printf("== TestRepoWatch ==")
 	c := newTestClient()
-	rawVersion, err := c.ServerVersion()
+	rawVersion, _, err := c.ServerVersion()
 	assert.NoError(t, err)
 	assert.True(t, true, rawVersion != "")
 
@@ -23,30 +23,30 @@ func TestRepoWatch(t *testing.T) {
 	assert.NotEqual(t, repo1, repo2)
 
 	//GetWatchedRepos
-	wl, err := c.GetWatchedRepos("test01")
+	wl, _, err := c.GetWatchedRepos("test01")
 	assert.NoError(t, err)
 	assert.NotNil(t, wl)
 	maxcount := len(wl)
 
 	//GetMyWatchedRepos
-	wl, err = c.GetMyWatchedRepos()
+	wl, _, err = c.GetMyWatchedRepos()
 	assert.NoError(t, err)
 	assert.Len(t, wl, maxcount)
 
 	//CheckRepoWatch
-	isWatching, err := c.CheckRepoWatch(repo1.Owner.UserName, repo1.Name)
+	isWatching, _, err := c.CheckRepoWatch(repo1.Owner.UserName, repo1.Name)
 	assert.NoError(t, err)
 	assert.True(t, isWatching)
 
 	//UnWatchRepo
-	err = c.UnWatchRepo(repo1.Owner.UserName, repo1.Name)
+	_, err = c.UnWatchRepo(repo1.Owner.UserName, repo1.Name)
 	assert.NoError(t, err)
-	isWatching, _ = c.CheckRepoWatch(repo1.Owner.UserName, repo1.Name)
+	isWatching, _, _ = c.CheckRepoWatch(repo1.Owner.UserName, repo1.Name)
 	assert.False(t, isWatching)
 
 	//WatchRepo
-	err = c.WatchRepo(repo1.Owner.UserName, repo1.Name)
+	_, err = c.WatchRepo(repo1.Owner.UserName, repo1.Name)
 	assert.NoError(t, err)
-	isWatching, _ = c.CheckRepoWatch(repo1.Owner.UserName, repo1.Name)
+	isWatching, _, _ = c.CheckRepoWatch(repo1.Owner.UserName, repo1.Name)
 	assert.True(t, isWatching)
 }

gitea/settings.go

@@ -32,37 +32,41 @@ type GlobalAttachmentSettings struct {
 }
 
 // GetGlobalUISettings get global ui settings witch are exposed by API
-func (c *Client) GetGlobalUISettings() (settings *GlobalUISettings, err error) {
+func (c *Client) GetGlobalUISettings() (*GlobalUISettings, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	conf := new(GlobalUISettings)
-	return conf, c.getParsedResponse("GET", "/settings/ui", jsonHeader, nil, &conf)
+	resp, err := c.getParsedResponse("GET", "/settings/ui", jsonHeader, nil, &conf)
+	return conf, resp, err
 }
 
 // GetGlobalRepoSettings get global repository settings witch are exposed by API
-func (c *Client) GetGlobalRepoSettings() (settings *GlobalRepoSettings, err error) {
+func (c *Client) GetGlobalRepoSettings() (*GlobalRepoSettings, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	conf := new(GlobalRepoSettings)
-	return conf, c.getParsedResponse("GET", "/settings/repository", jsonHeader, nil, &conf)
+	resp, err := c.getParsedResponse("GET", "/settings/repository", jsonHeader, nil, &conf)
+	return conf, resp, err
 }
 
 // GetGlobalAPISettings get global api settings witch are exposed by it
-func (c *Client) GetGlobalAPISettings() (settings *GlobalAPISettings, err error) {
+func (c *Client) GetGlobalAPISettings() (*GlobalAPISettings, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	conf := new(GlobalAPISettings)
-	return conf, c.getParsedResponse("GET", "/settings/api", jsonHeader, nil, &conf)
+	resp, err := c.getParsedResponse("GET", "/settings/api", jsonHeader, nil, &conf)
+	return conf, resp, err
 }
 
 // GetGlobalAttachmentSettings get global repository settings witch are exposed by API
-func (c *Client) GetGlobalAttachmentSettings() (settings *GlobalAttachmentSettings, err error) {
+func (c *Client) GetGlobalAttachmentSettings() (*GlobalAttachmentSettings, *Response, error) {
 	if err := c.CheckServerVersionConstraint(">=1.13.0"); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	conf := new(GlobalAttachmentSettings)
-	return conf, c.getParsedResponse("GET", "/settings/attachment", jsonHeader, nil, &conf)
+	resp, err := c.getParsedResponse("GET", "/settings/attachment", jsonHeader, nil, &conf)
+	return conf, resp, err
 }

gitea/settings_test.go

@@ -15,19 +15,19 @@ func TestGetGlobalSettings(t *testing.T) {
 	log.Println("== TestGetGlobalSettings ==")
 	c := newTestClient()
 
-	uiSettings, err := c.GetGlobalUISettings()
+	uiSettings, _, err := c.GetGlobalUISettings()
 	assert.NoError(t, err)
 	expectedAllowedReactions := []string{"+1", "-1", "laugh", "hooray", "confused", "heart", "rocket", "eyes"}
 	assert.ElementsMatch(t, expectedAllowedReactions, uiSettings.AllowedReactions)
 
-	repoSettings, err := c.GetGlobalRepoSettings()
+	repoSettings, _, err := c.GetGlobalRepoSettings()
 	assert.NoError(t, err)
 	assert.EqualValues(t, &GlobalRepoSettings{
 		HTTPGitDisabled: false,
 		MirrorsDisabled: false,
 	}, repoSettings)
 
-	apiSettings, err := c.GetGlobalAPISettings()
+	apiSettings, _, err := c.GetGlobalAPISettings()
 	assert.NoError(t, err)
 	assert.EqualValues(t, &GlobalAPISettings{
 		MaxResponseItems:       50,
@@ -36,7 +36,7 @@ func TestGetGlobalSettings(t *testing.T) {
 		DefaultMaxBlobSize:     10485760,
 	}, apiSettings)
 
-	attachSettings, err := c.GetGlobalAttachmentSettings()
+	attachSettings, _, err := c.GetGlobalAttachmentSettings()
 	assert.NoError(t, err)
 	assert.EqualValues(t, &GlobalAttachmentSettings{
 		Enabled:      true,

gitea/status.go

@@ -50,13 +50,14 @@ type CreateStatusOption struct {
 }
 
 // CreateStatus creates a new Status for a given Commit
-func (c *Client) CreateStatus(owner, repo, sha string, opts CreateStatusOption) (*Status, error) {
+func (c *Client) CreateStatus(owner, repo, sha string, opts CreateStatusOption) (*Status, *Response, error) {
 	body, err := json.Marshal(&opts)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	status := new(Status)
-	return status, c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/statuses/%s", owner, repo, sha), jsonHeader, bytes.NewReader(body), status)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/repos/%s/%s/statuses/%s", owner, repo, sha), jsonHeader, bytes.NewReader(body), status)
+	return status, resp, err
 }
 
 // ListStatusesOption options for listing a repository's commit's statuses
@@ -65,10 +66,11 @@ type ListStatusesOption struct {
 }
 
 // ListStatuses returns all statuses for a given Commit
-func (c *Client) ListStatuses(owner, repo, sha string, opt ListStatusesOption) ([]*Status, error) {
+func (c *Client) ListStatuses(owner, repo, sha string, opt ListStatusesOption) ([]*Status, *Response, error) {
 	opt.setDefaults()
 	statuses := make([]*Status, 0, opt.PageSize)
-	return statuses, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/statuses?%s", owner, repo, sha, opt.getURLQuery().Encode()), nil, nil, &statuses)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/statuses?%s", owner, repo, sha, opt.getURLQuery().Encode()), nil, nil, &statuses)
+	return statuses, resp, err
 }
 
 // CombinedStatus holds the combined state of several statuses for a single commit
@@ -83,7 +85,8 @@ type CombinedStatus struct {
 }
 
 // GetCombinedStatus returns the CombinedStatus for a given Commit
-func (c *Client) GetCombinedStatus(owner, repo, sha string) (*CombinedStatus, error) {
+func (c *Client) GetCombinedStatus(owner, repo, sha string) (*CombinedStatus, *Response, error) {
 	status := new(CombinedStatus)
-	return status, c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/status", owner, repo, sha), nil, nil, status)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/repos/%s/%s/commits/%s/status", owner, repo, sha), nil, nil, status)
+	return status, resp, err
 }

gitea/user.go

@@ -29,15 +29,15 @@ type User struct {
 }
 
 // GetUserInfo get user info by user's name
-func (c *Client) GetUserInfo(user string) (*User, error) {
+func (c *Client) GetUserInfo(user string) (*User, *Response, error) {
 	u := new(User)
-	err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s", user), nil, nil, u)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s", user), nil, nil, u)
-	return u, err
+	return u, resp, err
 }
 
 // GetMyUserInfo get user info of current user
-func (c *Client) GetMyUserInfo() (*User, error) {
+func (c *Client) GetMyUserInfo() (*User, *Response, error) {
 	u := new(User)
-	err := c.getParsedResponse("GET", "/user", nil, nil, u)
+	resp, err := c.getParsedResponse("GET", "/user", nil, nil, u)
-	return u, err
+	return u, resp, err
 }

gitea/user_app.go

@@ -26,13 +26,14 @@ type ListAccessTokensOptions struct {
 }
 
 // ListAccessTokens lists all the access tokens of user
-func (c *Client) ListAccessTokens(opts ListAccessTokensOptions) ([]*AccessToken, error) {
+func (c *Client) ListAccessTokens(opts ListAccessTokensOptions) ([]*AccessToken, *Response, error) {
 	if len(c.username) == 0 {
-		return nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
+		return nil, nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
 	}
 	opts.setDefaults()
 	tokens := make([]*AccessToken, 0, opts.PageSize)
-	return tokens, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/tokens?%s", c.username, opts.getURLQuery().Encode()), jsonHeader, nil, &tokens)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/tokens?%s", c.username, opts.getURLQuery().Encode()), jsonHeader, nil, &tokens)
+	return tokens, resp, err
 }
 
 // CreateAccessTokenOption options when create access token
@@ -41,22 +42,23 @@ type CreateAccessTokenOption struct {
 }
 
 // CreateAccessToken create one access token with options
-func (c *Client) CreateAccessToken(opt CreateAccessTokenOption) (*AccessToken, error) {
+func (c *Client) CreateAccessToken(opt CreateAccessTokenOption) (*AccessToken, *Response, error) {
 	if len(c.username) == 0 {
-		return nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
+		return nil, nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
 	}
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	t := new(AccessToken)
-	return t, c.getParsedResponse("POST", fmt.Sprintf("/users/%s/tokens", c.username), jsonHeader, bytes.NewReader(body), t)
+	resp, err := c.getParsedResponse("POST", fmt.Sprintf("/users/%s/tokens", c.username), jsonHeader, bytes.NewReader(body), t)
+	return t, resp, err
 }
 
 // DeleteAccessToken delete token, identified by ID and if not available by name
-func (c *Client) DeleteAccessToken(value interface{}) error {
+func (c *Client) DeleteAccessToken(value interface{}) (*Response, error) {
 	if len(c.username) == 0 {
-		return fmt.Errorf("\"username\" not set: only BasicAuth allowed")
+		return nil, fmt.Errorf("\"username\" not set: only BasicAuth allowed")
 	}
 
 	var token = ""
@@ -66,13 +68,13 @@ func (c *Client) DeleteAccessToken(value interface{}) error {
 		token = fmt.Sprintf("%d", value.(int64))
 	case reflect.String:
 		if err := c.CheckServerVersionConstraint(">= 1.13.0"); err != nil {
-			return err
+			return nil, err
 		}
 		token = value.(string)
 	default:
-		return fmt.Errorf("only string and int64 supported")
+		return nil, fmt.Errorf("only string and int64 supported")
 	}
 
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/users/%s/tokens/%s", c.username, token), jsonHeader, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/users/%s/tokens/%s", c.username, token), jsonHeader, nil)
-	return err
+	return resp, err
 }

gitea/user_email.go

@@ -23,10 +23,11 @@ type ListEmailsOptions struct {
 }
 
 // ListEmails all the email addresses of user
-func (c *Client) ListEmails(opt ListEmailsOptions) ([]*Email, error) {
+func (c *Client) ListEmails(opt ListEmailsOptions) ([]*Email, *Response, error) {
 	opt.setDefaults()
 	emails := make([]*Email, 0, opt.PageSize)
-	return emails, c.getParsedResponse("GET", fmt.Sprintf("/user/emails?%s", opt.getURLQuery().Encode()), nil, nil, &emails)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/emails?%s", opt.getURLQuery().Encode()), nil, nil, &emails)
+	return emails, resp, err
 }
 
 // CreateEmailOption options when creating email addresses
@@ -36,13 +37,14 @@ type CreateEmailOption struct {
 }
 
 // AddEmail add one email to current user with options
-func (c *Client) AddEmail(opt CreateEmailOption) ([]*Email, error) {
+func (c *Client) AddEmail(opt CreateEmailOption) ([]*Email, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	emails := make([]*Email, 0, 3)
-	return emails, c.getParsedResponse("POST", "/user/emails", jsonHeader, bytes.NewReader(body), &emails)
+	resp, err := c.getParsedResponse("POST", "/user/emails", jsonHeader, bytes.NewReader(body), &emails)
+	return emails, resp, err
 }
 
 // DeleteEmailOption options when deleting email addresses
@@ -52,11 +54,11 @@ type DeleteEmailOption struct {
 }
 
 // DeleteEmail delete one email of current users'
-func (c *Client) DeleteEmail(opt DeleteEmailOption) error {
+func (c *Client) DeleteEmail(opt DeleteEmailOption) (*Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	_, err = c.getResponse("DELETE", "/user/emails", jsonHeader, bytes.NewReader(body))
+	_, resp, err := c.getResponse("DELETE", "/user/emails", jsonHeader, bytes.NewReader(body))
-	return err
+	return resp, err
 }

gitea/user_follow.go

@@ -12,17 +12,19 @@ type ListFollowersOptions struct {
 }
 
 // ListMyFollowers list all the followers of current user
-func (c *Client) ListMyFollowers(opt ListFollowersOptions) ([]*User, error) {
+func (c *Client) ListMyFollowers(opt ListFollowersOptions) ([]*User, *Response, error) {
 	opt.setDefaults()
 	users := make([]*User, 0, opt.PageSize)
-	return users, c.getParsedResponse("GET", fmt.Sprintf("/user/followers?%s", opt.getURLQuery().Encode()), nil, nil, &users)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/followers?%s", opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
 }
 
 // ListFollowers list all the followers of one user
-func (c *Client) ListFollowers(user string, opt ListFollowersOptions) ([]*User, error) {
+func (c *Client) ListFollowers(user string, opt ListFollowersOptions) ([]*User, *Response, error) {
 	opt.setDefaults()
 	users := make([]*User, 0, opt.PageSize)
-	return users, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/followers?%s", user, opt.getURLQuery().Encode()), nil, nil, &users)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/followers?%s", user, opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
 }
 
 // ListFollowingOptions options for listing a user's users being followed
@@ -31,39 +33,41 @@ type ListFollowingOptions struct {
 }
 
 // ListMyFollowing list all the users current user followed
-func (c *Client) ListMyFollowing(opt ListFollowingOptions) ([]*User, error) {
+func (c *Client) ListMyFollowing(opt ListFollowingOptions) ([]*User, *Response, error) {
 	opt.setDefaults()
 	users := make([]*User, 0, opt.PageSize)
-	return users, c.getParsedResponse("GET", fmt.Sprintf("/user/following?%s", opt.getURLQuery().Encode()), nil, nil, &users)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/following?%s", opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
 }
 
 // ListFollowing list all the users the user followed
-func (c *Client) ListFollowing(user string, opt ListFollowingOptions) ([]*User, error) {
+func (c *Client) ListFollowing(user string, opt ListFollowingOptions) ([]*User, *Response, error) {
 	opt.setDefaults()
 	users := make([]*User, 0, opt.PageSize)
-	return users, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/following?%s", user, opt.getURLQuery().Encode()), nil, nil, &users)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/following?%s", user, opt.getURLQuery().Encode()), nil, nil, &users)
+	return users, resp, err
 }
 
 // IsFollowing if current user followed the target
-func (c *Client) IsFollowing(target string) bool {
+func (c *Client) IsFollowing(target string) (bool, *Response) {
-	_, err := c.getResponse("GET", fmt.Sprintf("/user/following/%s", target), nil, nil)
+	_, resp, err := c.getResponse("GET", fmt.Sprintf("/user/following/%s", target), nil, nil)
-	return err == nil
+	return err == nil, resp
 }
 
 // IsUserFollowing if the user followed the target
-func (c *Client) IsUserFollowing(user, target string) bool {
+func (c *Client) IsUserFollowing(user, target string) (bool, *Response) {
-	_, err := c.getResponse("GET", fmt.Sprintf("/users/%s/following/%s", user, target), nil, nil)
+	_, resp, err := c.getResponse("GET", fmt.Sprintf("/users/%s/following/%s", user, target), nil, nil)
-	return err == nil
+	return err == nil, resp
 }
 
 // Follow set current user follow the target
-func (c *Client) Follow(target string) error {
+func (c *Client) Follow(target string) (*Response, error) {
-	_, err := c.getResponse("PUT", fmt.Sprintf("/user/following/%s", target), nil, nil)
+	_, resp, err := c.getResponse("PUT", fmt.Sprintf("/user/following/%s", target), nil, nil)
-	return err
+	return resp, err
 }
 
 // Unfollow set current user unfollow the target
-func (c *Client) Unfollow(target string) error {
+func (c *Client) Unfollow(target string) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/user/following/%s", target), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/user/following/%s", target), nil, nil)
-	return err
+	return resp, err
 }

gitea/user_gpgkey.go

@@ -39,23 +39,26 @@ type ListGPGKeysOptions struct {
 }
 
 // ListGPGKeys list all the GPG keys of the user
-func (c *Client) ListGPGKeys(user string, opt ListGPGKeysOptions) ([]*GPGKey, error) {
+func (c *Client) ListGPGKeys(user string, opt ListGPGKeysOptions) ([]*GPGKey, *Response, error) {
 	opt.setDefaults()
 	keys := make([]*GPGKey, 0, opt.PageSize)
-	return keys, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/gpg_keys?%s", user, opt.getURLQuery().Encode()), nil, nil, &keys)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/gpg_keys?%s", user, opt.getURLQuery().Encode()), nil, nil, &keys)
+	return keys, resp, err
 }
 
 // ListMyGPGKeys list all the GPG keys of current user
-func (c *Client) ListMyGPGKeys(opt *ListGPGKeysOptions) ([]*GPGKey, error) {
+func (c *Client) ListMyGPGKeys(opt *ListGPGKeysOptions) ([]*GPGKey, *Response, error) {
 	opt.setDefaults()
 	keys := make([]*GPGKey, 0, opt.PageSize)
-	return keys, c.getParsedResponse("GET", fmt.Sprintf("/user/gpg_keys?%s", opt.getURLQuery().Encode()), nil, nil, &keys)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/gpg_keys?%s", opt.getURLQuery().Encode()), nil, nil, &keys)
+	return keys, resp, err
 }
 
 // GetGPGKey get current user's GPG key by key id
-func (c *Client) GetGPGKey(keyID int64) (*GPGKey, error) {
+func (c *Client) GetGPGKey(keyID int64) (*GPGKey, *Response, error) {
 	key := new(GPGKey)
-	return key, c.getParsedResponse("GET", fmt.Sprintf("/user/gpg_keys/%d", keyID), nil, nil, &key)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/gpg_keys/%d", keyID), nil, nil, &key)
+	return key, resp, err
 }
 
 // CreateGPGKeyOption options create user GPG key
@@ -66,17 +69,18 @@ type CreateGPGKeyOption struct {
 }
 
 // CreateGPGKey create GPG key with options
-func (c *Client) CreateGPGKey(opt CreateGPGKeyOption) (*GPGKey, error) {
+func (c *Client) CreateGPGKey(opt CreateGPGKeyOption) (*GPGKey, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	key := new(GPGKey)
-	return key, c.getParsedResponse("POST", "/user/gpg_keys", jsonHeader, bytes.NewReader(body), key)
+	resp, err := c.getParsedResponse("POST", "/user/gpg_keys", jsonHeader, bytes.NewReader(body), key)
+	return key, resp, err
 }
 
 // DeleteGPGKey delete GPG key with key id
-func (c *Client) DeleteGPGKey(keyID int64) error {
+func (c *Client) DeleteGPGKey(keyID int64) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/user/gpg_keys/%d", keyID), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/user/gpg_keys/%d", keyID), nil, nil)
-	return err
+	return resp, err
 }

gitea/user_key.go

@@ -30,23 +30,26 @@ type ListPublicKeysOptions struct {
 }
 
 // ListPublicKeys list all the public keys of the user
-func (c *Client) ListPublicKeys(user string, opt ListPublicKeysOptions) ([]*PublicKey, error) {
+func (c *Client) ListPublicKeys(user string, opt ListPublicKeysOptions) ([]*PublicKey, *Response, error) {
 	opt.setDefaults()
 	keys := make([]*PublicKey, 0, opt.PageSize)
-	return keys, c.getParsedResponse("GET", fmt.Sprintf("/users/%s/keys?%s", user, opt.getURLQuery().Encode()), nil, nil, &keys)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/users/%s/keys?%s", user, opt.getURLQuery().Encode()), nil, nil, &keys)
+	return keys, resp, err
 }
 
 // ListMyPublicKeys list all the public keys of current user
-func (c *Client) ListMyPublicKeys(opt ListPublicKeysOptions) ([]*PublicKey, error) {
+func (c *Client) ListMyPublicKeys(opt ListPublicKeysOptions) ([]*PublicKey, *Response, error) {
 	opt.setDefaults()
 	keys := make([]*PublicKey, 0, opt.PageSize)
-	return keys, c.getParsedResponse("GET", fmt.Sprintf("/user/keys?%s", opt.getURLQuery().Encode()), nil, nil, &keys)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/keys?%s", opt.getURLQuery().Encode()), nil, nil, &keys)
+	return keys, resp, err
 }
 
 // GetPublicKey get current user's public key by key id
-func (c *Client) GetPublicKey(keyID int64) (*PublicKey, error) {
+func (c *Client) GetPublicKey(keyID int64) (*PublicKey, *Response, error) {
 	key := new(PublicKey)
-	return key, c.getParsedResponse("GET", fmt.Sprintf("/user/keys/%d", keyID), nil, nil, &key)
+	resp, err := c.getParsedResponse("GET", fmt.Sprintf("/user/keys/%d", keyID), nil, nil, &key)
+	return key, resp, err
 }
 
 // CreateKeyOption options when creating a key
@@ -60,17 +63,18 @@ type CreateKeyOption struct {
 }
 
 // CreatePublicKey create public key with options
-func (c *Client) CreatePublicKey(opt CreateKeyOption) (*PublicKey, error) {
+func (c *Client) CreatePublicKey(opt CreateKeyOption) (*PublicKey, *Response, error) {
 	body, err := json.Marshal(&opt)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	key := new(PublicKey)
-	return key, c.getParsedResponse("POST", "/user/keys", jsonHeader, bytes.NewReader(body), key)
+	resp, err := c.getParsedResponse("POST", "/user/keys", jsonHeader, bytes.NewReader(body), key)
+	return key, resp, err
 }
 
 // DeletePublicKey delete public key with key id
-func (c *Client) DeletePublicKey(keyID int64) error {
+func (c *Client) DeletePublicKey(keyID int64) (*Response, error) {
-	_, err := c.getResponse("DELETE", fmt.Sprintf("/user/keys/%d", keyID), nil, nil)
+	_, resp, err := c.getResponse("DELETE", fmt.Sprintf("/user/keys/%d", keyID), nil, nil)
-	return err
+	return resp, err
 }

gitea/user_search.go

@@ -35,10 +35,10 @@ func (opt *SearchUsersOption) QueryEncode() string {
 }
 
 // SearchUsers finds users by query
-func (c *Client) SearchUsers(opt SearchUsersOption) ([]*User, error) {
+func (c *Client) SearchUsers(opt SearchUsersOption) ([]*User, *Response, error) {
 	link, _ := url.Parse("/users/search")
 	link.RawQuery = opt.QueryEncode()
-	resp := new(searchUsersResponse)
+	userResp := new(searchUsersResponse)
-	err := c.getParsedResponse("GET", link.String(), nil, nil, &resp)
+	resp, err := c.getParsedResponse("GET", link.String(), nil, nil, &userResp)
-	return resp.Users, err
+	return userResp.Users, resp, err
 }

gitea/user_test.go

@@ -14,7 +14,7 @@ import (
 func TestMyUser(t *testing.T) {
 	log.Println("== TestMyUser ==")
 	c := newTestClient()
-	user, err := c.GetMyUserInfo()
+	user, _, err := c.GetMyUserInfo()
 	assert.NoError(t, err)
 
 	assert.EqualValues(t, 1, user.ID)
@@ -29,20 +29,20 @@ func TestUserApp(t *testing.T) {
 	log.Println("== TestUserApp ==")
 	c := newTestClient()
 
-	result, err := c.ListAccessTokens(ListAccessTokensOptions{})
+	result, _, err := c.ListAccessTokens(ListAccessTokensOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, result, 1)
 	assert.EqualValues(t, "gitea-admin", result[0].Name)
 
-	t1, err := c.CreateAccessToken(CreateAccessTokenOption{Name: "TestCreateAccessToken"})
+	t1, _, err := c.CreateAccessToken(CreateAccessTokenOption{Name: "TestCreateAccessToken"})
 	assert.NoError(t, err)
 	assert.EqualValues(t, "TestCreateAccessToken", t1.Name)
-	result, _ = c.ListAccessTokens(ListAccessTokensOptions{})
+	result, _, _ = c.ListAccessTokens(ListAccessTokensOptions{})
 	assert.Len(t, result, 2)
 
-	err = c.DeleteAccessToken(t1.ID)
+	_, err = c.DeleteAccessToken(t1.ID)
 	assert.NoError(t, err)
-	result, _ = c.ListAccessTokens(ListAccessTokensOptions{})
+	result, _, _ = c.ListAccessTokens(ListAccessTokensOptions{})
 	assert.Len(t, result, 1)
 }
 
@@ -57,15 +57,15 @@ func TestUserSearch(t *testing.T) {
 	createTestUser(t, "1n2n3n", c)
 	createTestUser(t, "otherIt", c)
 
-	ul, err := c.SearchUsers(SearchUsersOption{KeyWord: "other"})
+	ul, _, err := c.SearchUsers(SearchUsersOption{KeyWord: "other"})
 	assert.NoError(t, err)
 	assert.Len(t, ul, 1)
 
-	ul, err = c.SearchUsers(SearchUsersOption{KeyWord: "notInTESTcase"})
+	ul, _, err = c.SearchUsers(SearchUsersOption{KeyWord: "notInTESTcase"})
 	assert.NoError(t, err)
 	assert.Len(t, ul, 0)
 
-	ul, err = c.SearchUsers(SearchUsersOption{KeyWord: "It"})
+	ul, _, err = c.SearchUsers(SearchUsersOption{KeyWord: "It"})
 	assert.NoError(t, err)
 	assert.Len(t, ul, 2)
 }
@@ -73,7 +73,7 @@ func TestUserSearch(t *testing.T) {
 func TestUserFollow(t *testing.T) {
 	log.Println("== TestUserFollow ==")
 	c := newTestClient()
-	me, _ := c.GetMyUserInfo()
+	me, _, _ := c.GetMyUserInfo()
 
 	uA := "uFollow_A"
 	uB := "uFollow_B"
@@ -86,49 +86,51 @@ func TestUserFollow(t *testing.T) {
 	// B follow C & ME
 	// C follow A & B & ME
 	c.sudo = uA
-	err := c.Follow(me.UserName)
+	_, err := c.Follow(me.UserName)
 	assert.NoError(t, err)
 	c.sudo = uB
-	err = c.Follow(me.UserName)
+	_, err = c.Follow(me.UserName)
 	assert.NoError(t, err)
-	err = c.Follow(uC)
+	_, err = c.Follow(uC)
 	assert.NoError(t, err)
 	c.sudo = uC
-	err = c.Follow(me.UserName)
+	_, err = c.Follow(me.UserName)
 	assert.NoError(t, err)
-	err = c.Follow(uA)
+	_, err = c.Follow(uA)
 	assert.NoError(t, err)
-	err = c.Follow(uB)
+	_, err = c.Follow(uB)
 	assert.NoError(t, err)
 
 	// C unfollow me
-	err = c.Unfollow(me.UserName)
+	_, err = c.Unfollow(me.UserName)
 	assert.NoError(t, err)
 
 	// ListMyFollowers of me
 	c.sudo = ""
-	f, err := c.ListMyFollowers(ListFollowersOptions{})
+	f, _, err := c.ListMyFollowers(ListFollowersOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, f, 2)
 
 	// ListFollowers of A
-	f, err = c.ListFollowers(uA, ListFollowersOptions{})
+	f, _, err = c.ListFollowers(uA, ListFollowersOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, f, 1)
 
 	// ListMyFollowing of me
-	f, err = c.ListMyFollowing(ListFollowingOptions{})
+	f, _, err = c.ListMyFollowing(ListFollowingOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, f, 0)
 
 	// ListFollowing of A
-	f, err = c.ListFollowing(uA, ListFollowingOptions{})
+	f, _, err = c.ListFollowing(uA, ListFollowingOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, f, 1)
 	assert.EqualValues(t, me.ID, f[0].ID)
 
-	assert.False(t, c.IsFollowing(uA))
+	isFollow, _ := c.IsFollowing(uA)
-	assert.True(t, c.IsUserFollowing(uB, uC))
+	assert.False(t, isFollow)
+	isFollow, _ = c.IsUserFollowing(uB, uC)
+	assert.True(t, isFollow)
 }
 
 func TestUserEmail(t *testing.T) {
@@ -139,7 +141,7 @@ func TestUserEmail(t *testing.T) {
 	c.sudo = userN
 
 	// ListEmails
-	el, err := c.ListEmails(ListEmailsOptions{})
+	el, _, err := c.ListEmails(ListEmailsOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, el, 1)
 	assert.EqualValues(t, "testuseremail@gitea.io", el[0].Email)
@@ -147,35 +149,35 @@ func TestUserEmail(t *testing.T) {
 
 	// AddEmail
 	mails := []string{"wow@mail.send", "speed@mail.me"}
-	el, err = c.AddEmail(CreateEmailOption{Emails: mails})
+	el, _, err = c.AddEmail(CreateEmailOption{Emails: mails})
 	assert.NoError(t, err)
 	assert.Len(t, el, 2)
-	_, err = c.AddEmail(CreateEmailOption{Emails: []string{mails[1]}})
+	_, _, err = c.AddEmail(CreateEmailOption{Emails: []string{mails[1]}})
 	assert.Error(t, err)
-	el, err = c.ListEmails(ListEmailsOptions{})
+	el, _, err = c.ListEmails(ListEmailsOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, el, 3)
 
 	// DeleteEmail
-	err = c.DeleteEmail(DeleteEmailOption{Emails: []string{mails[1]}})
+	_, err = c.DeleteEmail(DeleteEmailOption{Emails: []string{mails[1]}})
 	assert.NoError(t, err)
-	err = c.DeleteEmail(DeleteEmailOption{Emails: []string{"imaginary@e.de"}})
+	_, err = c.DeleteEmail(DeleteEmailOption{Emails: []string{"imaginary@e.de"}})
 	assert.Error(t, err)
 
-	el, err = c.ListEmails(ListEmailsOptions{})
+	el, _, err = c.ListEmails(ListEmailsOptions{})
 	assert.NoError(t, err)
 	assert.Len(t, el, 2)
-	err = c.DeleteEmail(DeleteEmailOption{Emails: []string{mails[0]}})
+	_, err = c.DeleteEmail(DeleteEmailOption{Emails: []string{mails[0]}})
 	assert.NoError(t, err)
 }
 
 func createTestUser(t *testing.T, username string, client *Client) *User {
 	bFalse := false
-	user, _ := client.GetUserInfo(username)
+	user, _, _ := client.GetUserInfo(username)
 	if user.ID != 0 {
 		return user
 	}
-	user, err := client.AdminCreateUser(CreateUserOption{Username: username, Password: username + "!1234", Email: username + "@gitea.io", MustChangePassword: &bFalse, SendNotify: bFalse})
+	user, _, err := client.AdminCreateUser(CreateUserOption{Username: username, Password: username + "!1234", Email: username + "@gitea.io", MustChangePassword: &bFalse, SendNotify: bFalse})
 	assert.NoError(t, err)
 	return user
 }

gitea/version.go

@@ -11,11 +11,12 @@ import (
 )
 
 // ServerVersion returns the version of the server
-func (c *Client) ServerVersion() (string, error) {
+func (c *Client) ServerVersion() (string, *Response, error) {
 	var v = struct {
 		Version string `json:"version"`
 	}{}
-	return v.Version, c.getParsedResponse("GET", "/version", nil, nil, &v)
+	resp, err := c.getParsedResponse("GET", "/version", nil, nil, &v)
+	return v.Version, resp, err
 }
 
 // CheckServerVersionConstraint validates that the login's server satisfies a
@@ -46,7 +47,7 @@ func (c *Client) loadClientServerVersion() error {
 	c.versionLock.Lock()
 	defer c.versionLock.Unlock()
 
-	raw, err := c.ServerVersion()
+	raw, _, err := c.ServerVersion()
 	if err != nil {
 		return err
 	}

gitea/version_test.go

@@ -14,7 +14,7 @@ import (
 func TestVersion(t *testing.T) {
 	log.Printf("== TestVersion ==")
 	c := newTestClient()
-	rawVersion, err := c.ServerVersion()
+	rawVersion, _, err := c.ServerVersion()
 	assert.NoError(t, err)
 	assert.True(t, true, rawVersion != "")