Completed taxonomies

Completed `comments` but unable to test, due to issues with comment creations on the server-side.

Author: sogko

comments.go

@@ -0,0 +1,62 @@
+package wordpress
+
+import (
+	"fmt"
+	"net/http"
+)
+
+type Comment struct {
+	ID              int        `json:"id"`
+	AvatarURL       string     `json:"avatar_url"`
+	AvatarURLs      AvatarURLS `json:"avatar_urls"`
+	Author          int        `json:"author"`
+	AuthorEmail     string     `json:"author_email"`
+	AuthorIP        string     `json:"author_ip"`
+	AuthorName      string     `json:"author_name"`
+	AuthorURL       string     `json:"author_url"`
+	AuthorUserAgent string     `json:"author_user_agent"`
+	Content         Content    `json:"content"`
+	Date            string     `json:"date"`
+	DateGMT         string     `json:"date_gmt"`
+	Karma           int        `json:"karma"`
+	Link            string     `json:"link"`
+	Parent          int        `json:"parent"`
+	Post            int        `json:"post"`
+	Status          string     `json:"status"`
+	Type            string     `json:"type"`
+}
+
+type CommentsCollection struct {
+	client *Client
+	url    string
+}
+
+func (col *CommentsCollection) List(params interface{}) ([]Comment, *http.Response, []byte, error) {
+	var posts []Comment
+	resp, body, err := col.client.List(col.url, params, &posts)
+	return posts, resp, body, err
+}
+func (col *CommentsCollection) Create(new *Comment) (*Comment, *http.Response, []byte, error) {
+	var created Comment
+	resp, body, err := col.client.Create(col.url, new, &created)
+	return &created, resp, body, err
+}
+func (col *CommentsCollection) Get(id int, params interface{}) (*Comment, *http.Response, []byte, error) {
+	var entity Comment
+	entityURL := fmt.Sprintf("%v/%v", col.url, id)
+	resp, body, err := col.client.Get(entityURL, params, &entity)
+	return &entity, resp, body, err
+}
+
+func (col *CommentsCollection) Update(id int, post *Comment) (*Comment, *http.Response, []byte, error) {
+	var updated Comment
+	entityURL := fmt.Sprintf("%v/%v", col.url, id)
+	resp, body, err := col.client.Update(entityURL, post, &updated)
+	return &updated, resp, body, err
+}
+func (col *CommentsCollection) Delete(id int, params interface{}) (*Comment, *http.Response, []byte, error) {
+	var deleted Comment
+	entityURL := fmt.Sprintf("%v/%v", col.url, id)
+	resp, body, err := col.client.Delete(entityURL, params, &deleted)
+	return &deleted, resp, body, err
+}

comments_test.go

