func TestPostCreateWithNoServer(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
server := httptest.NewServer(mux)
defer server.Close()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
t.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
testutil.ShouldExistFile(t, 0)
post := model.NewPost("Example Title", nil, nil)
err = post.Create(client, model.CreationOptions{})
if err == nil {
t.Fatal("error should occur")
}
testutil.ShouldExistFile(t, 0)
}
func TestFetchPostsWithResponseStatusError(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
mux.HandleFunc("/api/v2/authenticated_user/items", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(500)
})
server := httptest.NewServer(mux)
defer server.Close()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
t.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
_, err = model.FetchPosts(client, nil)
if err == nil {
t.Fatal("error should occur")
}
_, ok := err.(api.StatusError)
if !ok {
t.Fatalf("wrong type error: %s", reflect.TypeOf(err))
}
}
func TestPostDecodeWithWrongTitle(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
var post model.Post
err := post.Decode([]byte(`<!--
id: abcdefghijklmnopqrst
url: http://example.com/mypost
created_at: 2013-12-10T12:29:14+09:00
updated_at: 2015-02-25T09:26:30+09:00
private: true
coediting: false
tags:
- TypeScript
- Docker:
- 1.9
- Go:
- 1.4.3
- 1.5.3
team: null
-->
## Sub title
# Main title
Paragraph
`))
if err == nil {
t.Errorf("should return error with non-object element in tags")
}
}
func TestPostCreateWithWrongResponseBody(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
mux.HandleFunc("/api/v2/items", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Non JSON format")
})
server := httptest.NewServer(mux)
defer server.Close()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
t.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
post := model.NewPost("Example Title", nil, nil)
err = post.Create(client, model.CreationOptions{})
if err == nil {
t.Fatal("error should occur")
}
}
func TestPostSaveDuplicationWithID(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
testutil.ShouldExistFile(t, 0)
func() {
post := model.NewPost("Example Title", &model.Time{time.Date(2015, 11, 28, 13, 2, 37, 0, time.UTC)}, nil)
post.ID = "abcdefghijklmnopqrst"
err := post.Save(nil)
if err != nil {
t.Fatal(err)
}
}()
func() {
post := model.NewPost("Example Title", &model.Time{time.Date(2015, 11, 28, 13, 2, 37, 0, time.UTC)}, nil)
post.ID = "abcdefghijklmnopqrst"
err := post.Save(nil)
if err != nil {
t.Fatal(err)
}
}()
testutil.ShouldExistFile(t, 1)
}
func TestPostDecodeWithMultiComment(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
var post model.Post
err := post.Decode([]byte(`<!--
id: ""
url: ""
created_at: 2016-02-17T13:08:30+09:00
updated_at: 2016-02-17T13:08:30+09:00
private: false
coediting: false
tags:
- Qiita
- Go
team: null
-->
# Example Title
<!--
This is not meta
-->
# This is not title of this post
`))
if err != nil {
t.Fatal(err)
}
}
func TestFetchPostsWitWrongResponseBody(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
mux.HandleFunc("/api/v2/authenticated_user/items", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Non JSON format")
})
server := httptest.NewServer(mux)
defer server.Close()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
t.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
_, err = model.FetchPosts(client, nil)
if err == nil {
t.Fatal("error should occur")
}
}
func TestGenerateUniqueFile(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
log.Fatal(err)
}
client := api.NewClient(nil, inf)
testutil.ShouldExistFile(t, 0)
app := command.New(inf, client, os.Stdout, os.Stderr)
app.Run([]string{"qiitactl", "generate", "file", "Example Title"})
app.Run([]string{"qiitactl", "generate", "file", "Example Title"})
testutil.ShouldExistFile(t, 2)
path := fmt.Sprintf("mine/%s/Example Title.md", time.Now().Format("2006/01/02"))
_, err = os.Stat(path)
if err != nil {
t.Errorf("file should exist at %s", path)
}
path = fmt.Sprintf("mine/%s/Example Title-.md", time.Now().Format("2006/01/02"))
_, err = os.Stat(path)
if err != nil {
t.Errorf("file should exist at %s", path)
}
}
func TestPostDeleteWithWrongResponseBody(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
mux.HandleFunc("/api/v2/items/abcdefghijklmnopqrst", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Non JSON format")
})
server := httptest.NewServer(mux)
defer server.Close()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
t.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
post := model.NewPost("Example Title", nil, nil)
post.ID = "abcdefghijklmnopqrst"
err = post.Delete(client)
// Don't parse response body from DELETE method
if err != nil {
t.Fatal(err)
}
}
func TestClientPost(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
log.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
client.DebugMode(true)
body, _, err := client.Post("", "/echo", "data")
if err != nil {
t.Fatal(err)
}
var b string
err = json.Unmarshal(body, &b)
if err != nil {
t.Fatal(err)
}
if b != "data" {
t.Errorf("wrong body: %s", b)
}
}
func TestPostDeleteWithNoServer(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
server := httptest.NewServer(mux)
defer server.Close()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
t.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
testutil.ShouldExistFile(t, 0)
post := model.NewPost("Example Title", &model.Time{time.Date(2000, 1, 1, 9, 0, 0, 0, time.UTC)}, nil)
post.ID = "abcdefghijklmnopqrst"
err = post.Delete(client)
if err == nil {
t.Fatal("error should occur")
}
testutil.ShouldExistFile(t, 0)
}
func TestFetchPostWithID(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
handleItem(mux)
serverMine := httptest.NewServer(mux)
defer serverMine.Close()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
log.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
switch subDomain {
case "":
url = fmt.Sprintf("%s%s%s", serverMine.URL, "/api/v2", path)
default:
log.Fatalf("wrong sub domain \"%s\"", subDomain)
}
return
}, inf)
testutil.ShouldExistFile(t, 0)
errBuf := bytes.NewBuffer([]byte{})
app := command.New(inf, client, os.Stdout, errBuf)
app.Run([]string{"qiitactl", "fetch", "post", "-i", "4bd431809afb1bb99e4f"})
e := errBuf.Bytes()
if len(e) != 0 {
t.Fatal(string(e))
}
testutil.ShouldExistFile(t, 1)
b, err := ioutil.ReadFile("mine/2000/01/01/Example Title.md")
if err != nil {
t.Fatal(err)
}
actual := string(b)
expected := `<!--
id: 4bd431809afb1bb99e4f
url: https://qiita.com/yaotti/items/4bd431809afb1bb99e4f
created_at: 2000-01-01T09:00:00+09:00
updated_at: 2000-01-01T09:00:00+09:00
private: false
coediting: false
tags:
- Ruby:
- 0.0.1
team: null
-->
# Example Title
## Example body`
if actual != expected {
t.Errorf("wrong body:\n%s", testutil.Diff(expected, actual))
}
}
func TestNewPostWithFileWithNoFile(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
_, err := model.NewPostWithFile("mine/2013/12/10-main-title.md")
if err == nil {
t.Fatal("error should occur")
}
}
func TestResponseError(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
err := api.ResponseError{
Type: "not_found",
Message: "Not found",
}
if err.Error() != "Not found" {
t.Errorf("wrong Error: %s", err.Error())
}
}
func TestStatusError(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
err := api.StatusError{
Code: 404,
Message: "404 Not Found",
}
if err.Error() != "404 Not Found" {
t.Errorf("wrong Error: %s", err.Error())
}
}
func TestShowPosts(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
handleAuthenticatedUserItems(mux)
handleTeams(mux)
serverMine := httptest.NewServer(mux)
defer serverMine.Close()
mux = http.NewServeMux()
handleAuthenticatedUserItemsWithTeam(mux)
serverTeam := httptest.NewServer(mux)
defer serverTeam.Close()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
log.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
switch subDomain {
case "":
url = fmt.Sprintf("%s%s%s", serverMine.URL, "/api/v2", path)
case "increments":
url = fmt.Sprintf("%s%s%s", serverTeam.URL, "/api/v2", path)
default:
log.Fatalf("wrong sub domain \"%s\"", subDomain)
}
return
}, inf)
testutil.ShouldExistFile(t, 0)
buf := bytes.NewBuffer([]byte{})
errBuf := bytes.NewBuffer([]byte{})
app := command.New(inf, client, buf, errBuf)
app.Run([]string{"qiitactl", "show", "posts"})
e := errBuf.Bytes()
if len(e) != 0 {
t.Fatal(string(e))
}
testutil.ShouldExistFile(t, 0)
if string(buf.Bytes()) != `Posts in Qiita:
4bd431809afb1bb99e4f 2000/01/01 Example Title
Posts in Qiita:Team (Increments Inc.):
4bd431809afb1bb99e4t 2015/09/25 Example Title in team
` {
t.Errorf("written text is wrong: %s", buf.Bytes())
}
}
func TestClientProcessWithEmptyToken(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
_, _, err := client.Options("", "/echo", nil)
_, ok := err.(api.EmptyTokenError)
if !ok {
t.Fatal("empty token error should occur")
}
}
func BenchmarkPostsSave(b *testing.B) {
testutil.CleanUp()
defer testutil.CleanUp()
var posts model.Posts
for i := 0; i < b.N; i++ {
posts = append(posts, model.NewPost(fmt.Sprintf("Example Title %d", i), nil, nil))
}
b.ResetTimer()
err := posts.Save()
if err != nil {
b.Fatal(err)
}
}
func TestClientProcessWithStatusError(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
log.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
_, _, err = client.Options("", "/errors/status", nil)
_, ok := err.(api.StatusError)
if !ok {
t.Fatal("status error should occur")
}
}
func TestPostSaveWithPath(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
testutil.ShouldExistFile(t, 0)
post := model.NewPost("Example Title", &model.Time{time.Date(2015, 11, 28, 13, 2, 37, 0, time.UTC)}, nil)
post.ID = "abcdefghijklmnopqrst"
post.Path = "foo/bar.md"
err := post.Save(nil)
if err != nil {
t.Fatal(err)
}
testutil.ShouldExistFile(t, 1)
func() {
a, err := ioutil.ReadFile("foo/bar.md")
if err != nil {
t.Fatal(err)
}
actual := string(a)
expected := `<!--
id: abcdefghijklmnopqrst
url: ""
created_at: 2015-11-28T22:02:37+09:00
updated_at: 2015-11-28T22:02:37+09:00
private: false
coediting: false
tags: []
team: null
-->
# Example Title
`
if actual != expected {
t.Errorf("wrong content:\n%s", testutil.Diff(expected, actual))
}
}()
}
func TestPostUpdateWithEmptyID(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
log.Fatal(err)
}
client := api.NewClient(nil, inf)
testutil.ShouldExistFile(t, 0)
post := model.NewPost("Example Title", nil, nil)
err = post.Update(client)
err, ok := err.(model.EmptyIDError)
if !ok {
t.Fatal("empty ID error should occur")
}
testutil.ShouldExistFile(t, 0)
}
func TestFetchPostWithResponseError(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
mux.HandleFunc("/api/v2/items/4bd431809afb1bb99e4f", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(400)
w.Write([]byte(`{
"message": "Not found",
"type": "not_found"
}`))
})
server := httptest.NewServer(mux)
defer server.Close()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
t.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
testutil.ShouldExistFile(t, 0)
_, err = model.FetchPost(client, nil, "4bd431809afb1bb99e4f")
if err == nil {
t.Fatal("error should occur")
}
_, ok := err.(api.ResponseError)
if !ok {
t.Fatalf("wrong type error: %s", reflect.TypeOf(err))
}
testutil.ShouldExistFile(t, 0)
}
func TestClientDelete(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
log.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
body, _, err := client.Delete("", "/echo", nil)
if err != nil {
t.Fatal(err)
}
if string(body) != fmt.Sprintf("%s /api/v2%s is accepted", "DELETE", "/echo") {
t.Errorf("wrong body: %s", body)
}
}
func TestNewPostWithFileWithWrongFormattedFile(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
err := os.MkdirAll("mine/2013/12", 0755)
if err != nil {
t.Fatal(err)
}
err = ioutil.WriteFile("mine/2013/12/10-main-title.md", []byte(`<!--
id: abcdefghijklmnopqrst
url: http://example.com/mypost
created_at: 2013-12-10T12:29:14+09:00
updated_at: 2015-02-25T09:26:30+09:00
private: true
coediting: false
tags:
- TypeScript
- Docker:
- 1.9
- Go:
- 1.4.3
- 1.5.3
team: null
-->
## Sub title
Paragraph
`), 0644)
if err != nil {
t.Fatal(err)
}
_, err = model.NewPostWithFile("mine/2013/12/10-main-title.md")
if err == nil {
t.Fatal("error should occur")
}
}
func TestFetchPostsWithWrongTotalCount(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
mux.HandleFunc("/api/v2/authenticated_user/items", func(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
w.WriteHeader(405)
b, _ := json.Marshal(api.ResponseError{"method_not_allowed", "Method Not Allowed"})
w.Write(b)
return
}
var posts []model.Post
b, _ := json.Marshal(posts)
w.Header().Set("Total-Count", "dummy")
w.Write(b)
})
server := httptest.NewServer(mux)
defer server.Close()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
t.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
_, err = model.FetchPosts(client, nil)
if err == nil {
t.Fatal("error should occur")
}
}
func TestFetchPostWithWrongID(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
handleItem(mux)
serverMine := httptest.NewServer(mux)
defer serverMine.Close()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
log.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
switch subDomain {
case "":
url = fmt.Sprintf("%s%s%s", serverMine.URL, "/api/v2", path)
default:
log.Fatalf("wrong sub domain \"%s\"", subDomain)
}
return
}, inf)
testutil.ShouldExistFile(t, 0)
buf := bytes.NewBuffer([]byte{})
errBuf := bytes.NewBuffer([]byte{})
app := command.New(inf, client, buf, errBuf)
app.Run([]string{"qiitactl", "fetch", "post", "-i", "XXXXXXXXXXXXXXXXXXXX"})
e := errBuf.Bytes()
actual := string(e)
expected := "404 Not Found\n"
if actual != expected {
t.Fatalf("error should occur when fetches post with wrong ID: %s", actual)
}
testutil.ShouldExistFile(t, 0)
}
func TestMain(m *testing.M) {
code := m.Run()
testutil.CleanUp()
os.Exit(code)
}
func TestPostsSave(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
post0 := model.NewPost("Example Title 0", &model.Time{time.Date(2015, 11, 28, 13, 2, 37, 0, time.UTC)}, nil)
post1 := model.NewPost("Example Title 1", &model.Time{time.Date(2016, 2, 1, 5, 21, 49, 0, time.UTC)}, nil)
posts := model.Posts{post0, post1}
err := posts.Save()
if err != nil {
t.Fatal(err)
}
func() {
a, err := ioutil.ReadFile("mine/2015/11/28/Example Title 0.md")
if err != nil {
t.Fatal(err)
}
actual := string(a)
expected := `<!--
id: ""
url: ""
created_at: 2015-11-28T22:02:37+09:00
updated_at: 2015-11-28T22:02:37+09:00
private: false
coediting: false
tags: []
team: null
-->
# Example Title 0
`
if actual != expected {
t.Errorf("wrong content:\n%s", testutil.Diff(expected, actual))
}
}()
func() {
a, err := ioutil.ReadFile("mine/2016/02/01/Example Title 1.md")
if err != nil {
t.Fatal(err)
}
actual := string(a)
expected := `<!--
id: ""
url: ""
created_at: 2016-02-01T14:21:49+09:00
updated_at: 2016-02-01T14:21:49+09:00
private: false
coediting: false
tags: []
team: null
-->
# Example Title 1
`
if actual != expected {
t.Errorf("wrong content:\n%s", testutil.Diff(expected, actual))
}
}()
}
func TestFetchPostsWithTotalCount(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
mux.HandleFunc("/api/v2/authenticated_user/items", func(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
w.WriteHeader(405)
b, _ := json.Marshal(api.ResponseError{"method_not_allowed", "Method Not Allowed"})
w.Write(b)
return
}
total := 1422
q := r.URL.Query()
perPage, err := strconv.Atoi(q.Get("per_page"))
if err != nil {
perPage = 10
}
page, err := strconv.Atoi(q.Get("page"))
if err != nil {
page = 1
}
var posts []model.Post
from := perPage*(page-1) + 1
if from <= total {
to := perPage * page
if to > total {
to = total
}
for i := from; i <= to; i++ {
post := model.Post{Meta: model.Meta{ID: fmt.Sprint(i)}}
posts = append(posts, post)
}
} else {
testutil.ResponseError(w, 500, fmt.Errorf("shouldn't access over total count"))
return
}
b, _ := json.Marshal(posts)
w.Header().Set("Total-Count", fmt.Sprint(total))
w.Write(b)
})
server := httptest.NewServer(mux)
defer server.Close()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
t.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
team := model.Team{
Active: true,
ID: "increments",
Name: "Increments Inc",
}
posts, err := model.FetchPosts(client, &team)
if err != nil {
t.Fatal(err)
}
if len(posts) != 1422 {
t.Errorf("wrong posts length: %d", len(posts))
}
}
func TestFetchPosts(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
mux.HandleFunc("/api/v2/authenticated_user/items", func(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
w.WriteHeader(405)
b, _ := json.Marshal(api.ResponseError{"method_not_allowed", "Method Not Allowed"})
w.Write(b)
return
}
var body string
if r.URL.Query().Get("page") == "1" {
body = `[
{
"rendered_body": "<h2>Example body</h2>",
"body": "## Example body",
"coediting": false,
"created_at": "2000-01-01T00:00:00+00:00",
"id": "4bd431809afb1bb99e4f",
"private": false,
"tags": [
{
"name": "Ruby",
"versions": [
"0.0.1"
]
}
],
"title": "Example title",
"updated_at": "2000-01-01T00:00:00+00:00",
"url": "https://qiita.com/yaotti/items/4bd431809afb1bb99e4f",
"user": {
"description": "Hello, world.",
"facebook_id": "yaotti",
"followees_count": 100,
"followers_count": 200,
"github_login_name": "yaotti",
"id": "yaotti",
"items_count": 300,
"linkedin_id": "yaotti",
"location": "Tokyo, Japan",
"name": "Hiroshige Umino",
"organization": "Increments Inc",
"permanent_id": 1,
"profile_image_url": "https://si0.twimg.com/profile_images/2309761038/1ijg13pfs0dg84sk2y0h_normal.jpeg",
"twitter_screen_name": "yaotti",
"website_url": "http://yaotti.hatenablog.com"
}
}
]`
} else {
testutil.ResponseError(w, 500, fmt.Errorf("shouldn't access over total count"))
return
}
w.Header().Set("Total-Count", fmt.Sprint(1))
w.Write([]byte(body))
})
server := httptest.NewServer(mux)
defer server.Close()
err := os.Setenv("QIITA_ACCESS_TOKEN", "XXXXXXXXXXXX")
if err != nil {
t.Fatal(err)
}
client := api.NewClient(func(subDomain, path string) (url string) {
url = fmt.Sprintf("%s%s%s", server.URL, "/api/v2", path)
return
}, inf)
team := model.Team{
Active: true,
ID: "increments",
Name: "Increments Inc",
}
posts, err := model.FetchPosts(client, &team)
if err != nil {
t.Fatal(err)
}
if len(posts) != 1 {
t.Fatalf("wrong length: expected %d, but actual %d", 1, len(posts))
}
post := posts[0]
if post.RenderedBody != "<h2>Example body</h2>" {
t.Errorf("wrong RenderedBody: %s", post.RenderedBody)
}
if post.Body != "## Example body" {
t.Errorf("wrong Body: %s", post.Body)
}
if post.Coediting != false {
t.Errorf("wrong Coediting: %b", post.Coediting)
}
if !post.CreatedAt.Equal(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)) {
t.Errorf("wrong CreatedAt: %s", post.CreatedAt)
}
if post.ID != "4bd431809afb1bb99e4f" {
t.Errorf("wrong ID: %s", post.ID)
}
if post.Private != false {
t.Errorf("wrong Private: %b", post.Private)
}
if post.Title != "Example title" {
t.Errorf("wrong Title: %s", post.Title)
}
if !post.UpdatedAt.Equal(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)) {
t.Errorf("wrong UpdatedAt: %s", post.UpdatedAt)
}
if post.URL != "https://qiita.com/yaotti/items/4bd431809afb1bb99e4f" {
t.Errorf("wrong URL: %s", post.URL)
}
if post.User.Description != "Hello, world." {
t.Errorf("wrong Description: %s", post.User.Description)
}
if post.User.FacebookID != "yaotti" {
t.Errorf("wrong FacebookId: %s", post.User.FacebookID)
}
if post.User.FolloweesCount != 100 {
t.Errorf("wrong FolloweesCount: %s", post.User.FolloweesCount)
}
if post.User.FollowersCount != 200 {
t.Errorf("wrong FollowersCount: %s", post.User.FollowersCount)
}
if post.User.GithubLoginName != "yaotti" {
t.Errorf("wrong GithubLoginName: %s", post.User.GithubLoginName)
}
if post.User.ID != "yaotti" {
t.Errorf("wrong Id: %s", post.User.ID)
}
if post.User.ItemsCount != 300 {
t.Errorf("wrong ItemsCount: %d", post.User.ItemsCount)
}
if post.User.LinkedinID != "yaotti" {
t.Errorf("wrong LinkedinId: %s", post.User.LinkedinID)
}
if post.User.Location != "Tokyo, Japan" {
t.Errorf("wrong Location: %s", post.User.Location)
}
if post.User.Name != "Hiroshige Umino" {
t.Errorf("wrong Name: %s", post.User.Name)
}
if post.User.Organization != "Increments Inc" {
t.Errorf("wrong Organization: %s", post.User.Organization)
}
if post.User.PermanentID != 1 {
t.Errorf("wrong PermanentId: %d", post.User.PermanentID)
}
if post.User.ProfileImageURL != "https://si0.twimg.com/profile_images/2309761038/1ijg13pfs0dg84sk2y0h_normal.jpeg" {
t.Errorf("wrong ProfileImageUrl: %s", post.User.ProfileImageURL)
}
if post.User.TwitterScreenName != "yaotti" {
t.Errorf("wrong TwitterScreenName: %s", post.User.TwitterScreenName)
}
if post.User.WebsiteURL != "http://yaotti.hatenablog.com" {
t.Errorf("wrong WebsiteUrl: %s", post.User.WebsiteURL)
}
if len(post.Tags) != 1 {
t.Fatalf("wrong Tags length: %d", len(post.Tags))
}
if post.Tags[0].Name != "Ruby" {
t.Errorf("wrong tag Name: %s", post.Tags[0].Name)
}
if len(post.Tags[0].Versions) != 1 {
t.Fatalf("wrong tag Versions length: %d", len(post.Tags[0].Versions))
}
if post.Tags[0].Versions[0] != "0.0.1" {
t.Errorf("wrong tag Versions: %s", post.Tags[0].Versions[0])
}
}