func TestFetchPostWithResponseStatusError(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(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)
testutil.ShouldExistFile(t, 0)
_, err = model.FetchPost(client, nil, "4bd431809afb1bb99e4f")
if err == nil {
t.Fatal("error should occur")
}
_, ok := err.(api.StatusError)
if !ok {
t.Fatalf("wrong type error: %s", reflect.TypeOf(err))
}
testutil.ShouldExistFile(t, 0)
}
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 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 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 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 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 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 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 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 TestUpdatePostWithNoServer(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
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)
err = os.MkdirAll("mine/2000/01/01", 0755)
if err != nil {
t.Fatal(err)
}
err = ioutil.WriteFile("mine/2000/01/01/Example Title.md", []byte(`<!--
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
- NewTag:
- "1.0"
team: null
-->
# Example Edited Title
## Example Edited Body`), 0664)
if err != nil {
t.Fatal(err)
}
testutil.ShouldExistFile(t, 1)
errBuf := bytes.NewBuffer([]byte{})
app := command.New(inf, client, os.Stdout, errBuf)
app.Run([]string{"qiitactl", "update", "post", "mine/2000/01/01/Example Title.md"})
e := errBuf.Bytes()
if len(e) == 0 {
t.Fatal("error should occur")
}
testutil.ShouldExistFile(t, 1)
}
func TestShowPostsErrors(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
func() {
mux := http.NewServeMux()
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("error should occur")
}
}()
func() {
mux := http.NewServeMux()
handleAuthenticatedUserItems(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("error should occur")
}
}()
func() {
mux := http.NewServeMux()
handleAuthenticatedUserItems(mux)
handleTeams(mux)
serverMine := httptest.NewServer(mux)
defer serverMine.Close()
mux = http.NewServeMux()
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("error should occur")
}
}()
}
func TestPostUpdateInTeam(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
mux.HandleFunc("/api/v2/items/abcdefghijklmnopqrst", func(w http.ResponseWriter, r *http.Request) {
if r.Method != "PATCH" {
w.WriteHeader(405)
b, _ := json.Marshal(api.ResponseError{"method_not_allowed", "Method Not Allowed"})
w.Write(b)
return
}
defer r.Body.Close()
b, err := ioutil.ReadAll(r.Body)
if err != nil {
testutil.ResponseError(w, 500, err)
return
}
if string(b) == "" {
testutil.ResponseAPIError(w, 500, api.ResponseError{
Type: "fatal",
Message: "empty body",
})
return
}
var post model.Post
err = json.Unmarshal(b, &post)
if err != nil {
testutil.ResponseError(w, 500, err)
return
}
post.UpdatedAt = model.Time{Time: time.Date(2016, 2, 1, 12, 51, 42, 0, time.UTC)}
b, err = json.Marshal(post)
if err != nil {
testutil.ResponseError(w, 500, err)
return
}
_, err = w.Write(b)
if err != nil {
testutil.ResponseError(w, 500, err)
return
}
})
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) {
if subDomain != "increments" {
t.Fatalf("wrong sub domain: %s", subDomain)
return
}
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)}, &model.Team{Active: true, ID: "increments", Name: "Increments Inc."})
post.ID = "abcdefghijklmnopqrst"
prevPath := post.Path
if err != nil {
t.Fatal(err)
}
err = post.Update(client)
if err != nil {
t.Fatal(err)
}
postPath := post.Path
if err != nil {
t.Fatal(err)
}
if postPath != prevPath {
t.Errorf("wrong path: expected %s, but actual %s", prevPath, postPath)
}
if !post.UpdatedAt.Equal(time.Date(2016, 2, 1, 12, 51, 42, 0, time.UTC)) {
t.Errorf("wrong UpdatedAt: %s", post.UpdatedAt)
}
testutil.ShouldExistFile(t, 0)
}
func TestPostSaveWithTeam(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)}, &model.Team{Active: true, ID: "increments", Name: "Increments Inc."})
post.ID = "abcdefghijklmnopqrst"
err := post.Save(nil)
if err != nil {
t.Fatal(err)
}
testutil.ShouldExistFile(t, 1)
func() {
a, err := ioutil.ReadFile("increments/2015/11/28/Example Title.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:
active: true
id: increments
name: Increments Inc.
-->
# Example Title
`
if actual != expected {
t.Errorf("wrong content:\n%s", testutil.Diff(expected, actual))
}
}()
post.Title = "Example Edited Title"
post.CreatedAt = model.Time{time.Date(2015, 12, 28, 13, 2, 37, 0, time.UTC)}
post.UpdatedAt = post.CreatedAt
err = post.Save(nil)
if err != nil {
t.Fatal(err)
}
testutil.ShouldExistFile(t, 1)
func() {
_, err := os.Stat("increments/2015/12/28/Example Edited Title.md")
if err == nil {
t.Errorf("filename based on edited post shouldn't exist: %s", "mine/2015/12/28/Example Edited Title.md")
}
}()
func() {
a, err := ioutil.ReadFile("increments/2015/11/28/Example Title.md")
if err != nil {
t.Fatal(err)
}
actual := string(a)
expected := `<!--
id: abcdefghijklmnopqrst
url: ""
created_at: 2015-12-28T22:02:37+09:00
updated_at: 2015-12-28T22:02:37+09:00
private: false
coediting: false
tags: []
team:
active: true
id: increments
name: Increments Inc.
-->
# Example Edited Title
`
if actual != expected {
t.Errorf("wrong content:\n%s", testutil.Diff(expected, actual))
}
}()
}
func TestFetchPost(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
mux.HandleFunc("/api/v2/items/4bd431809afb1bb99e4f", 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
}
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"
}
}`
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)
testutil.ShouldExistFile(t, 0)
team := model.Team{
Active: true,
ID: "increments",
Name: "Increments Inc",
}
post, err := model.FetchPost(client, &team, "4bd431809afb1bb99e4f")
if err != nil {
t.Fatal(err)
}
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])
}
testutil.ShouldExistFile(t, 0)
}
func TestPostCreateWithTweetAndGist(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
mux := http.NewServeMux()
mux.HandleFunc("/api/v2/items", func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
w.WriteHeader(405)
b, _ := json.Marshal(api.ResponseError{"method_not_allowed", "Method Not Allowed"})
w.Write(b)
return
}
defer r.Body.Close()
b, err := ioutil.ReadAll(r.Body)
if err != nil {
testutil.ResponseError(w, 500, err)
return
}
if string(b) == "" {
testutil.ResponseAPIError(w, 500, api.ResponseError{
Type: "fatal",
Message: "empty body",
})
return
}
var post model.CreationPost
err = json.Unmarshal(b, &post)
if err != nil {
testutil.ResponseError(w, 500, err)
return
}
if !post.Tweet || !post.Gist {
testutil.ResponseError(w, 500, errors.New("tweet and gist should be true"))
return
}
post.CreatedAt = model.Time{Time: time.Date(2016, 2, 1, 12, 51, 42, 0, time.UTC)}
post.UpdatedAt = post.CreatedAt
b, err = json.Marshal(post)
if err != nil {
testutil.ResponseError(w, 500, err)
return
}
_, err = w.Write(b)
if err != nil {
testutil.ResponseError(w, 500, err)
return
}
})
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)
prevPath := post.Path
if err != nil {
t.Fatal(err)
}
err = post.Create(client, model.CreationOptions{true, true})
if err != nil {
t.Fatal(err)
}
postPath := post.Path
if err != nil {
t.Fatal(err)
}
if postPath != prevPath {
t.Errorf("wrong path: expected %s, but actual %s", prevPath, postPath)
}
if !post.CreatedAt.Equal(time.Date(2016, 2, 1, 12, 51, 42, 0, time.UTC)) {
t.Errorf("wrong CreatedAt: %s", post.CreatedAt)
}
if !post.UpdatedAt.Equal(time.Date(2016, 2, 1, 12, 51, 42, 0, time.UTC)) {
t.Errorf("wrong UpdatedAt: %s", post.UpdatedAt)
}
testutil.ShouldExistFile(t, 0)
}
func TestPostSaveWithInvalidMarkdown(t *testing.T) {
testutil.CleanUp()
defer testutil.CleanUp()
err := os.MkdirAll("foo", 0755)
if err != nil {
t.Fatal(err)
}
err = ioutil.WriteFile("foo/wrong-format.md", []byte{}, 0644)
if err != nil {
t.Fatal(err)
}
err = ioutil.WriteFile("foo/no-id.md", []byte(`<!--
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
`), 0644)
if err != nil {
t.Fatal(err)
}
if err != nil {
t.Fatal(err)
}
testutil.ShouldExistFile(t, 2)
func() {
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, 3)
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))
}
}()
}