@@ -0,0 +1,144 @@
+package wordpress_test
+
+import (
+	"github.com/sogko/go-wordpress"
+	"net/http"
+	"testing"
+	"log"
+)
+
+func factoryComment(postID int) wordpress.Comment {
+	return wordpress.Comment{
+		Post: postID,
+		Author: 1,
+		Status: wordpress.CommentStatusApproved,
+		AuthorName: "go-wordpress",
+		Content: wordpress.Content{
+			Raw: "Test Comment",
+			Rendered: "<p>Test Comment</p>",
+		},
+	}
+}
+
+func cleanUpComment(t *testing.T, commentID int) {
+
+	wp := initTestClient()
+	deletedComment, resp, body, err := wp.Comments().Delete(commentID, "force=true")
+	if err != nil {
+		t.Errorf("Failed to clean up new comment: %v", err.Error())
+	}
+	if body == nil {
+		t.Errorf("body should not be nil")
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("Expected 200 StatusOK, got %v", resp.Status)
+	}
+	if deletedComment.ID != commentID {
+		t.Errorf("Deleted comment ID should be the same as newly created comment: %v != %v", deletedComment.ID, commentID)
+	}
+}
+
+func getAnyOneComment(t *testing.T, wp *wordpress.Client) *wordpress.Comment {
+
+	comments, resp, body, err := wp.Comments().List(nil)
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("Expected 200 OK, got %v", resp.Status)
+	}
+	if len(comments) < 1 {
+		log.Print(err)
+		log.Print(body)
+		log.Print(resp)
+		t.Fatalf("Should not return empty comments")
+	}
+
+	commentID := comments[0].ID
+
+	comment, resp, _, _ := wp.Comments().Get(commentID, "context=edit")
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("Expected 200 OK, got %v", resp.Status)
+	}
+	return comment
+}
+
+func TestCommentsList(t *testing.T) {
+	wp := initTestClient()
+
+	comments, resp, body, err := wp.Comments().List(nil)
+	if err != nil {
+		t.Errorf("Should not return error: %v", err.Error())
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("Expected 200 OK, got %v", resp.Status)
+	}
+	if body == nil {
+		t.Errorf("Should not return nil body")
+	}
+	if comments == nil {
+		t.Errorf("Should not return nil comments")
+	}
+	if len(comments) == 0 {
+		t.Errorf("Should not return empty comments")
+	}
+}
+
+func TestCommentsGet_CommentExists(t *testing.T) {
+	wp := initTestClient()
+
+	c := getAnyOneComment(t, wp)
+
+	comment, resp, body, err := wp.Comments().Get(c.ID, nil)
+	if err != nil {
+		t.Errorf("Should not return error: %v", err.Error())
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("Expected 200 OK, got %v", resp.Status)
+	}
+	if body == nil {
+		t.Errorf("Should not return nil body")
+	}
+	if comment == nil {
+		t.Errorf("Should not return nil comments")
+	}
+}
+
+func TestCommentsGet_CommentDoesNotExists(t *testing.T) {
+	wp := initTestClient()
+
+	comment, resp, body, err := wp.Comments().Get(-1, nil)
+	if err == nil {
+		t.Errorf("Should return error")
+	}
+	if resp.StatusCode != http.StatusNotFound {
+		t.Errorf("Expected 404 Not Found, got %v", resp.Status)
+	}
+	if body == nil {
+		t.Errorf("Should not return nil body")
+	}
+	if comment == nil {
+		t.Errorf("Should not return nil comments")
+	}
+}
+
+func TestCommentsCreate(t *testing.T) {
+	t.Skipf("[TestCommentsCreate] Skipped: there is an issue with creating comments, server returning empty string")
+	wp := initTestClient()
+
+	p := getAnyOnePost(t, wp)
+	c := factoryComment(p.ID)
+
+	newComment, resp, body, err := wp.Comments().Create(&c)
+	if err != nil {
+		t.Errorf("Should not return error: %v", err.Error())
+	}
+	if resp.StatusCode != http.StatusCreated {
+		t.Errorf("Expected 201 Created, got %v", resp.Status)
+	}
+	if body == nil {
+		t.Errorf("Should not return nil body")
+	}
+	if newComment == nil {
+		t.Errorf("Should not return nil newComment")
+	}
+
+	cleanUpComment(t, newComment.ID)
+}

endpoints.md

@@ -12,11 +12,11 @@ List of WP-API REST endpoints and implementation status
 
 ## Comments
 
-- [ ] `GET    /comments`
-- [ ] `POST   /comments`
-- [ ] `GET    /comments/[id]`
-- [ ] `PUT    /comments/[id]`
-- [ ] `DELETE /comments/[id]`
+- [x] `GET    /comments`
+- [x] `POST   /comments` (Untested)
+- [x] `GET    /comments/[id]`
+- [x] `PUT    /comments/[id]`  (Untested)
+- [x] `DELETE /comments/[id]`  (Untested)
 
 ## Meta
 
@@ -94,8 +94,8 @@ List of WP-API REST endpoints and implementation status
 
 ## Taxonomies
 
-- [ ] `GET    /taxonomies`
-- [ ] `GET    /taxonomies/[slug]`
+- [x] `GET    /taxonomies`
+- [x] `GET    /taxonomies/[slug]`
 
 ## Terms
 
@@ -107,6 +107,22 @@ List of WP-API REST endpoints and implementation status
 
 `[tax_base] = "tag" | "category"`
 
