first commit

Author: ktsujichan

.travis.yml

@@ -0,0 +1,7 @@
+language: go
+go:
+  - 1.7
+  - 1.8
+  - tip
+sudo: false
+

LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2017 Kenta Tsuji
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,32 @@
+# Qiita SDK for Go
+<span style="display: inline-block;">
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+</span>
+
+Qiita API v2 client library written in Golang.
+
+## Install
+```
+go get -u github.com/ktsujichan/qiita-sdk-go
+```
+
+## Library
+```golang
+package main
+
+import (
+	"context"
+	"github.com/ktsujichan/qiita-sdk-go/qiita"
+)
+
+func main() {
+	config := qiita.NewConfig()
+	c, _ := qiita.NewClient("<qiita access token>", *config)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	c.ListItems(ctx, 1, 10, "Golang")
+	c.ListUsers(ctx, 1, 10)
+	c.GetUser(ctx, "r7kamura")
+}
+```

qiita/access_token.go

@@ -0,0 +1,57 @@
+package qiita
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+)
+
+// Access token for Qiita API v2
+type AccessToken struct {
+	ClientId string   `json:"client_id"`
+	Scopes   []string `json:"scopes"`
+	Token    string   `json:"token"`
+}
+
+type Auth struct {
+	ClientId     string `json:"client_id"`
+	ClientSecret string `json:"client_secret"`
+	Code         string `json:"code"`
+}
+
+/*
+	Create a new access token.
+
+	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))
+	if err != nil {
+		return err
+	}
+	if res.StatusCode != http.StatusCreated {
+		return errors.New(res.Status)
+	}
+	return nil
+}
+
+/*
+	DELETE /api/v2/access_tokens/:access_token
+
+	Deactivate an access token.
+*/
+func (c *Client) DeleteAccessToken(ctx context.Context, accessToken string) error {
+	p := fmt.Sprintf("/api/v2/access_tokens/%s", accessToken)
+	res, err := c.delete(ctx, p)
+	if err != nil {
+		return err
+	}
+	if res.StatusCode != http.StatusNoContent {
+		return errors.New(res.Status)
+	}
+	return nil
+}

qiita/access_token_test.go

@@ -0,0 +1,68 @@
+package qiita
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestCreateAccessToken(t *testing.T) {
+	// 201
+	func() {
+		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusCreated)
+			http.ServeFile(w, r, "")
+		}))
+		c, _ := mockClient(server)
+		ctx, _ := context.WithCancel(context.Background())
+		err := c.CreateAccessToken(ctx, Auth{})
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	// 400
+	func() {
+		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusBadRequest)
+			http.ServeFile(w, r, "")
+		}))
+		c, _ := mockClient(server)
+		ctx, _ := context.WithCancel(context.Background())
+		err := c.CreateAccessToken(ctx, Auth{})
+		if err == nil {
+			t.Fail()
+		}
+	}()
+}
+
+func TestDeleteAccessToken(t *testing.T) {
+	// 204
+	func() {
+		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusNoContent)
+			http.ServeFile(w, r, "")
+		}))
+		c, _ := mockClient(server)
+		ctx, _ := context.WithCancel(context.Background())
+		err := c.DeleteAccessToken(ctx, "")
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	// 400
+	func() {
+		server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusBadRequest)
+			http.ServeFile(w, r, "")
+		}))
+		c, _ := mockClient(server)
+		ctx, _ := context.WithCancel(context.Background())
+		err := c.DeleteAccessToken(ctx, "")
+		if err == nil {
+			t.Fail()
+		}
+	}()
+}

qiita/authenticated_user.go

@@ -0,0 +1,35 @@
+package qiita
+
+import (
+	"context"
+	"errors"
+	"net/http"
+)
+
+// An user currently authenticated by a given access token. This resources has more detailed information than normal User resource.
+type AuthenticatedUser struct {
+	*User
+	ImageMonthlyUploadLimit     uint `json:"image_monthly_upload_limit"`
+	ImageMonthlyUploadRemaining uint `json:"image_monthly_upload_remaining"`
+	TeamOnly                    bool `json:"team_only"`
+}
+
+/*
+	Get a user associated to the current access token.
+
+	GET /api/v2/authenticated_user
+*/
+func (c *Client) GetAuthenticatedUser(ctx context.Context) (*AuthenticatedUser, error) {
+	res, err := c.get(ctx, "/api/v2/authenticated_user", nil)
+	if err != nil {
+		return nil, err
+	}
+	if res.StatusCode != http.StatusOK {
+		return nil, errors.New(res.Status)
+	}
+	var authenticatedUser AuthenticatedUser
+	if err := decodeBody(res, &authenticatedUser); err != nil {
+		return nil, err
+	}
+	return &authenticatedUser, nil
+}

