wordpress_client 0.0.1

data/spec/integration/categories_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+describe "Categories" do
+  setup_integration_client
+
+  it "is listed on found posts" do
+    post = client.posts(per_page: 1).first
+
+    expect(post.categories).to_not be_empty
+
+    category = post.categories.first
+    expect(category.id).to be_kind_of(Integer)
+    expect(category.name_html).to be_instance_of(String)
+    expect(category.slug).to be_instance_of(String)
+
+    expect(post.category_ids).to eq post.categories.map(&:id)
+  end
+
+  it "can be listed" do
+    categories = client.categories
+    expect(categories.size).to be > 0
+
+    category = categories.first
+    expect(category.id).to be_kind_of(Integer)
+    expect(category.name_html).to be_instance_of(String)
+    expect(category.slug).to be_instance_of(String)
+  end
+
+  it "can be found" do
+    existing = find_existing_category
+    expect(client.find_category(existing.id)).to eq existing
+  end
+
+  it "can be created" do
+    category = client.create_category(name: "New category")
+
+    expect(category.id).to be_kind_of(Integer)
+    expect(category.name_html).to eq "New category"
+    expect(category.slug).to eq "new-category"
+
+    expect(client.categories(per_page: 100).map(&:name_html)).to include "New category"
+  end
+
+  it "can be updated" do
+    existing = find_existing_category
+    client.update_category(existing.id, name: "Updated name")
+    expect(client.find_category(existing.id).name_html).to eq "Updated name"
+  end
+
+  it "uses HTML for the name" do
+    category = client.create_category(name: "Sort & Find")
+    expect(category.name_html).to eq "Sort & Find"
+  end
+
+  def find_existing_category
+    categories = client.categories(per_page: 1)
+    expect(categories).to_not be_empty
+    categories.first
+  end
+end

data/spec/integration/category_assignment_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe "Category assignment" do
+  setup_integration_client
+  let(:existing_post) { find_existing_post }
+
+  it "can be set for multiple categories when creating a post" do
+    category = client.create_category(name: "Assignment test 1")
+    post = client.create_post(category_ids: [category.id], title: "Assignment test")
+
+    expect(post.categories).to eq [category]
+  end
+
+  it "can be changed when updating a post" do
+    category = client.create_category(name: "Assignment test 2")
+    post = find_existing_post
+
+    client.update_post(post.id, category_ids: [category.id])
+
+    post = client.find_post(post.id)
+    expect(post.categories).to eq [category]
+  end
+
+  def find_existing_post
+    posts = client.posts(per_page: 1)
+    expect(posts).to_not be_empty
+    posts.first
+  end
+end

data/spec/integration/posts_crud_spec.rb

@@ -0,0 +1,118 @@
+require "spec_helper"
+
+describe "Posts (CRUD)" do
+  setup_integration_client
+
+  it "can list posts" do
+    posts = client.posts(per_page: 1)
+    expect(posts.size).to be 1
+
+    post = posts.first
+    expect(post).to be_instance_of WordpressClient::Post
+    expect(post.title_html).to be_instance_of(String)
+  end
+
+  it "can get specific posts" do
+    existing_post = find_existing_post
+
+    found_post = client.find_post(existing_post.id)
+    expect(found_post.id).to eq existing_post.id
+    expect(found_post.title_html).to eq existing_post.title_html
+
+    expect { client.find_post(888888) }.to raise_error(WordpressClient::NotFoundError)
+  end
+
+  it "can create a post" do
+    data = {
+      title: "A newly created post",
+      status: "publish",
+    }
+
+    post = client.create_post(data)
+
+    expect(post.id).to be_kind_of Integer
+
+    # Try to find the post to determine if it was persisted or not
+    all_posts = client.posts(per_page: 100)
+    expect(all_posts.map(&:id)).to include post.id
+    expect(all_posts.map(&:title_html)).to include "A newly created post"
+  end
+
+  it "raises a validation error if post could not be created" do
+    expect {
+      client.create_post(status: "not really valid")
+    }.to raise_error(WordpressClient::ValidationError, /status/)
+  end
+
+  it "can update a post" do
+    post = find_existing_post
+
+    client.update_post(post.id, title: "Updated title")
+
+    expect(client.find_post(post.id).title_html).to eq "Updated title"
+  end
+
+  it "raises errors if post could not be updated" do
+    existing_post = find_existing_post
+
+    expect {
+      client.update_post(existing_post.id, status: "not really valid")
+    }.to raise_error(WordpressClient::ValidationError, /status/)
+
+    expect {
+      client.update_post(888888, title: "Never existed in the first place")
+    }.to raise_error(WordpressClient::NotFoundError)
+  end
+
+  it "correctly handles HTML" do
+    post = client.create_post(
+      title: "HTML test & verify",
+      content: '<p class="hello-world">Hello world</p>',
+    )
+
+    expect(post.content_html.strip).to eq '<p class="hello-world">Hello world</p>'
+    expect(post.title_html.strip).to eq 'HTML test &amp; verify'
+  end
+
+  it "can move a post to the trash can" do
+    post = find_existing_post
+
+    expect(
+      client.delete_post(post.id)
+    ).to eq true
+
+    found_post = client.find_post(post.id)
+    expect(found_post.id).to eq post.id
+    expect(found_post.status).to eq "trash"
+  end
+
+  it "can permanently delete a post" do
+    post = find_existing_post
+
+    expect(
+      client.delete_post(post.id, force: true)
+    ).to eq true
+
+    expect {
+      client.find_post(post.id)
+    }.to raise_error(WordpressClient::NotFoundError)
+  end
+
+  it "raises an error when deleting a post that does not exist" do
+    post_id = 99999999
+
+    expect {
+      client.find_post(post_id)
+    }.to raise_error(WordpressClient::NotFoundError)
+
+    expect {
+      client.delete_post(99999999)
+    }.to raise_error(WordpressClient::NotFoundError)
+  end
+
+  def find_existing_post
+    posts = client.posts(per_page: 1)
+    expect(posts).to_not be_empty
+    posts.first
+  end
+end