+### Tag Terms
+
+- [ ] `GET    /terms/tag`
+- [ ] `POST   /terms/tag]`
+- [ ] `GET    /terms/tag]/[id]`
+- [ ] `PUT    /terms/tag]/[id]`
+- [ ] `DELETE /terms/tag/[id]`
+
+### Category Terms
+
+- [ ] `GET    /terms/category`
+- [ ] `POST   /terms/category]`
+- [ ] `GET    /terms/category]/[id]`
+- [ ] `PUT    /terms/category]/[id]`
+- [ ] `DELETE /terms/category/[id]`
+
 ## Users
 
 - [ ] `GET    /users`

posts.go

@@ -17,6 +17,9 @@ const (
 	CommentStatusOpen   = "open"
 	CommentStatusClosed = "closed"
 
+	CommentStatusApproved= "approved"
+	CommentStatusUnapproved= "unapproved"
+
 	PingStatusOpen   = "open"
 	PingStatusClosed = "closed"
 

taxonomies.go

@@ -0,0 +1,37 @@
+package wordpress
+
+import (
+	"fmt"
+	"net/http"
+)
+
+type Labels struct {
+	Raw      string `json:"raw"`
+	Rendered string `json:"rendered"`
+}
+type Taxonomy struct {
+	Description  string                 `json:"description"`
+	Hierarchical bool                   `json:"hierarchical"`
+	Labels       map[string]interface{} `json:"labels"`
+	Name         string                 `json:"name"`
+	Slug         string                 `json:"slug"`
+	ShowCloud    bool                   `json:"show_cloud"`
+	Types        []string               `json:"types"`
+}
+type TaxonomiesCollection struct {
+	client *Client
+	url    string
+}
+
+func (col *TaxonomiesCollection) List(params interface{}) ([]Taxonomy, *http.Response, []byte, error) {
+	var taxonomies []Taxonomy
+	resp, body, err := col.client.List(col.url, params, &taxonomies)
+	return taxonomies, resp, body, err
+}
+
+func (col *TaxonomiesCollection) Get(slug string, params interface{}) (*Taxonomy, *http.Response, []byte, error) {
+	var taxonomy Taxonomy
+	entityURL := fmt.Sprintf("%v/%v", col.url, slug)
+	resp, body, err := col.client.Get(entityURL, params, &taxonomy)
+	return &taxonomy, resp, body, err
+}

taxonomies_test.go

@@ -0,0 +1,63 @@
+package wordpress_test
+
+import (
+	"net/http"
+	"testing"
+)
+
+func TestTaxonomiesList(t *testing.T) {
+	wp := initTestClient()
+
+	taxonomies, resp, body, err := wp.Taxonomies().List(nil)
+	if err != nil {
+		t.Errorf("Should not return error: %v", err.Error())
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("Expected 200 OK, got %v", resp.Status)
+	}
+	if body == nil {
+		t.Errorf("Should not return nil body")
+	}
+	if taxonomies == nil {
+		t.Errorf("Should not return nil taxonomies")
+	}
+	if len(taxonomies) != 2 {
+		t.Errorf("Should return two taxonomies")
+	}
+}
+
+func TestTaxonomiesGet_TaxonomyExists(t *testing.T) {
+	wp := initTestClient()
+
+	taxonomy, resp, body, err := wp.Taxonomies().Get("post_tag", nil)
+	if err != nil {
+		t.Errorf("Should not return error: %v", err.Error())
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("Expected 200 OK, got %v", resp.Status)
+	}
+	if body == nil {
+		t.Errorf("Should not return nil body")
+	}
+	if taxonomy == nil {
+		t.Errorf("Should not return nil taxonomies")
+	}
+}
+
+func TestTaxonomiesGet_TaxonomyDoesNotExists(t *testing.T) {
+	wp := initTestClient()
+
+	taxonomy, resp, body, err := wp.Taxonomies().Get("RANDOM", nil)
+	if err == nil {
+		t.Errorf("Should return error")
+	}
+	if resp.StatusCode != http.StatusNotFound {
+		t.Errorf("Expected 404 Not Found, got %v", resp.Status)
+	}
+	if body == nil {
+		t.Errorf("Should not return nil body")
+	}
+	if taxonomy == nil {
+		t.Errorf("Should not return nil taxonomies")
+	}
+}