qiita/authenticated_user_test.go

@@ -0,0 +1,38 @@
+package qiita
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestGetAuthenticatedUser(t *testing.T) {
+	// 200
+	func() {
+		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")
+		}))
+		c, _ := mockClient(server)
+		ctx, _ := context.WithCancel(context.Background())
+		_, err := c.GetAuthenticatedUser(ctx)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	// 400
+	func() {
+		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")
+		}))
+		c, _ := mockClient(server)
+		ctx, _ := context.WithCancel(context.Background())
+		_, err := c.GetAuthenticatedUser(ctx)
+		if err == nil {
+			t.Fail()
+		}
+	}()
+}

qiita/client.go

@@ -0,0 +1,110 @@
+package qiita
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"path"
+	"runtime"
+)
+
+type Client struct {
+	URL        *url.URL
+	HTTPClient *http.Client
+	Token      string
+}
+
+var userAgent = fmt.Sprintf("QiitaGoClient/%s (%s)", version, runtime.Version())
+
+func NewClient(token string, config Config) (*Client, error) {
+	parsedURL, err := url.ParseRequestURI(config.Endpoint)
+	if err != nil {
+		return nil, err
+	}
+	return &Client{
+		URL:        parsedURL,
+		HTTPClient: &http.Client{},
+		Token:      token,
+	}, nil
+}
+
+func (c *Client) newRequest(ctx context.Context, method, p string, body io.Reader) (*http.Request, error) {
+	u := *c.URL
+	u.Path = path.Join(c.URL.Path, p)
+	req, err := http.NewRequest(method, u.String(), body)
+	if err != nil {
+		return nil, err
+	}
+	req = req.WithContext(ctx)
+	req.Header.Set("Authorization", "Bearer "+c.Token)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("User-Agent", userAgent)
+	return req, nil
+}
+
+func decodeBody(res *http.Response, out interface{}) error {
+	defer res.Body.Close()
+	decoder := json.NewDecoder(res.Body)
+	return decoder.Decode(out)
+}
+
+func (c *Client) url(endpoint string) string {
+	u := *c.URL
+	u.Path = path.Join(c.URL.Path, endpoint)
+	return u.String()
+}
+
+func (c *Client) do(ctx context.Context, req *http.Request) (*http.Response, error) {
+	req.Header.Set("Authorization", "Bearer "+c.Token)
+	req.Header.Set("User-Agent", userAgent)
+	return c.HTTPClient.Do(req)
+}
+
+func (c *Client) get(ctx context.Context, endpoint string, rawQuery *string) (*http.Response, error) {
+	req, err := http.NewRequest("GET", c.url(endpoint), nil)
+	if rawQuery != nil {
+		req.URL.RawQuery = *rawQuery
+	}
+	if err != nil {
+		return nil, err
+	}
+	return c.do(ctx, req)
+}
+
+func (client *Client) post(ctx context.Context, endpoint string, body io.Reader) (*http.Response, error) {
+	req, err := http.NewRequest("POST", client.url(endpoint), body)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
+	return client.do(ctx, req)
+}
+
+func (client *Client) patch(ctx context.Context, endpoint string, body io.Reader) (*http.Response, error) {
+	req, err := http.NewRequest("PATCH", client.url(endpoint), body)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
+	return client.do(ctx, req)
+}
+
+func (client *Client) put(ctx context.Context, endpoint string, body io.Reader) (*http.Response, error) {
+	req, err := http.NewRequest("PUT", client.url(endpoint), body)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
+	return client.do(ctx, req)
+}
+
+func (c *Client) delete(ctx context.Context, endpoint string) (*http.Response, error) {
+	req, err := http.NewRequest("DELETE", c.url(endpoint), nil)
+	if err != nil {
+		return nil, err
+	}
+	return c.do(ctx, req)
+}