data/spec/integration/posts_finding_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+describe "Posts (finding)" do
+  setup_integration_client
+
+  it "sorts on publication date by default" do
+    client.create_post(status: "publish", date: "2012-05-05T15:00:00Z", title: "Oldest")
+    client.create_post(status: "publish", date: "2012-06-15T15:00:00Z", title: "Newest")
+    client.create_post(status: "publish", date: "2012-05-20T15:00:00Z", title: "Older")
+
+    posts = client.posts(per_page: 10)
+
+    expect(posts.first.date).to be > posts.last.date
+    expect(posts.map(&:id)).to eq posts.sort_by(&:date).reverse.map(&:id)
+  end
+
+  it "can list articles in a specific category" do
+    category = client.create_category(name: "Filtering time", slug: "filtering")
+    post = client.create_post(
+      category_ids: [category.id],
+      status: "publish",
+      title: "Some title",
+    )
+
+    expect(client.posts(category_slug: "filtering").map(&:id)).to eq [post.id]
+  end
+
+  it "can list articles in a specific tag" do
+    tag = client.create_tag(name: "Taggged", slug: "tagged")
+    post = client.create_post(
+      tag_ids: [tag.id],
+      status: "publish",
+      title: "Some title",
+    )
+
+    expect(client.posts(tag_slug: "tagged").map(&:id)).to eq [post.id]
+  end
+
+  it "can list articles in a specific tag and category" do
+    category = client.create_category(name: "Fishing", slug: "fish")
+    tag = client.create_tag(name: "Soup", slug: "soup")
+    post = client.create_post(
+      category_ids: [category.id],
+      tag_ids: [tag.id],
+      status: "publish",
+      title: "Some title",
+    )
+
+    _post_without_tag = client.create_post(
+      category_ids: [category.id],
+      status: "publish",
+      title: "Some title",
+    )
+
+    _post_without_category = client.create_post(
+      tag_ids: [tag.id],
+      status: "publish",
+      title: "Some title",
+    )
+
+    expect(client.posts(category_slug: "fish", tag_slug: "soup").map(&:id)).to eq [post.id]
+  end
+
+  describe "finding by slug" do
+    it "finds the matching post" do
+      post = client.create_post(title: "Oh hai", slug: "oh-hai")
+      found = client.find_by_slug("oh-hai")
+      expect(found.id).to eq post.id
+    end
+
+    it "raises NotFoundError when no post can be found" do
+      expect {
+        client.find_by_slug("clearly-does-not-exist-anywhere")
+      }.to raise_error(WordpressClient::NotFoundError, /clearly/)
+    end
+
+    it "finds on the slug even if the title is wildly different" do
+      post = client.create_post(
+        title: "Updated title that doesn't match slug",
+        slug: "original-concise-title",
+      )
+      found = client.find_by_slug("original-concise-title")
+      expect(found.id).to eq post.id
+    end
+  end
+end

data/spec/integration/posts_metadata_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe "Post meta" do
+  setup_integration_client
+
+  it "can be set on a post" do
+    post = client.create_post(title: "Metadata creation", meta: {foo: "bar"})
+    expect(post.meta).to eq("foo" => "bar")
+  end
+
+  it "can be updated on a post" do
+    post = client.create_post(title: "Metadata creation", meta: {before: "now"})
+    post = client.update_post(post.id, meta: {"before" => "then", "after" => "now"})
+    expect(post.meta).to eq("before" => "then", "after" => "now")
+  end
+
+  it "can remove metadata for a post" do
+    post = client.create_post(title: "Metadata creation", meta: {one: "1", two: "2", three: "3"})
+    post = client.update_post(post.id, meta: {three: "3", two: nil})
+    expect(post.meta).to eq("three" => "3")
+  end
+
+  it "does not contain HTML data" do
+    post = client.create_post(title: "Metadata HTML", meta: {foo: "bar&baz"})
+    expect(post.meta).to eq("foo" => "bar&baz")
+  end
+end

