diff --git a/qiita/access_token.go b/qiita/access_token.go
index d69a48b..931d79a 100755
--- a/qiita/access_token.go
+++ b/qiita/access_token.go
@@ -11,13 +11,13 @@ import (
 
 // Access token for Qiita API v2
 type AccessToken struct {
-	ClientId string   `json:"client_id"`
+	ClientID string   `json:"client_id"`
 	Scopes   []string `json:"scopes"`
 	Token    string   `json:"token"`
 }
 
 type Auth struct {
-	ClientId     string `json:"client_id"`
+	ClientID     string `json:"client_id"`
 	ClientSecret string `json:"client_secret"`
 	Code         string `json:"code"`
 }
@@ -28,8 +28,11 @@ type Auth struct {
 	POST /api/v2/access_tokens
 */
 func (c *Client) CreateAccessToken(ctx context.Context, auth Auth) error {
-	b, _ := json.Marshal(auth)
-	res, err := c.post(ctx, "/api/v2/access_tokens", bytes.NewBuffer(b))
+	b, err := json.Marshal(auth)
+	if err != nil {
+		return err
+	}
+	res, err := c.post(ctx, "access_tokens", bytes.NewBuffer(b))
 	if err != nil {
 		return err
 	}
@@ -45,7 +48,7 @@ func (c *Client) CreateAccessToken(ctx context.Context, auth Auth) error {
 	Deactivate an access token.
 */
 func (c *Client) DeleteAccessToken(ctx context.Context, accessToken string) error {
-	p := fmt.Sprintf("/api/v2/access_tokens/%s", accessToken)
+	p := fmt.Sprintf("access_tokens/%s", accessToken)
 	res, err := c.delete(ctx, p)
 	if err != nil {
 		return err
diff --git a/qiita/access_token_test.go b/qiita/access_token_test.go
index b148e5d..e7bb91d 100755
--- a/qiita/access_token_test.go
+++ b/qiita/access_token_test.go
@@ -7,62 +7,62 @@ import (
 	"testing"
 )
 
-func TestCreateAccessToken(t *testing.T) {
-	// 201
-	func() {
+func TestClient_CreateAccessToken(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusCreated)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.CreateAccessToken(ctx, Auth{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.CreateAccessToken(ctx, Auth{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestDeleteAccessToken(t *testing.T) {
-	// 204
-	func() {
+func TestClient_DeleteAccessToken(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteAccessToken(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteAccessToken(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
diff --git a/qiita/authenticated_user.go b/qiita/authenticated_user.go
index 55b2b82..2d3fbd5 100755
--- a/qiita/authenticated_user.go
+++ b/qiita/authenticated_user.go
@@ -20,7 +20,7 @@ type AuthenticatedUser struct {
 	GET /api/v2/authenticated_user
 */
 func (c *Client) GetAuthenticatedUser(ctx context.Context) (*AuthenticatedUser, error) {
-	res, err := c.get(ctx, "/api/v2/authenticated_user", nil)
+	res, err := c.get(ctx, "authenticated_user", nil)
 	if err != nil {
 		return nil, err
 	}
diff --git a/qiita/authenticated_user_test.go b/qiita/authenticated_user_test.go
index 967e9b8..ad159fe 100755
--- a/qiita/authenticated_user_test.go
+++ b/qiita/authenticated_user_test.go
@@ -7,32 +7,32 @@ import (
 	"testing"
 )
 
-func TestGetAuthenticatedUser(t *testing.T) {
-	// 200
-	func() {
+func TestClient_GetAuthenticatedUser(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/get_authenticated_user.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetAuthenticatedUser(ctx)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/get_authenticated_user.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetAuthenticatedUser(ctx)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
diff --git a/qiita/client.go b/qiita/client.go
index 0548c7b..419c83a 100755
--- a/qiita/client.go
+++ b/qiita/client.go
@@ -51,6 +51,18 @@ func decodeBody(res *http.Response, out interface{}) error {
 	return decoder.Decode(out)
 }
 
+func rawQuery(query map[string]interface{}) *string {
+	values := url.Values{}
+	for k, v := range query {
+		value := fmt.Sprint(v)
+		if value != "" {
+			values.Add(k, value)
+		}
+	}
+	q := values.Encode()
+	return &q
+}
+
 func (c *Client) url(endpoint string) string {
 	u := *c.URL
 	u.Path = path.Join(c.URL.Path, endpoint)
@@ -63,42 +75,43 @@ func (c *Client) do(ctx context.Context, req *http.Request) (*http.Response, err
 	return c.HTTPClient.Do(req)
 }
 
-func (c *Client) get(ctx context.Context, endpoint string, rawQuery *string) (*http.Response, error) {
+func (c *Client) get(ctx context.Context, endpoint string, q map[string]interface{}) (*http.Response, error) {
 	req, err := http.NewRequest(http.MethodGet, c.url(endpoint), nil)
-	if rawQuery != nil {
-		req.URL.RawQuery = *rawQuery
-	}
 	if err != nil {
 		return nil, err
 	}
+	query := rawQuery(q)
+	if query != nil {
+		req.URL.RawQuery = *query
+	}
 	return c.do(ctx, req)
 }
 
-func (client *Client) post(ctx context.Context, endpoint string, body io.Reader) (*http.Response, error) {
-	req, err := http.NewRequest(http.MethodPost, client.url(endpoint), body)
+func (c *Client) post(ctx context.Context, endpoint string, body io.Reader) (*http.Response, error) {
+	req, err := http.NewRequest(http.MethodPost, c.url(endpoint), body)
 	if err != nil {
 		return nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
-	return client.do(ctx, req)
+	return c.do(ctx, req)
 }
 
-func (client *Client) patch(ctx context.Context, endpoint string, body io.Reader) (*http.Response, error) {
-	req, err := http.NewRequest(http.MethodPatch, client.url(endpoint), body)
+func (c *Client) patch(ctx context.Context, endpoint string, body io.Reader) (*http.Response, error) {
+	req, err := http.NewRequest(http.MethodPatch, c.url(endpoint), body)
 	if err != nil {
 		return nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
-	return client.do(ctx, req)
+	return c.do(ctx, req)
 }
 
-func (client *Client) put(ctx context.Context, endpoint string, body io.Reader) (*http.Response, error) {
-	req, err := http.NewRequest(http.MethodPut, client.url(endpoint), body)
+func (c *Client) put(ctx context.Context, endpoint string, body io.Reader) (*http.Response, error) {
+	req, err := http.NewRequest(http.MethodPut, c.url(endpoint), body)
 	if err != nil {
 		return nil, err
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
-	return client.do(ctx, req)
+	return c.do(ctx, req)
 }
 
 func (c *Client) delete(ctx context.Context, endpoint string) (*http.Response, error) {
diff --git a/qiita/comment.go b/qiita/comment.go
index c2a0aba..3f5b07a 100755
--- a/qiita/comment.go
+++ b/qiita/comment.go
@@ -13,7 +13,7 @@ import (
 type Comment struct {
 	Body         string `json:"body"`
 	CreatedAt    string `json:"created_at,omitempty"`
-	Id           string `json:"id,omitempty"`
+	ID           string `json:"id,omitempty"`
 	RenderedBody string `json:"rendered_body,omitempty"`
 	UpdatedAt    string `json:"updated_at,omitempty"`
 	User         User   `json:"user,omitempty"`
@@ -26,8 +26,8 @@ type Comments []Comment
 
 	DELETE /api/v2/comments/:comment_id
 */
-func (c *Client) DeleteComment(ctx context.Context, commentId string) error {
-	p := fmt.Sprintf("/api/v2/comments/%s", commentId)
+func (c *Client) DeleteComment(ctx context.Context, commentID string) error {
+	p := fmt.Sprintf("comments/%s", commentID)
 	res, err := c.delete(ctx, p)
 	if err != nil {
 		return err
@@ -43,8 +43,8 @@ func (c *Client) DeleteComment(ctx context.Context, commentId string) error {
 
 	GET /api/v2/comments/:comment_id
 */
-func (c *Client) GetComment(ctx context.Context, commentId string) (*Comment, error) {
-	p := fmt.Sprintf("/api/v2/comments/%s", commentId)
+func (c *Client) GetComment(ctx context.Context, commentID string) (*Comment, error) {
+	p := fmt.Sprintf("comments/%s", commentID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return nil, err
@@ -65,8 +65,11 @@ func (c *Client) GetComment(ctx context.Context, commentId string) (*Comment, er
 	PATCH /api/v2/comments/:comment_id
 */
 func (c *Client) UpdateComment(ctx context.Context, comment Comment) error {
-	b, _ := json.Marshal(comment)
-	p := fmt.Sprintf("/api/v2/comments/%s", comment.Id)
+	b, err := json.Marshal(comment)
+	if err != nil {
+		return err
+	}
+	p := fmt.Sprintf("comments/%s", comment.ID)
 	res, err := c.patch(ctx, p, bytes.NewBuffer(b))
 	if err != nil {
 		return err
@@ -82,8 +85,8 @@ func (c *Client) UpdateComment(ctx context.Context, comment Comment) error {
 
 	List comments on an item in newest order.
 */
-func (c *Client) ListComments(ctx context.Context, itemId string) (*Comments, error) {
-	p := fmt.Sprintf("/api/v2/items/%s/comments", itemId)
+func (c *Client) ListComments(ctx context.Context, itemID string) (*Comments, error) {
+	p := fmt.Sprintf("items/%s/comments", itemID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return nil, err
@@ -103,9 +106,12 @@ func (c *Client) ListComments(ctx context.Context, itemId string) (*Comments, er
 
 	POST /api/v2/items/:item_id/comments
 */
-func (c *Client) PostComment(ctx context.Context, itemId string, comment Comment) error {
-	b, _ := json.Marshal(comment)
-	p := fmt.Sprintf("/api/v2/items/%s/comments", itemId)
+func (c *Client) PostComment(ctx context.Context, itemID string, comment Comment) error {
+	b, err := json.Marshal(comment)
+	if err != nil {
+		return err
+	}
+	p := fmt.Sprintf("items/%s/comments", itemID)
 	res, err := c.post(ctx, p, bytes.NewBuffer(b))
 	if err != nil {
 		return err
diff --git a/qiita/comment_test.go b/qiita/comment_test.go
index 262771f..df963d1 100755
--- a/qiita/comment_test.go
+++ b/qiita/comment_test.go
@@ -7,152 +7,152 @@ import (
 	"testing"
 )
 
-func TestDeleteComment(t *testing.T) {
-	// 204
-	func() {
+func TestClient_DeleteComment(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteComment(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteComment(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestGetComment(t *testing.T) {
-	// 200
-	func() {
+func TestClient_GetComment(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/get_comment.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetComment(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/get_comment.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetComment(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestUpdateComment(t *testing.T) {
-	// 200
-	func() {
+func TestClient_UpdateComment(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UpdateComment(ctx, Comment{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UpdateComment(ctx, Comment{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestListComments(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListComments(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_comments.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListComments(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_comments.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListComments(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestPostComment(t *testing.T) {
-	// 201
-	func() {
+func TestClient_PostComment(t *testing.T) {
+	t.Run("201", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusCreated)
 			http.ServeFile(w, r, "testdata/post_comment.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.PostComment(ctx, "", Comment{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/post_comment.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.PostComment(ctx, "", Comment{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
diff --git a/qiita/config.go b/qiita/config.go
index ad8c69c..178c7d9 100755
--- a/qiita/config.go
+++ b/qiita/config.go
@@ -6,7 +6,7 @@ type Config struct {
 
 // APIEndpoint constants
 const (
-	APIEndpointBase = "http://qiita.com"
+	APIEndpointBase = "http://qiita.com/api/v2"
 )
 
 func NewConfig() *Config {
diff --git a/qiita/emoji_reaction.go b/qiita/emoji_reaction.go
index 1c46208..2f66736 100755
--- a/qiita/emoji_reaction.go
+++ b/qiita/emoji_reaction.go
@@ -11,10 +11,10 @@ import (
 
 // An emoji reaction.
 type Reaction struct {
-	CreatedAt string `json:"created_at,omitemoty"`
-	ImageUrl  string `json:"image_url,omitemoty"`
+	CreatedAt string `json:"created_at,omitempty"`
+	ImageURL  string `json:"image_url,omitempty"`
 	Name      string `json:"name"`
-	User      User   `json:"user,omitemoty"`
+	User      User   `json:"user,omitempty"`
 }
 
 type Reactions []Reaction
@@ -24,9 +24,12 @@ type Reactions []Reaction
 
 	POST /api/v2/comments/:comment_id/reactions
 */
-func (c *Client) AddCommentReaction(ctx context.Context, commentId string, reaction Reaction) error {
-	b, _ := json.Marshal(reaction)
-	p := fmt.Sprintf("/api/v2/comments/%s/reactions", commentId)
+func (c *Client) AddCommentReaction(ctx context.Context, commentID string, reaction Reaction) error {
+	b, err := json.Marshal(reaction)
+	if err != nil {
+		return err
+	}
+	p := fmt.Sprintf("comments/%s/reactions", commentID)
 	res, err := c.post(ctx, p, bytes.NewBuffer(b))
 	if err != nil {
 		return err
@@ -42,9 +45,12 @@ func (c *Client) AddCommentReaction(ctx context.Context, commentId string, react
 
 	POST /api/v2/items/:item_id/reactions
 */
-func (c *Client) AddItemReaction(ctx context.Context, itemId string, reaction Reaction) error {
-	b, _ := json.Marshal(reaction)
-	p := fmt.Sprintf("/api/v2/items/%s/reactions", itemId)
+func (c *Client) AddItemReaction(ctx context.Context, itemID string, reaction Reaction) error {
+	b, err := json.Marshal(reaction)
+	if err != nil {
+		return err
+	}
+	p := fmt.Sprintf("items/%s/reactions", itemID)
 	res, err := c.post(ctx, p, bytes.NewBuffer(b))
 	if err != nil {
 		return err
@@ -60,9 +66,12 @@ func (c *Client) AddItemReaction(ctx context.Context, itemId string, reaction Re
 
 	POST /api/v2/projects/:project_id/reactions
 */
-func (c *Client) AddProjectReaction(ctx context.Context, projectId uint, reaction Reaction) error {
-	b, _ := json.Marshal(reaction)
-	p := fmt.Sprintf("/api/v2/projects/%d/reactions", projectId)
+func (c *Client) AddProjectReaction(ctx context.Context, projectID uint, reaction Reaction) error {
+	b, err := json.Marshal(reaction)
+	if err != nil {
+		return err
+	}
+	p := fmt.Sprintf("projects/%d/reactions", projectID)
 	res, err := c.post(ctx, p, bytes.NewBuffer(b))
 	if err != nil {
 		return err
@@ -78,8 +87,8 @@ func (c *Client) AddProjectReaction(ctx context.Context, projectId uint, reactio
 
 	DELETE /api/v2/comments/:comment_id/reactions/:reaction_name
 */
-func (c *Client) DeleteCommentReaction(ctx context.Context, commentId, reactionName string) error {
-	p := fmt.Sprintf("/api/v2/comments/%s/reactions/%s", commentId, reactionName)
+func (c *Client) DeleteCommentReaction(ctx context.Context, commentID, reactionName string) error {
+	p := fmt.Sprintf("comments/%s/reactions/%s", commentID, reactionName)
 	res, err := c.delete(ctx, p)
 	if err != nil {
 		return err
@@ -95,8 +104,8 @@ func (c *Client) DeleteCommentReaction(ctx context.Context, commentId, reactionN
 
 	DELETE /api/v2/items/:item_id/reactions/:reaction_name
 */
-func (c *Client) DeleteItemReaction(ctx context.Context, itemId, reactionName string) error {
-	p := fmt.Sprintf("/api/v2/items/%s/reactions/%s", itemId, reactionName)
+func (c *Client) DeleteItemReaction(ctx context.Context, itemID, reactionName string) error {
+	p := fmt.Sprintf("items/%s/reactions/%s", itemID, reactionName)
 	res, err := c.delete(ctx, p)
 	if err != nil {
 		return err
@@ -112,8 +121,8 @@ func (c *Client) DeleteItemReaction(ctx context.Context, itemId, reactionName st
 
 	DELETE /api/v2/projects/:project_id/reactions/:reaction_name
 */
-func (c *Client) DeleteProjectReaction(ctx context.Context, projectId uint, reactionName string) error {
-	p := fmt.Sprintf("/api/v2/projects/%d/reactions/%s", projectId, reactionName)
+func (c *Client) DeleteProjectReaction(ctx context.Context, projectID uint, reactionName string) error {
+	p := fmt.Sprintf("projects/%d/reactions/%s", projectID, reactionName)
 	res, err := c.delete(ctx, p)
 	if err != nil {
 		return err
@@ -129,8 +138,8 @@ func (c *Client) DeleteProjectReaction(ctx context.Context, projectId uint, reac
 
 	GET /api/v2/comments/:comment_id/reactions
 */
-func (c *Client) ListCommentReactions(ctx context.Context, commentId string) (*Reactions, error) {
-	p := fmt.Sprintf("/api/v2/comments/%s/reactions", commentId)
+func (c *Client) ListCommentReactions(ctx context.Context, commentID string) (*Reactions, error) {
+	p := fmt.Sprintf("comments/%s/reactions", commentID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return nil, err
@@ -150,8 +159,8 @@ func (c *Client) ListCommentReactions(ctx context.Context, commentId string) (*R
 
 	GET /api/v2/items/:item_id/reactions
 */
-func (c *Client) ListItemReactions(ctx context.Context, itemId string) (*Reactions, error) {
-	p := fmt.Sprintf("/api/v2/items/%s/reactions", itemId)
+func (c *Client) ListItemReactions(ctx context.Context, itemID string) (*Reactions, error) {
+	p := fmt.Sprintf("items/%s/reactions", itemID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return nil, err
@@ -171,8 +180,8 @@ func (c *Client) ListItemReactions(ctx context.Context, itemId string) (*Reactio
 
 	GET /api/v2/projects/:project_id/reactions
 */
-func (c *Client) ListProjectReactions(ctx context.Context, projectId string) (*Reactions, error) {
-	p := fmt.Sprintf("/api/v2/projects/%s/reactions", projectId)
+func (c *Client) ListProjectReactions(ctx context.Context, projectID string) (*Reactions, error) {
+	p := fmt.Sprintf("projects/%s/reactions", projectID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return nil, err
diff --git a/qiita/emoji_reaction_test.go b/qiita/emoji_reaction_test.go
index 2e3dfb7..83a9739 100755
--- a/qiita/emoji_reaction_test.go
+++ b/qiita/emoji_reaction_test.go
@@ -7,272 +7,272 @@ import (
 	"testing"
 )
 
-func TestAddCommentReaction(t *testing.T) {
-	// 201
-	func() {
+func TestClient_AddCommentReaction(t *testing.T) {
+	t.Run("201", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusCreated)
 			http.ServeFile(w, r, "testdata/add_comment_reaction.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.AddCommentReaction(ctx, "", Reaction{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/add_comment_reaction.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.AddCommentReaction(ctx, "", Reaction{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestAddItemReaction(t *testing.T) {
-	// 201
-	func() {
+func TestClient_AddItemReaction(t *testing.T) {
+	t.Run("201", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusCreated)
 			http.ServeFile(w, r, "testdata/add_item_reaction.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.AddItemReaction(ctx, "", Reaction{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/add_item_reaction.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.AddItemReaction(ctx, "", Reaction{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestAddProjectReaction(t *testing.T) {
-	// 201
-	func() {
+func TestClient_AddProjectReaction(t *testing.T) {
+	t.Run("201", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusCreated)
 			http.ServeFile(w, r, "testdata/add_project_reaction.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.AddProjectReaction(ctx, 1, Reaction{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/add_project_reaction.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.AddProjectReaction(ctx, 1, Reaction{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestDeleteCommentReaction(t *testing.T) {
-	// 204
-	func() {
+func TestClient_DeleteCommentReaction(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteCommentReaction(ctx, "", "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteCommentReaction(ctx, "", "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestDeleteItemReaction(t *testing.T) {
-	// 204
-	func() {
+func TestClient_DeleteItemReaction(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteItemReaction(ctx, "", "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteItemReaction(ctx, "", "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestDeleteProjectReaction(t *testing.T) {
-	// 204
-	func() {
+func TestClient_DeleteProjectReaction(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteProjectReaction(ctx, 1, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteProjectReaction(ctx, 1, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestListCommentReactions(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListCommentReactions(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_comment_reactions.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListCommentReactions(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_comment_reactions.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListCommentReactions(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
 func TestListItemReactions(t *testing.T) {
-	// 200
-	func() {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_item_reactions.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListItemReactions(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_item_reactions.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListItemReactions(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestListProjectReactions(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListProjectReactions(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_project_reactions.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListProjectReactions(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_project_reactions.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListProjectReactions(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
diff --git a/qiita/expanded_template.go b/qiita/expanded_template.go
index 57c3445..9f39536 100755
--- a/qiita/expanded_template.go
+++ b/qiita/expanded_template.go
@@ -21,17 +21,20 @@ type ExpandedTemplate struct {
 	POST /api/v2/expanded_templates
 */
 func (c *Client) CreateExpandedTemplate(ctx context.Context, template Template) (*ExpandedTemplate, error) {
-	b, _ := json.Marshal(template)
-	res, err := c.post(ctx, "/api/v2/expanded_templates", bytes.NewBuffer(b))
+	b, err := json.Marshal(template)
+	if err != nil {
+		return nil, err
+	}
+	res, err := c.post(ctx, "expanded_templates", bytes.NewBuffer(b))
 	if err != nil {
 		return nil, err
 	}
 	if res.StatusCode != http.StatusCreated {
 		return nil, errors.New(res.Status)
 	}
-	var expanded_template ExpandedTemplate
-	if err := decodeBody(res, &expanded_template); err != nil {
+	var expandedTemplate ExpandedTemplate
+	if err := decodeBody(res, &expandedTemplate); err != nil {
 		return nil, err
 	}
-	return &expanded_template, nil
+	return &expandedTemplate, nil
 }
diff --git a/qiita/expanded_template_test.go b/qiita/expanded_template_test.go
index 19a48ad..0fbaab2 100755
--- a/qiita/expanded_template_test.go
+++ b/qiita/expanded_template_test.go
@@ -7,32 +7,32 @@ import (
 	"testing"
 )
 
-func TestCreateExpandedTemplate(t *testing.T) {
-	// 201
-	func() {
+func TestClient_CreateExpandedTemplate(t *testing.T) {
+	t.Run("201", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusCreated)
 			http.ServeFile(w, r, "testdata/create_expanded_template.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.CreateExpandedTemplate(ctx, Template{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/create_expanded_template.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.CreateExpandedTemplate(ctx, Template{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
diff --git a/qiita/group.go b/qiita/group.go
index 2c35a95..73d4940 100755
--- a/qiita/group.go
+++ b/qiita/group.go
@@ -3,9 +3,9 @@ package qiita
 // Represents a group on Qiita:Team
 type Group struct {
 	CreatedAt string `json:"created_at"`
-	Id        uint   `json:"id"`
+	ID        uint   `json:"id"`
 	Name      string `json:"name"`
 	Private   bool   `json:"private"`
 	UpdatedAt string `json:"updated_at"`
-	UrlName   string `json:"url_name"`
+	URLName   string `json:"url_name"`
 }
diff --git a/qiita/item.go b/qiita/item.go
index 88c444d..55fa5f5 100755
--- a/qiita/item.go
+++ b/qiita/item.go
@@ -7,7 +7,6 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
-	"net/url"
 )
 
 // Represents an item posted from a user
@@ -17,14 +16,14 @@ type Item struct {
 	CreatedAt    string    `json:"created_at,omitempty"`
 	Gist         bool      `json:"gist,omitempty"`
 	Group        *Group    `json:"group,omitempty"`
-	Id           string    `json:"id,omitempty"`
+	ID           string    `json:"id,omitempty"`
 	Private      bool      `json:"private"`
 	Tags         *Taggings `json:"tags"`
 	Title        string    `json:"title"`
 	Tweet        bool      `json:"tweet,omitempty"`
 	RenderedBody string    `json:"rendered_body,omitempty"`
 	UpdatedAt    string    `json:"updated_at,omitempty"`
-	Url          string    `json:"url,omitempty"`
+	URL          string    `json:"url,omitempty"`
 	User         *User     `json:"user,omitempty"`
 }
 
@@ -36,11 +35,10 @@ type Items []Item
 	GET /api/v2/authenticated_user/items
 */
 func (c *Client) ListAuthenticatedUserItems(ctx context.Context, page, perPage uint) (*Items, error) {
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, "/api/v2/authenticated_user/items", &rawQuery)
+	res, err := c.get(ctx, "authenticated_user/items", map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -60,14 +58,11 @@ func (c *Client) ListAuthenticatedUserItems(ctx context.Context, page, perPage u
 	GET /api/v2/items
 */
 func (c *Client) ListItems(ctx context.Context, page, perPage uint, query string) (*Items, error) {
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	if query != "" {
-		values.Add("query", query)
-	}
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, "/api/v2/items", &rawQuery)
+	res, err := c.get(ctx, "items", map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+		"query":    query,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -87,8 +82,11 @@ func (c *Client) ListItems(ctx context.Context, page, perPage uint, query string
 	POST /api/v2/items
 */
 func (c *Client) CreateItem(ctx context.Context, item Item) error {
-	b, _ := json.Marshal(item)
-	res, err := c.post(ctx, "/api/v2/items", bytes.NewBuffer(b))
+	b, err := json.Marshal(item)
+	if err != nil {
+		return err
+	}
+	res, err := c.post(ctx, "items", bytes.NewBuffer(b))
 	if err != nil {
 		return err
 	}
@@ -103,8 +101,8 @@ func (c *Client) CreateItem(ctx context.Context, item Item) error {
 
 	DELETE /api/v2/items/:item_id
 */
-func (c *Client) DeleteItem(ctx context.Context, itemId string) error {
-	p := fmt.Sprintf("/api/v2/items/%s", itemId)
+func (c *Client) DeleteItem(ctx context.Context, itemID string) error {
+	p := fmt.Sprintf("items/%s", itemID)
 	res, err := c.delete(ctx, p)
 	if err != nil {
 		return err
@@ -120,8 +118,8 @@ func (c *Client) DeleteItem(ctx context.Context, itemId string) error {
 
 	GET /api/v2/items/:item_id
 */
-func (c *Client) GetItem(ctx context.Context, itemId string) (*Item, error) {
-	p := fmt.Sprintf("/api/v2/items/%s", itemId)
+func (c *Client) GetItem(ctx context.Context, itemID string) (*Item, error) {
+	p := fmt.Sprintf("items/%s", itemID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return nil, err
@@ -142,8 +140,11 @@ func (c *Client) GetItem(ctx context.Context, itemId string) (*Item, error) {
 	PATCH /api/v2/items/:item_id
 */
 func (c *Client) UpdateItem(ctx context.Context, item Item) error {
-	b, _ := json.Marshal(item)
-	p := fmt.Sprintf("/api/v2/items/%s", item.Id)
+	b, err := json.Marshal(item)
+	if err != nil {
+		return err
+	}
+	p := fmt.Sprintf("items/%s", item.ID)
 	res, err := c.patch(ctx, p, bytes.NewBuffer(b))
 	if err != nil {
 		return err
@@ -159,8 +160,8 @@ func (c *Client) UpdateItem(ctx context.Context, item Item) error {
 
 	DELETE /api/v2/items/:item_id/like
 */
-func (c *Client) UnlikeItem(ctx context.Context, itemId string) error {
-	p := fmt.Sprintf("/api/v2/items/%s/like", itemId)
+func (c *Client) UnlikeItem(ctx context.Context, itemID string) error {
+	p := fmt.Sprintf("items/%s/like", itemID)
 	res, err := c.delete(ctx, p)
 	if err != nil {
 		return err
@@ -176,8 +177,8 @@ func (c *Client) UnlikeItem(ctx context.Context, itemId string) error {
 
 	PUT /api/v2/items/:item_id/like
 */
-func (c *Client) LikeItem(ctx context.Context, itemId string) error {
-	p := fmt.Sprintf("/api/v2/items/%s/like", itemId)
+func (c *Client) LikeItem(ctx context.Context, itemID string) error {
+	p := fmt.Sprintf("items/%s/like", itemID)
 	res, err := c.put(ctx, p, nil)
 	if err != nil {
 		return err
@@ -193,8 +194,8 @@ func (c *Client) LikeItem(ctx context.Context, itemId string) error {
 
 	PUT /api/v2/items/:item_id/stock
 */
-func (c *Client) StockItem(ctx context.Context, itemId string) error {
-	p := fmt.Sprintf("/api/v2/items/%s/stock", itemId)
+func (c *Client) StockItem(ctx context.Context, itemID string) error {
+	p := fmt.Sprintf("items/%s/stock", itemID)
 	res, err := c.put(ctx, p, nil)
 	if err != nil {
 		return err
@@ -210,8 +211,8 @@ func (c *Client) StockItem(ctx context.Context, itemId string) error {
 
 	DELETE /api/v2/items/:item_id/stock
 */
-func (c *Client) UnstockItem(ctx context.Context, itemId string) error {
-	p := fmt.Sprintf("/api/v2/items/%s/stock", itemId)
+func (c *Client) UnstockItem(ctx context.Context, itemID string) error {
+	p := fmt.Sprintf("items/%s/stock", itemID)
 	res, err := c.delete(ctx, p)
 	if err != nil {
 		return err
@@ -227,8 +228,8 @@ func (c *Client) UnstockItem(ctx context.Context, itemId string) error {
 
 	GET /api/v2/items/:item_id/stock
 */
-func (c *Client) EnsureItemStock(ctx context.Context, itemId string) error {
-	p := fmt.Sprintf("/api/v2/items/%s/stock", itemId)
+func (c *Client) EnsureItemStock(ctx context.Context, itemID string) error {
+	p := fmt.Sprintf("items/%s/stock", itemID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return err
@@ -244,8 +245,8 @@ func (c *Client) EnsureItemStock(ctx context.Context, itemId string) error {
 
 	GET /api/v2/items/:item_id/like
 */
-func (c *Client) EnsureItemLike(ctx context.Context, itemId string) error {
-	p := fmt.Sprintf("/api/v2/items/%s/like", itemId)
+func (c *Client) EnsureItemLike(ctx context.Context, itemID string) error {
+	p := fmt.Sprintf("items/%s/like", itemID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return err
@@ -261,13 +262,12 @@ func (c *Client) EnsureItemLike(ctx context.Context, itemId string) error {
 
 	GET /api/v2/tags/:tag_id/items
 */
-func (c *Client) ListTaggedItems(ctx context.Context, tagId string, page, perPage uint) (*Items, error) {
-	p := fmt.Sprintf("/api/v2/tags/%s/items", tagId)
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, p, &rawQuery)
+func (c *Client) ListTaggedItems(ctx context.Context, tagID string, page, perPage uint) (*Items, error) {
+	p := fmt.Sprintf("tags/%s/items", tagID)
+	res, err := c.get(ctx, p, map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -286,13 +286,12 @@ func (c *Client) ListTaggedItems(ctx context.Context, tagId string, page, perPag
 
 	GET /api/v2/users/:user_id/items
 */
-func (c *Client) ListUserItems(ctx context.Context, userId string, page, perPage uint) (*Items, error) {
-	p := fmt.Sprintf("/api/v2/users/%s/items", userId)
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, p, &rawQuery)
+func (c *Client) ListUserItems(ctx context.Context, userID string, page, perPage uint) (*Items, error) {
+	p := fmt.Sprintf("users/%s/items", userID)
+	res, err := c.get(ctx, p, map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -311,13 +310,12 @@ func (c *Client) ListUserItems(ctx context.Context, userId string, page, perPage
 
 	GET /api/v2/users/:user_id/stocks
 */
-func (c *Client) ListUserStocks(ctx context.Context, userId string, page, perPage uint) (*Items, error) {
-	p := fmt.Sprintf("/api/v2/users/%s/stocks", userId)
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, p, &rawQuery)
+func (c *Client) ListUserStocks(ctx context.Context, userID string, page, perPage uint) (*Items, error) {
+	p := fmt.Sprintf("users/%s/stocks", userID)
+	res, err := c.get(ctx, p, map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+	})
 	if err != nil {
 		return nil, err
 	}
diff --git a/qiita/item_test.go b/qiita/item_test.go
index 2ffe153..4cc72e9 100755
--- a/qiita/item_test.go
+++ b/qiita/item_test.go
@@ -7,452 +7,452 @@ import (
 	"testing"
 )
 
-func TestListAuthenticatedUserItems(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListAuthenticatedUserItems(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_authenticated_user_items.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListAuthenticatedUserItems(ctx, 1, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_authenticated_user_items.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListAuthenticatedUserItems(ctx, 1, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestListItems(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListItems(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_items.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListItems(ctx, 1, 1, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_items.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListItems(ctx, 1, 1, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestCreateItem(t *testing.T) {
-	// 201
-	func() {
+func TestClient_CreateItem(t *testing.T) {
+	t.Run("201", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusCreated)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.CreateItem(ctx, Item{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.CreateItem(ctx, Item{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestDeleteItem(t *testing.T) {
-	// 204
-	func() {
+func TestClient_DeleteItem(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteItem(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteItem(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestGetItem(t *testing.T) {
-	// 200
-	func() {
+func TestClient_GetItem(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/get_item.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetItem(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/get_item.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetItem(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestUpdateItem(t *testing.T) {
-	// 200
-	func() {
+func TestClient_UpdateItem(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/update_item.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UpdateItem(ctx, Item{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/update_item.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UpdateItem(ctx, Item{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestUnlikeItem(t *testing.T) {
-	// 204
-	func() {
+func TestClient_UnlikeItem(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UnlikeItem(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UnlikeItem(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestLikeItem(t *testing.T) {
-	// 204
-	func() {
+func TestClient_LikeItem(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.LikeItem(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.LikeItem(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestStockItem(t *testing.T) {
-	// 204
-	func() {
+func TestClient_StockItem(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.StockItem(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.StockItem(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestUnstockItem(t *testing.T) {
-	// 204
-	func() {
+func TestClient_UnstockItem(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UnstockItem(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UnstockItem(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestEnsureItemStock(t *testing.T) {
-	// 204
-	func() {
+func TestClient_EnsureItemStock(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.EnsureItemStock(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.EnsureItemStock(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestEnsureItemLike(t *testing.T) {
-	// 204
-	func() {
+func TestClient_EnsureItemLike(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.EnsureItemLike(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.EnsureItemLike(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestListTaggedItems(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListTaggedItems(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_tagged_items.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListTaggedItems(ctx, "", 1, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_tagged_items.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListTaggedItems(ctx, "", 1, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestListUserItems(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListUserItems(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_user_items.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListUserItems(ctx, "", 1, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_user_items.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListUserItems(ctx, "", 1, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestListUserStocks(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListUserStocks(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_user_stocks.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListUserStocks(ctx, "", 1, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_user_stocks.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListUserStocks(ctx, "", 1, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
diff --git a/qiita/like.go b/qiita/like.go
index 5a0ae4a..5b1a975 100755
--- a/qiita/like.go
+++ b/qiita/like.go
@@ -20,8 +20,8 @@ type Likes []Like
 
 	GET /api/v2/items/:item_id/likes
 */
-func (c *Client) ListItemLikes(ctx context.Context, itemId string) (*Likes, error) {
-	p := fmt.Sprintf("/api/v2/items/%s/likes", itemId)
+func (c *Client) ListItemLikes(ctx context.Context, itemID string) (*Likes, error) {
+	p := fmt.Sprintf("items/%s/likes", itemID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return nil, err
diff --git a/qiita/like_test.go b/qiita/like_test.go
index 4e4aec4..555f752 100755
--- a/qiita/like_test.go
+++ b/qiita/like_test.go
@@ -7,32 +7,32 @@ import (
 	"testing"
 )
 
-func TestListItemLikes(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListItemLikes(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_item_likes.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListItemLikes(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_item_likes.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListItemLikes(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
diff --git a/qiita/project.go b/qiita/project.go
index f697b79..67a9646 100755
--- a/qiita/project.go
+++ b/qiita/project.go
@@ -7,7 +7,6 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
-	"net/url"
 )
 
 // Represents a project on Qiita:Team (only available on Qiita:Team).
@@ -15,7 +14,7 @@ type Project struct {
 	Archived     bool      `json:"archived"`
 	Body         string    `json:"body"`
 	CreatedAt    string    `json:"created_at,omitempty"`
-	Id           uint      `json:"id,omitempty"`
+	ID           uint      `json:"id,omitempty"`
 	Name         string    `json:"name"`
 	RenderedBody string    `json:"rendered_body,omitempty"`
 	Tags         *Taggings `json:"tags,omitempty"`
@@ -30,11 +29,10 @@ type Projects []Project
 	GET /api/v2/projects
 */
 func (c *Client) ListProjects(ctx context.Context, page, perPage uint) (*Projects, error) {
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, "/api/v2/projects", &rawQuery)
+	res, err := c.get(ctx, "projects", map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -54,8 +52,11 @@ func (c *Client) ListProjects(ctx context.Context, page, perPage uint) (*Project
 	POST /api/v2/projects
 */
 func (c *Client) CreateProject(ctx context.Context, project Project) error {
-	b, _ := json.Marshal(project)
-	res, err := c.post(ctx, "/api/v2/projects", bytes.NewBuffer(b))
+	b, err := json.Marshal(project)
+	if err != nil {
+		return err
+	}
+	res, err := c.post(ctx, "projects", bytes.NewBuffer(b))
 	if err != nil {
 		return err
 	}
@@ -70,8 +71,8 @@ func (c *Client) CreateProject(ctx context.Context, project Project) error {
 
 	DELETE /api/v2/projects/:project_id
 */
-func (c *Client) DeleteProject(ctx context.Context, projectId uint) error {
-	p := fmt.Sprintf("/api/v2/projects/%d", projectId)
+func (c *Client) DeleteProject(ctx context.Context, projectID uint) error {
+	p := fmt.Sprintf("projects/%d", projectID)
 	res, err := c.delete(ctx, p)
 	if err != nil {
 		return err
@@ -87,13 +88,12 @@ func (c *Client) DeleteProject(ctx context.Context, projectId uint) error {
 
 	GET /api/v2/projects/:project_id
 */
-func (c *Client) GetProject(ctx context.Context, projectId string, page, perPage uint) (*Project, error) {
-	p := fmt.Sprintf("/api/v2/projects/%s", projectId)
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, p, &rawQuery)
+func (c *Client) GetProject(ctx context.Context, projectID string, page, perPage uint) (*Project, error) {
+	p := fmt.Sprintf("projects/%s", projectID)
+	res, err := c.get(ctx, p, map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -113,8 +113,11 @@ func (c *Client) GetProject(ctx context.Context, projectId string, page, perPage
 	PATCH /api/v2/projects/:project_id
 */
 func (c *Client) UpdateProject(ctx context.Context, project Project) error {
-	b, _ := json.Marshal(project)
-	p := fmt.Sprintf("/api/v2/projects/%d", project.Id)
+	b, err := json.Marshal(project)
+	if err != nil {
+		return err
+	}
+	p := fmt.Sprintf("projects/%d", project.ID)
 	res, err := c.patch(ctx, p, bytes.NewBuffer(b))
 	if err != nil {
 		return err
diff --git a/qiita/project_test.go b/qiita/project_test.go
index 62af3d0..e4125bf 100755
--- a/qiita/project_test.go
+++ b/qiita/project_test.go
@@ -7,152 +7,152 @@ import (
 	"testing"
 )
 
-func TestGetProjects(t *testing.T) {
-	// 200
-	func() {
+func TestClient_GetProjects(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/get_projects.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListProjects(ctx, 1, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/get_projects.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListProjects(ctx, 1, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestCreateProject(t *testing.T) {
-	// 201
-	func() {
+func TestClient_CreateProject(t *testing.T) {
+	t.Run("201", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusCreated)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.CreateProject(ctx, Project{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.CreateProject(ctx, Project{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestDeleteProject(t *testing.T) {
-	// 204
-	func() {
+func TestClient_DeleteProject(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteProject(ctx, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteProject(ctx, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestGetProject(t *testing.T) {
-	// 200
-	func() {
+func TestClient_GetProject(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/get_project.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetProject(ctx, "", 1, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/get_project.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetProject(ctx, "", 1, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestUpdateProject(t *testing.T) {
-	// 200
-	func() {
+func TestClient_UpdateProject(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UpdateProject(ctx, Project{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UpdateProject(ctx, Project{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
diff --git a/qiita/tag.go b/qiita/tag.go
index 8235b28..f48524b 100755
--- a/qiita/tag.go
+++ b/qiita/tag.go
@@ -5,14 +5,13 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
-	"net/url"
 )
 
 // A tag attached to an item
 type Tag struct {
 	FollowersCount uint   `json:"followers_count"`
-	IconUrl        string `json:"icon_url"`
-	Id             string `json:"id"`
+	IconURL        string `json:"icon_url"`
+	ID             string `json:"id"`
 	ItemsCount     uint   `json:"items_count"`
 }
 
@@ -24,12 +23,11 @@ type Tags []Tag
 	GET /api/v2/tags
 */
 func (c *Client) ListTags(ctx context.Context, page, perPage uint, sort string) (*Tags, error) {
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	values.Add("sort", sort)
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, "/api/v2/tags", &rawQuery)
+	res, err := c.get(ctx, "tags", map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+		"sort":     sort,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -48,8 +46,8 @@ func (c *Client) ListTags(ctx context.Context, page, perPage uint, sort string)
 
 	GET /api/v2/tags/:tag_id
 */
-func (c *Client) GetTag(ctx context.Context, tagId string) (*Tag, error) {
-	p := fmt.Sprintf("/api/v2/tags/%s", tagId)
+func (c *Client) GetTag(ctx context.Context, tagID string) (*Tag, error) {
+	p := fmt.Sprintf("tags/%s", tagID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return nil, err
@@ -69,13 +67,12 @@ func (c *Client) GetTag(ctx context.Context, tagId string) (*Tag, error) {
 
 	GET /api/v2/users/:user_id/following_tags
 */
-func (c *Client) ListFollowingTags(ctx context.Context, userId string, page, perPage uint) (*Tags, error) {
-	p := fmt.Sprintf("/api/v2/users/%s/following_tags", userId)
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, p, &rawQuery)
+func (c *Client) ListFollowingTags(ctx context.Context, userID string, page, perPage uint) (*Tags, error) {
+	p := fmt.Sprintf("users/%s/following_tags", userID)
+	res, err := c.get(ctx, p, map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -94,8 +91,8 @@ func (c *Client) ListFollowingTags(ctx context.Context, userId string, page, per
 
 	DELETE /api/v2/tags/:tag_id/following
 */
-func (c *Client) UnfollowTag(ctx context.Context, tagId string) error {
-	p := fmt.Sprintf("/api/v2/tags/%s/following", tagId)
+func (c *Client) UnfollowTag(ctx context.Context, tagID string) error {
+	p := fmt.Sprintf("tags/%s/following", tagID)
 	res, err := c.delete(ctx, p)
 	if err != nil {
 		return err
@@ -111,8 +108,8 @@ func (c *Client) UnfollowTag(ctx context.Context, tagId string) error {
 
 	GET /api/v2/tags/:tag_id/following
 */
-func (c *Client) EnsureFollowingTag(ctx context.Context, tagId string) error {
-	p := fmt.Sprintf("/api/v2/tags/%s/following", tagId)
+func (c *Client) EnsureFollowingTag(ctx context.Context, tagID string) error {
+	p := fmt.Sprintf("tags/%s/following", tagID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return err
@@ -128,8 +125,8 @@ func (c *Client) EnsureFollowingTag(ctx context.Context, tagId string) error {
 
 	PUT /api/v2/tags/:tag_id/following
 */
-func (c *Client) FollowTag(ctx context.Context, tagId string) error {
-	p := fmt.Sprintf("/api/v2/tags/%s/following", tagId)
+func (c *Client) FollowTag(ctx context.Context, tagID string) error {
+	p := fmt.Sprintf("tags/%s/following", tagID)
 	res, err := c.put(ctx, p, nil)
 	if err != nil {
 		return err
diff --git a/qiita/tag_test.go b/qiita/tag_test.go
index c884142..af4e74a 100755
--- a/qiita/tag_test.go
+++ b/qiita/tag_test.go
@@ -7,182 +7,182 @@ import (
 	"testing"
 )
 
-func TestListTags(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListTags(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_tags.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListTags(ctx, 1, 1, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_tags.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListTags(ctx, 1, 1, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestGetTag(t *testing.T) {
-	// 200
-	func() {
+func TestClient_GetTag(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/get_tag.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetTag(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/get_tag.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetTag(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestListFollowingTags(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListFollowingTags(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_following_tags.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListFollowingTags(ctx, "", 1, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_following_tags.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListFollowingTags(ctx, "", 1, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestUnfollowTag(t *testing.T) {
-	// 204
-	func() {
+func TestClient_UnfollowTag(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UnfollowTag(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UnfollowTag(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestEnsureFollowingTag(t *testing.T) {
-	// 204
-	func() {
+func TestClient_EnsureFollowingTag(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.EnsureFollowingTag(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.EnsureFollowingTag(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestFollowTag(t *testing.T) {
-	// 204
-	func() {
+func TestClient_FollowTag(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.FollowTag(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.FollowTag(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
diff --git a/qiita/tagging.go b/qiita/tagging.go
index 0c2bb5e..22a7d3e 100755
--- a/qiita/tagging.go
+++ b/qiita/tagging.go
@@ -22,9 +22,12 @@ type Taggings []Tagging
 
 	POST /api/v2/items/:item_id/taggings
 */
-func (c *Client) AddItemTagging(ctx context.Context, itemId string, tagging Tagging) error {
-	b, _ := json.Marshal(tagging)
-	p := fmt.Sprintf("/api/v2/items/%s/taggings", itemId)
+func (c *Client) AddItemTagging(ctx context.Context, itemID string, tagging Tagging) error {
+	b, err := json.Marshal(tagging)
+	if err != nil {
+		return err
+	}
+	p := fmt.Sprintf("items/%s/taggings", itemID)
 	res, err := c.post(ctx, p, bytes.NewBuffer(b))
 	if err != nil {
 		return err
@@ -40,8 +43,8 @@ func (c *Client) AddItemTagging(ctx context.Context, itemId string, tagging Tagg
 
 	DELETE /api/v2/items/:item_id/taggings/:tagging_id
 */
-func (c *Client) DeleteItemTagging(ctx context.Context, itemId, taggingId string) error {
-	p := fmt.Sprintf("/api/v2/items/%s/taggings/%s", itemId, taggingId)
+func (c *Client) DeleteItemTagging(ctx context.Context, itemID, taggingID string) error {
+	p := fmt.Sprintf("items/%s/taggings/%s", itemID, taggingID)
 	res, err := c.delete(ctx, p)
 	if err != nil {
 		return err
diff --git a/qiita/tagging_test.go b/qiita/tagging_test.go
index b12a171..56bfad3 100755
--- a/qiita/tagging_test.go
+++ b/qiita/tagging_test.go
@@ -7,62 +7,62 @@ import (
 	"testing"
 )
 
-func TestAddItemTagging(t *testing.T) {
-	// 201
-	func() {
+func TestClient_AddItemTagging(t *testing.T) {
+	t.Run("201", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusCreated)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.AddItemTagging(ctx, "", Tagging{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.AddItemTagging(ctx, "", Tagging{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestDeleteItemTagging(t *testing.T) {
-	// 204
-	func() {
+func TestClient_DeleteItemTagging(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteItemTagging(ctx, "", "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteItemTagging(ctx, "", "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
diff --git a/qiita/team.go b/qiita/team.go
index 82ade9e..91438fe 100755
--- a/qiita/team.go
+++ b/qiita/team.go
@@ -9,7 +9,7 @@ import (
 // Represents a team on Qiita:Team (only available on Qiita:Team).
 type Team struct {
 	Archive bool   `json:"archive"`
-	Id      string `json:"id"`
+	ID      string `json:"id"`
 	Name    string `json:"name"`
 }
 
@@ -21,7 +21,7 @@ type Teams []Team
 	GET /api/v2/teams
 */
 func (c *Client) ListTeams(ctx context.Context) (*Teams, error) {
-	res, err := c.get(ctx, "/api/v2/teams", nil)
+	res, err := c.get(ctx, "teams", nil)
 	if err != nil {
 		return nil, err
 	}
diff --git a/qiita/team_test.go b/qiita/team_test.go
index 67b51cb..b77031f 100755
--- a/qiita/team_test.go
+++ b/qiita/team_test.go
@@ -7,32 +7,32 @@ import (
 	"testing"
 )
 
-func TestListTeams(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListTeams(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_teams.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListTeams(ctx)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_teams.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListTeams(ctx)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
diff --git a/qiita/template.go b/qiita/template.go
index 9440711..5e1d42c 100755
--- a/qiita/template.go
+++ b/qiita/template.go
@@ -7,14 +7,13 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
-	"net/url"
 )
 
 // Represents a template for generating an item boilerplate (only available on Qiita:Team).
 type Template struct {
 	*ExpandedTemplate
 	Body  string    `json:"body"`
-	Id    uint      `json:"id,omitempty"`
+	ID    uint      `json:"id,omitempty"`
 	Name  string    `json:"name"`
 	Tags  *Taggings `json:"tags"`
 	Title string    `json:"title"`
@@ -28,11 +27,10 @@ type Templates []Template
 	GET /api/v2/templates
 */
 func (c *Client) ListTemplates(ctx context.Context, page, perPage uint) (*Templates, error) {
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, "/api/v2/templates", &rawQuery)
+	res, err := c.get(ctx, "templates", map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -51,8 +49,8 @@ func (c *Client) ListTemplates(ctx context.Context, page, perPage uint) (*Templa
 
 	DELETE /api/v2/templates/:template_id
 */
-func (c *Client) DeleteTemplate(ctx context.Context, templateId uint) error {
-	p := fmt.Sprintf("/api/v2/templates/%d", templateId)
+func (c *Client) DeleteTemplate(ctx context.Context, templateID uint) error {
+	p := fmt.Sprintf("templates/%d", templateID)
 	res, err := c.delete(ctx, p)
 	if err != nil {
 		return err
@@ -68,8 +66,8 @@ func (c *Client) DeleteTemplate(ctx context.Context, templateId uint) error {
 
 	GET /api/v2/templates/:template_id
 */
-func (c *Client) GetTemplate(ctx context.Context, templateId uint) (*Template, error) {
-	p := fmt.Sprintf("/api/v2/templates/%d", templateId)
+func (c *Client) GetTemplate(ctx context.Context, templateID uint) (*Template, error) {
+	p := fmt.Sprintf("templates/%d", templateID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return nil, err
@@ -90,8 +88,11 @@ func (c *Client) GetTemplate(ctx context.Context, templateId uint) (*Template, e
 	POST /api/v2/templates
 */
 func (c *Client) CreateTemplate(ctx context.Context, template Template) error {
-	b, _ := json.Marshal(template)
-	res, err := c.post(ctx, "/api/v2/templates", bytes.NewBuffer(b))
+	b, err := json.Marshal(template)
+	if err != nil {
+		return err
+	}
+	res, err := c.post(ctx, "templates", bytes.NewBuffer(b))
 	if err != nil {
 		return err
 	}
@@ -107,8 +108,11 @@ func (c *Client) CreateTemplate(ctx context.Context, template Template) error {
 	PATCH /api/v2/templates/:template_id
 */
 func (c *Client) UpdateTemplate(ctx context.Context, template Template) error {
-	b, _ := json.Marshal(template)
-	p := fmt.Sprintf("/api/v2/templates/%d", template.Id)
+	b, err := json.Marshal(template)
+	if err != nil {
+		return err
+	}
+	p := fmt.Sprintf("templates/%d", template.ID)
 	res, err := c.patch(ctx, p, bytes.NewBuffer(b))
 	if err != nil {
 		return err
diff --git a/qiita/template_test.go b/qiita/template_test.go
index f5379d7..fbca1b3 100755
--- a/qiita/template_test.go
+++ b/qiita/template_test.go
@@ -7,152 +7,152 @@ import (
 	"testing"
 )
 
-func TestListTemplates(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListTemplates(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_templates.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListTemplates(ctx, 1, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_templates.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListTemplates(ctx, 1, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestDeleteTemplate(t *testing.T) {
-	// 204
-	func() {
+func TestClient_DeleteTemplate(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteTemplate(ctx, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.DeleteTemplate(ctx, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestGetTemplate(t *testing.T) {
-	// 200
-	func() {
+func TestClient_GetTemplate(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/get_template.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetTemplate(ctx, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/get_template.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetTemplate(ctx, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestCreateTemplate(t *testing.T) {
-	// 201
-	func() {
+func TestClient_CreateTemplate(t *testing.T) {
+	t.Run("201", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusCreated)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.CreateTemplate(ctx, Template{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.CreateTemplate(ctx, Template{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestUpdateTemplate(t *testing.T) {
-	// 200
-	func() {
+func TestClient_UpdateTemplate(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UpdateTemplate(ctx, Template{})
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UpdateTemplate(ctx, Template{})
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
diff --git a/qiita/user.go b/qiita/user.go
index 5cc02c2..7967f6c 100755
--- a/qiita/user.go
+++ b/qiita/user.go
@@ -5,26 +5,25 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
-	"net/url"
 )
 
 // A Qiita user (a.k.a. account)
 type User struct {
 	Description       string `json:"description"`
-	FacebookId        string `json:"facebook_id"`
+	FacebookID        string `json:"facebook_id"`
 	FolloweesCount    uint   `json:"followees_count"`
 	FollowersCount    uint   `json:"followers_count"`
 	GitHubLoginName   string `json:"github_login_name"`
-	Id                string `json:"id"`
+	ID                string `json:"id"`
 	ItemCount         uint   `json:"item_count"`
-	LinkedinId        string `json:"linkedin_id"`
+	LinkedinID        string `json:"linkedin_id"`
 	Location          string `json:"location"`
 	Name              string `json:"name"`
 	Organization      string `json:"organization"`
-	PermanentId       uint   `json:"permanent_id"`
-	ProfileImageUrl   string `json:"profile_image_url"`
+	PermanentID       uint   `json:"permanent_id"`
+	ProfileImageURL   string `json:"profile_image_url"`
 	TwitterScreenName string `json:"twitter_screen_name"`
-	WebsiteUrl        string `json:"website_url"`
+	WebsiteURL        string `json:"website_url"`
 }
 
 type Users []User
@@ -34,13 +33,12 @@ type Users []User
 
 	GET /api/v2/items/:item_id/stockers
 */
-func (c *Client) ListStockers(ctx context.Context, itemId string, page, perPage uint) (*Users, error) {
-	p := fmt.Sprintf("/api/v2/items/%s/stockers", itemId)
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, p, &rawQuery)
+func (c *Client) ListStockers(ctx context.Context, itemID string, page, perPage uint) (*Users, error) {
+	p := fmt.Sprintf("items/%s/stockers", itemID)
+	res, err := c.get(ctx, p, map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -60,11 +58,10 @@ func (c *Client) ListStockers(ctx context.Context, itemId string, page, perPage
 	GET /api/v2/users
 */
 func (c *Client) ListUsers(ctx context.Context, page, perPage uint) (*Users, error) {
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, "/api/v2/users", &rawQuery)
+	res, err := c.get(ctx, "users", map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -83,8 +80,8 @@ func (c *Client) ListUsers(ctx context.Context, page, perPage uint) (*Users, err
 
 	GET /api/v2/users/:user_id
 */
-func (c *Client) GetUser(ctx context.Context, userId string) (*User, error) {
-	p := fmt.Sprintf("/api/v2/users/%s", userId)
+func (c *Client) GetUser(ctx context.Context, userID string) (*User, error) {
+	p := fmt.Sprintf("users/%s", userID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return nil, err
@@ -104,13 +101,12 @@ func (c *Client) GetUser(ctx context.Context, userId string) (*User, error) {
 
 	GET /api/v2/users/:user_id/followees
 */
-func (c *Client) ListFollowees(ctx context.Context, userId string, page, perPage uint) (*Users, error) {
-	p := fmt.Sprintf("/api/v2/users/%s/followees", userId)
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, p, &rawQuery)
+func (c *Client) ListFollowees(ctx context.Context, userID string, page, perPage uint) (*Users, error) {
+	p := fmt.Sprintf("users/%s/followees", userID)
+	res, err := c.get(ctx, p, map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -129,13 +125,12 @@ func (c *Client) ListFollowees(ctx context.Context, userId string, page, perPage
 
 	GET /api/v2/users/:user_id/followers
 */
-func (c *Client) ListFollowers(ctx context.Context, userId string, page, perPage uint) (*Users, error) {
-	p := fmt.Sprintf("/api/v2/users/%s/followers", userId)
-	values := url.Values{}
-	values.Add("page", fmt.Sprint(page))
-	values.Add("per_page", fmt.Sprint(perPage))
-	rawQuery := values.Encode()
-	res, err := c.get(ctx, p, &rawQuery)
+func (c *Client) ListFollowers(ctx context.Context, userID string, page, perPage uint) (*Users, error) {
+	p := fmt.Sprintf("users/%s/followers", userID)
+	res, err := c.get(ctx, p, map[string]interface{}{
+		"page":     page,
+		"per_page": perPage,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -154,8 +149,8 @@ func (c *Client) ListFollowers(ctx context.Context, userId string, page, perPage
 
 	DELETE /api/v2/users/:user_id/following
 */
-func (c *Client) UnfollowUser(ctx context.Context, userId string) error {
-	p := fmt.Sprintf("/api/v2/users/%s/following", userId)
+func (c *Client) UnfollowUser(ctx context.Context, userID string) error {
+	p := fmt.Sprintf("users/%s/following", userID)
 	res, err := c.delete(ctx, p)
 	if err != nil {
 		return err
@@ -171,8 +166,8 @@ func (c *Client) UnfollowUser(ctx context.Context, userId string) error {
 
 	GET /api/v2/users/:user_id/following
 */
-func (c *Client) EnsureFollowingUser(ctx context.Context, userId string) error {
-	p := fmt.Sprintf("/api/v2/users/%s/following", userId)
+func (c *Client) EnsureFollowingUser(ctx context.Context, userID string) error {
+	p := fmt.Sprintf("users/%s/following", userID)
 	res, err := c.get(ctx, p, nil)
 	if err != nil {
 		return err
@@ -188,8 +183,8 @@ func (c *Client) EnsureFollowingUser(ctx context.Context, userId string) error {
 
 	PUT /api/v2/users/:user_id/following
 */
-func (c *Client) FollowUser(ctx context.Context, userId string) error {
-	p := fmt.Sprintf("/api/v2/users/%s/following", userId)
+func (c *Client) FollowUser(ctx context.Context, userID string) error {
+	p := fmt.Sprintf("users/%s/following", userID)
 	res, err := c.put(ctx, p, nil)
 	if err != nil {
 		return err
diff --git a/qiita/user_test.go b/qiita/user_test.go
index 87ff85c..c5e26ae 100755
--- a/qiita/user_test.go
+++ b/qiita/user_test.go
@@ -7,242 +7,242 @@ import (
 	"testing"
 )
 
-func TestListStockers(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListStockers(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_stockers.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListStockers(ctx, "", 1, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_stockers.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListStockers(ctx, "", 1, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestListUsers(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListUsers(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_users.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListUsers(ctx, 1, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_users.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListUsers(ctx, 1, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestGetUser(t *testing.T) {
-	// 200
-	func() {
+func TestClient_GetUser(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/get_user.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetUser(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/get_user.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.GetUser(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestListFollowees(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListFollowees(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_followees.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListFollowees(ctx, "", 1, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_followees.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListFollowees(ctx, "", 1, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestListFollowers(t *testing.T) {
-	// 200
-	func() {
+func TestClient_ListFollowers(t *testing.T) {
+	t.Run("200", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
 			http.ServeFile(w, r, "testdata/list_followers.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListFollowers(ctx, "", 1, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "testdata/list_followers.json")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		_, err := c.ListFollowers(ctx, "", 1, 1)
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestUnfollowUser(t *testing.T) {
-	// 204
-	func() {
+func TestClient_UnfollowUser(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UnfollowUser(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.UnfollowUser(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestEnsureFollowingUser(t *testing.T) {
-	// 204
-	func() {
+func TestClient_EnsureFollowingUser(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.EnsureFollowingUser(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.EnsureFollowingUser(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }
 
-func TestFollowUser(t *testing.T) {
-	// 204
-	func() {
+func TestClient_FollowUser(t *testing.T) {
+	t.Run("204", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusNoContent)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.FollowUser(ctx, "")
 		if err != nil {
 			t.Fatal(err)
 		}
-	}()
+	})
 
-	// 400
-	func() {
+	t.Run("400", func(t *testing.T) {
 		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusBadRequest)
 			http.ServeFile(w, r, "")
 		}))
+		defer server.Close()
 		c, _ := mockClient(server)
 		ctx := context.TODO()
 		err := c.FollowUser(ctx, "")
 		if err == nil {
 			t.Fail()
 		}
-	}()
+	})
 }