data/spec/integration/posts_with_attachments_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe "Posts with attachments" do
+  setup_integration_client
+
+  it "exposes featured image as a Media instance" do
+    media = find_or_upload_media
+    post = client.create_post(title: "With media", featured_image: media.id)
+
+    expect(post.featured_image).to be_instance_of(WordpressClient::Media)
+    expect(post.featured_image.slug).to eq media.slug
+    expect(post.featured_image.guid).to eq media.guid
+    expect(post.featured_image.source_url).to eq media.source_url
+    expect(post.featured_image_id).to eq media.id
+  end
+
+  def find_or_upload_media
+    client.media(per_page: 1).first ||
+      client.upload_file(fixture_path("thoughtful.jpg"), mime_type: "image/jpeg")
+  end
+end

data/spec/integration/tag_assignment_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe "Tag assignment" do
+  setup_integration_client
+  let(:existing_post) { find_existing_post }
+
+  it "can be set for multiple tags when creating a post" do
+    tag = client.create_tag(name: "Assignment test 1")
+    post = client.create_post(tag_ids: [tag.id], title: "Assignment test")
+
+    expect(post.tags).to eq [tag]
+  end
+
+  it "can be changed when updating a post" do
+    tag = client.create_tag(name: "Assignment test 2")
+    post = find_existing_post
+
+    client.update_post(post.id, tag_ids: [tag.id])
+
+    post = client.find_post(post.id)
+    expect(post.tags).to eq [tag]
+  end
+
+  def find_existing_post
+    posts = client.posts(per_page: 1)
+    expect(posts).to_not be_empty
+    posts.first
+  end
+end

data/spec/integration/tags_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe "Tags" do
+  setup_integration_client
+
+  it "can be found" do
+    existing = find_or_create_tag
+    expect(client.find_tag(existing.id)).to eq existing
+  end
+
+  it "can be created" do
+    tag = client.create_tag(name: "New tag")
+
+    expect(tag.id).to be_kind_of(Integer)
+    expect(tag.name_html).to eq "New tag"
+    expect(tag.slug).to eq "new-tag"
+
+    expect(client.tags(per_page: 100).map(&:name_html)).to include "New tag"
+  end
+
+  it "can be updated" do
+    existing = find_or_create_tag
+    client.update_tag(existing.id, name: "Updated name")
+    expect(client.find_tag(existing.id).name_html).to eq "Updated name"
+  end
+
+  it "uses HTML for the name" do
+    tag = client.create_tag(name: "Sort & Find")
+    expect(tag.name_html).to eq "Sort & Find"
+  end
+
+  def find_or_create_tag
+    tags = client.tags(per_page: 1)
+    tags.first || client.create_tag(name: "Autocreated")
+  end
+end

data/spec/media_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+module WordpressClient
+  describe Media do
+    let(:fixture) { json_fixture("image-media.json") }
+
+    it "can be parsed from JSON data" do
+      media = Media.parse(fixture)
+
+      expect(media.id).to eq 5
+      expect(media.title_html).to eq "thoughtful"
+      expect(media.slug).to eq "thoughtful"
+      expect(media.description).to eq ""
+
+      expect(media.guid).to eq "http://example.com/wp-content/uploads/2015/11/thoughtful.jpg"
+      expect(media.source_url).to eq "http://example.com/wp-content/uploads/2015/11/thoughtful.jpg"
+      expect(media.link).to eq "http://example.com/?attachment_id=5"
+
+      expect(media.date).to_not be_nil
+      expect(media.updated_at).to_not be_nil
+    end
+
+    it "exposes media information" do
+      expect(Media.parse(fixture).media_details).to eq fixture.fetch("media_details")
+    end
+
+    it "tries to read guid from source_url if guid is not present" do
+      # This happens for associated attachments of posts, for example.
+      fixture.delete("guid")
+      fixture["source_url"] = "http://example.com/image.jpg"
+
+      media = Media.parse(fixture)
+      expect(media.guid).to eq "http://example.com/image.jpg"
+      expect(media.source_url).to eq "http://example.com/image.jpg"
+    end
+
+    describe "dates" do
+      it "uses GMT times if available" do
+        media = Media.parse(fixture.merge(
+          "date_gmt" => "2001-01-01T15:00:00",
+          "date" => "2001-01-01T12:00:00",
+          "modified_gmt" => "2001-01-01T15:00:00",
+          "modified" => "2001-01-01T12:00:00",
+        ))
+
+        expect(media.date).to eq Time.utc(2001, 1, 1, 15, 0, 0)
+        expect(media.updated_at).to eq Time.utc(2001, 1, 1, 15, 0, 0)
+      end
+
+      it "falls back to local time if no GMT date is provided" do
+        media = Media.parse(fixture.merge(
+          "date_gmt" => nil,
+          "date" => "2001-01-01T12:00:00",
+          "modified_gmt" => nil,
+          "modified" => "2001-01-01T12:00:00",
+        ))
+
+        expect(media.date).to eq Time.local(2001, 1, 1, 12, 0, 0)
+        expect(media.updated_at).to eq Time.local(2001, 1, 1, 12, 0, 0)
+      end
+    end
+  end
+end