695 lines
23 KiB
Ruby
695 lines
23 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require "spec_helper"
|
|
|
|
describe Api::V1::PostsController do
|
|
let!(:auth_with_read) { FactoryGirl.create(:auth_with_read) }
|
|
let!(:access_token_with_read) { auth_with_read.create_access_token.to_s }
|
|
|
|
let(:auth_with_read_and_write) {
|
|
FactoryGirl.create(:auth_with_read_and_write)
|
|
}
|
|
let!(:access_token_with_read_and_write) {
|
|
auth_with_read_and_write.create_access_token.to_s
|
|
}
|
|
|
|
let(:alice_aspect) { alice.aspects.first }
|
|
|
|
let(:alice_photo1) {
|
|
alice.build_post(:photo, pending: true, user_file: File.open(photo_fixture_name), to: alice_aspect.id).tap(&:save!)
|
|
}
|
|
|
|
let(:alice_photo2) {
|
|
alice.build_post(:photo, pending: true, user_file: File.open(photo_fixture_name), to: alice_aspect.id).tap(&:save!)
|
|
}
|
|
|
|
let(:alice_photo_ids) { [alice_photo1.id.to_s, alice_photo2.id.to_s] }
|
|
let(:alice_photo_guids) { [alice_photo1.guid, alice_photo2.guid] }
|
|
|
|
describe "#show" do
|
|
before do
|
|
@status = alice.post(
|
|
:status_message,
|
|
text: "hello @{#{bob.diaspora_handle}} and @{#{eve.diaspora_handle}}from Alice!",
|
|
public: true,
|
|
to: "all"
|
|
)
|
|
end
|
|
|
|
context "when mark notifications is omitted" do
|
|
# TODO: Determine if this needs to be added back to the spec or if this is just in the notifications services
|
|
xit "shows attempts to show the info and mark the user notifications" do
|
|
@status = auth_with_read.user.post(
|
|
:status_message,
|
|
text: "hello @{bob Testing ; bob@example.com}",
|
|
public: true,
|
|
to: "all"
|
|
)
|
|
get(
|
|
api_v1_post_path(@status.id),
|
|
params: {access_token: access_token_with_read}
|
|
)
|
|
expect(response.status).to eq(200)
|
|
post = response_body(response)
|
|
expect(post["post_type"]).to eq("StatusMessage")
|
|
expect(post["public"]).to eq(true)
|
|
expect(post["author"]["id"]).to eq(auth_with_read.user.person.id)
|
|
expect(post["interactions"]["comments_count"]).to eq(0)
|
|
|
|
mention_ids = Mention.where(
|
|
mentions_container_id: @status.id,
|
|
mentions_container_type: "Post",
|
|
person_id: bob.person.id
|
|
).ids
|
|
Notification.where(
|
|
recipient_id: bob.person.id,
|
|
target_type: "Mention",
|
|
target_id: mention_ids,
|
|
unread: true
|
|
)
|
|
# expect(notifications.length).to eq(0)
|
|
end
|
|
end
|
|
|
|
context "when mark notifications is false" do
|
|
# TODO: Determine if this needs to be added back to the spec or if this is just in the notifications services
|
|
xit "shows attempts to show the info" do
|
|
@status = auth_with_read.user.post(
|
|
:status_message,
|
|
text: "hello @{bob ; bob@example.com}",
|
|
public: true,
|
|
to: "all"
|
|
)
|
|
|
|
get(
|
|
api_v1_post_path(@status.id),
|
|
params: {
|
|
access_token: access_token_with_read,
|
|
mark_notifications: "false"
|
|
}
|
|
)
|
|
expect(response.status).to eq(200)
|
|
post = response_body(response)
|
|
|
|
expect(post["post_type"]).to eq("StatusMessage")
|
|
expect(post["public"]).to eq(true)
|
|
expect(post["author"]["id"]).to eq(auth_with_read.user.person.id)
|
|
expect(post["interactions"]["comments_count"]).to eq(0)
|
|
|
|
mention_ids = Mention.where(
|
|
mentions_container_id: @status.id,
|
|
mentions_container_type: "Post",
|
|
person_id: bob.person.id
|
|
).ids
|
|
Notification.where(
|
|
recipient_id: bob.person.id,
|
|
target_type: "Mention",
|
|
target_id: mention_ids,
|
|
unread: true
|
|
)
|
|
# expect(notifications.length).to eq(1)
|
|
end
|
|
end
|
|
|
|
context "access simple by post ID" do
|
|
it "gets post" do
|
|
get(
|
|
api_v1_post_path(@status.id),
|
|
params: {
|
|
access_token: access_token_with_read
|
|
}
|
|
)
|
|
expect(response.status).to eq(200)
|
|
post = response_body(response)
|
|
confirm_post_format(post, alice, @status, [bob, eve])
|
|
end
|
|
end
|
|
|
|
context "access full post by post ID" do
|
|
it "gets post" do
|
|
base_params = {status_message: {text: "myText"}, public: true}
|
|
poll_params = {poll_question: "something?", poll_answers: %w[yes no maybe]}
|
|
location_params = {location_address: "somewhere", location_coords: "1,2"}
|
|
merged_params = base_params.merge(location_params)
|
|
merged_params = merged_params.merge(poll_params)
|
|
merged_params = merged_params.merge(photos: alice_photo_ids)
|
|
status_message = StatusMessageCreationService.new(alice).create(merged_params)
|
|
|
|
get(
|
|
api_v1_post_path(status_message.id),
|
|
params: {
|
|
access_token: access_token_with_read
|
|
}
|
|
)
|
|
expect(response.status).to eq(200)
|
|
post = response_body(response)
|
|
confirm_post_format(post, alice, status_message)
|
|
end
|
|
end
|
|
|
|
context "access reshare style post by post ID" do
|
|
it "gets post" do
|
|
reshare_post = FactoryGirl.create(:reshare, root: @status, author: bob.person)
|
|
get(
|
|
api_v1_post_path(reshare_post.id),
|
|
params: {
|
|
access_token: access_token_with_read
|
|
}
|
|
)
|
|
expect(response.status).to eq(200)
|
|
post = response_body(response)
|
|
confirm_reshare_format(post, @status, alice)
|
|
end
|
|
end
|
|
|
|
context "access private post not to reader" do
|
|
it "fails to get post" do
|
|
private_post = alice.post(:status_message, text: "to aspect only", public: false, to: alice.aspects.first.id)
|
|
get(
|
|
api_v1_post_path(private_post.id),
|
|
params: {
|
|
access_token: access_token_with_read
|
|
}
|
|
)
|
|
expect(response.status).to eq(404)
|
|
expect(response.body).to eq(I18n.t("api.endpoint_errors.posts.post_not_found"))
|
|
end
|
|
end
|
|
|
|
context "access post with invalid id" do
|
|
it "fails to get post" do
|
|
get(
|
|
api_v1_post_path("999_999_999"),
|
|
params: {
|
|
access_token: access_token_with_read
|
|
}
|
|
)
|
|
expect(response.status).to eq(404)
|
|
expect(response.body).to eq(I18n.t("api.endpoint_errors.posts.post_not_found"))
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "#create" do
|
|
let(:user_photo1) {
|
|
auth_with_read_and_write.user.build_post(:photo, pending: true,
|
|
user_file: File.open(photo_fixture_name), to: "all").tap(&:save!)
|
|
}
|
|
let(:user_photo2) {
|
|
auth_with_read_and_write.user.build_post(:photo, pending: true,
|
|
user_file: File.open(photo_fixture_name), to: "all").tap(&:save!)
|
|
}
|
|
|
|
let(:user_photo_ids) { [user_photo1.id.to_s, user_photo2.id.to_s] }
|
|
let(:user_photo_guids) { [user_photo1.guid, user_photo2.guid] }
|
|
|
|
context "when given read-write access token" do
|
|
it "creates a public post" do
|
|
post_for_ref_only = auth_with_read_and_write.user.post(
|
|
:status_message,
|
|
text: "Hello this is a public post!",
|
|
public: true,
|
|
to: "all"
|
|
)
|
|
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: "Hello this is a public post!",
|
|
public: true
|
|
}
|
|
)
|
|
expect(response.status).to eq(200)
|
|
post = response_body(response)
|
|
confirm_post_format(post, auth_with_read_and_write.user, post_for_ref_only)
|
|
end
|
|
|
|
it "or creates a private post" do
|
|
aspect = Aspect.find_by(user_id: auth_with_read_and_write.user.id)
|
|
post_for_ref_only = auth_with_read_and_write.user.post(
|
|
:status_message,
|
|
text: "Hello this is a private post!",
|
|
aspect_ids: [aspect[:id]]
|
|
)
|
|
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: "Hello this is a private post!",
|
|
public: false,
|
|
aspects: [aspect[:id]]
|
|
}
|
|
)
|
|
post = response_body(response)
|
|
expect(response.status).to eq(200)
|
|
confirm_post_format(post, auth_with_read_and_write.user, post_for_ref_only)
|
|
end
|
|
end
|
|
|
|
context "with fully populated post" do
|
|
it "creates with photos" do
|
|
message_text = "Post with photos"
|
|
base_params = {status_message: {text: message_text}, public: true}
|
|
merged_params = base_params.merge(photos: user_photo_ids)
|
|
post_for_ref_only = StatusMessageCreationService.new(auth_with_read_and_write.user).create(merged_params)
|
|
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: message_text,
|
|
public: true,
|
|
photos: user_photo_guids
|
|
}
|
|
)
|
|
expect(response.status).to eq(200)
|
|
post = response_body(response)
|
|
confirm_post_format(post, auth_with_read_and_write.user, post_for_ref_only)
|
|
end
|
|
|
|
it "fails to add other's photos" do
|
|
message_text = "Post with photos"
|
|
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: message_text,
|
|
public: true,
|
|
photos: alice_photo_guids
|
|
}
|
|
)
|
|
expect(response.status).to eq(200)
|
|
post = JSON.parse(response.body)
|
|
expect(post["photos"].empty?).to be_truthy
|
|
end
|
|
|
|
it "fails to add bad guid" do
|
|
message_text = "Post with photos"
|
|
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: message_text,
|
|
public: true,
|
|
photos: ["999_999_999"]
|
|
}
|
|
)
|
|
expect(response.status).to eq(422)
|
|
expect(response.body).to eq(I18n.t("api.endpoint_errors.posts.failed_create"))
|
|
end
|
|
|
|
it "creates with poll" do
|
|
message_text = "status with a poll"
|
|
poll_params = {poll_question: "something?", poll_answers: %w[yes no maybe]}
|
|
base_params = {status_message: {text: message_text}, public: true}
|
|
merged_params = base_params.merge(poll_params)
|
|
post_for_ref_only = StatusMessageCreationService.new(auth_with_read_and_write.user).create(merged_params)
|
|
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: message_text,
|
|
public: true,
|
|
poll: {
|
|
question: "something?",
|
|
poll_answers: %w[yes no maybe]
|
|
}
|
|
}
|
|
)
|
|
post = response_body(response)
|
|
expect(response.status).to eq(200)
|
|
confirm_post_format(post, auth_with_read_and_write.user, post_for_ref_only)
|
|
end
|
|
|
|
it "fails poll with no answers" do
|
|
message_text = "status with a poll"
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: message_text,
|
|
public: true,
|
|
poll: {
|
|
question: "something?",
|
|
poll_answers: []
|
|
}
|
|
}
|
|
)
|
|
expect(response.status).to eq(422)
|
|
expect(response.body).to eq(I18n.t("api.endpoint_errors.posts.failed_create"))
|
|
end
|
|
|
|
it "fails poll with blank answer" do
|
|
message_text = "status with a poll"
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: message_text,
|
|
public: true,
|
|
poll: {
|
|
question: "question",
|
|
poll_answers: ["yes", ""]
|
|
}
|
|
}
|
|
)
|
|
expect(response.status).to eq(422)
|
|
expect(response.body).to eq(I18n.t("api.endpoint_errors.posts.failed_create"))
|
|
end
|
|
|
|
it "fails poll with blank question and message text" do
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: "",
|
|
public: true,
|
|
poll: {
|
|
question: "question",
|
|
poll_answers: %w[yes no]
|
|
}
|
|
}
|
|
)
|
|
expect(response.status).to eq(422)
|
|
expect(response.body).to eq(I18n.t("api.endpoint_errors.posts.failed_create"))
|
|
end
|
|
|
|
it "creates with location" do
|
|
message_text = "status with location"
|
|
base_params = {status_message: {text: message_text}, public: true}
|
|
location_params = {location_address: "somewhere", location_coords: "1,2"}
|
|
merged_params = base_params.merge(location_params)
|
|
post_for_ref_only = StatusMessageCreationService.new(auth_with_read_and_write.user).create(merged_params)
|
|
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: message_text,
|
|
public: true,
|
|
location: {
|
|
address: "somewhere",
|
|
lat: 1,
|
|
lng: 2
|
|
}
|
|
}
|
|
)
|
|
post = response_body(response)
|
|
expect(response.status).to eq(200)
|
|
confirm_post_format(post, auth_with_read_and_write.user, post_for_ref_only)
|
|
end
|
|
|
|
it "creates with mentions" do
|
|
message_text = "hello @{#{alice.diaspora_handle}} from Bob!"
|
|
post_for_ref_only = auth_with_read_and_write.user.post(
|
|
:status_message,
|
|
text: message_text,
|
|
public: true
|
|
)
|
|
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: message_text,
|
|
public: true
|
|
}
|
|
)
|
|
post = response_body(response)
|
|
expect(response.status).to eq(200)
|
|
confirm_post_format(post, auth_with_read_and_write.user, post_for_ref_only, [alice])
|
|
end
|
|
end
|
|
|
|
context "when given NSFW hashtag" do
|
|
it "creates NSFW post" do
|
|
message_text = "hello @{#{alice.diaspora_handle}} from Bob but this is #nsfw!"
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: message_text,
|
|
public: true
|
|
}
|
|
)
|
|
expect(response.status).to eq(200)
|
|
post = response_body(response)
|
|
expect(post["nsfw"]).to be_truthy
|
|
end
|
|
end
|
|
|
|
# TODO: Add when doing reshares endpoint
|
|
xcontext "when reshared" do
|
|
it "creates post with identical fields plus root" do
|
|
raise NotImplementedError
|
|
end
|
|
|
|
it "fails to reshare post user can't see" do
|
|
raise NotImplementedError
|
|
end
|
|
end
|
|
|
|
context "when given missing format" do
|
|
it "fails when no body" do
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
public: true
|
|
}
|
|
)
|
|
expect(response.status).to eq(422)
|
|
expect(response.body).to eq(I18n.t("api.endpoint_errors.posts.failed_create"))
|
|
end
|
|
|
|
it "fails when no public field and no aspects" do
|
|
message_text = "hello @{#{alice.diaspora_handle}} from Bob!"
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: message_text
|
|
}
|
|
)
|
|
expect(response.status).to eq(422)
|
|
expect(response.body).to eq(I18n.t("api.endpoint_errors.posts.failed_create"))
|
|
end
|
|
|
|
it "fails when private no aspects" do
|
|
message_text = "hello @{#{alice.diaspora_handle}} from Bob!"
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: message_text,
|
|
public: false
|
|
}
|
|
)
|
|
expect(response.status).to eq(422)
|
|
expect(response.body).to eq(I18n.t("api.endpoint_errors.posts.failed_create"))
|
|
end
|
|
|
|
it "fails when unknown aspect IDs" do
|
|
message_text = "hello @{#{alice.diaspora_handle}} from Bob!"
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: message_text,
|
|
public: false,
|
|
aspects: ["-1"]
|
|
}
|
|
)
|
|
expect(response.status).to eq(422)
|
|
expect(response.body).to eq(I18n.t("api.endpoint_errors.posts.failed_create"))
|
|
end
|
|
|
|
it "fails when no public field but aspects" do
|
|
aspect = Aspect.find_by(user_id: auth_with_read_and_write.user.id)
|
|
message_text = "hello @{#{alice.diaspora_handle}} from Bob!"
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read_and_write,
|
|
body: message_text,
|
|
aspects: [aspect[:id]]
|
|
}
|
|
)
|
|
expect(response.status).to eq(422)
|
|
expect(response.body).to eq(I18n.t("api.endpoint_errors.posts.failed_create"))
|
|
end
|
|
end
|
|
|
|
context "when given read only access token" do
|
|
it "doesn't create the post" do
|
|
post(
|
|
api_v1_posts_path,
|
|
params: {
|
|
access_token: access_token_with_read,
|
|
status_message: {text: "Hello this is a post!"},
|
|
public: true
|
|
}
|
|
)
|
|
expect(response.status).to eq(403)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "#destroy" do
|
|
context "when given read-write access token" do
|
|
it "attempts to destroy the post" do
|
|
@status = auth_with_read_and_write.user.post(
|
|
:status_message,
|
|
text: "hello",
|
|
public: true,
|
|
to: "all"
|
|
)
|
|
delete(
|
|
api_v1_post_path(@status.id),
|
|
params: {access_token: access_token_with_read_and_write}
|
|
)
|
|
expect(response.status).to eq(204)
|
|
end
|
|
end
|
|
|
|
context "when given read only access token" do
|
|
it "doesn't delete the post" do
|
|
@status = auth_with_read.user.post(
|
|
:status_message,
|
|
text: "hello",
|
|
public: true
|
|
)
|
|
delete(
|
|
api_v1_post_path(@status.id),
|
|
params: {access_token: access_token_with_read}
|
|
)
|
|
|
|
expect(response.status).to eq(403)
|
|
end
|
|
end
|
|
|
|
context "when given invalid Post ID" do
|
|
it "doesn't delete a post" do
|
|
delete(
|
|
api_v1_post_path("999_999_999"),
|
|
params: {access_token: access_token_with_read_and_write}
|
|
)
|
|
expect(response.status).to eq(404)
|
|
expect(response.body).to eq(I18n.t("api.endpoint_errors.posts.post_not_found"))
|
|
end
|
|
end
|
|
|
|
context "when PostID refers to another user's post" do
|
|
it "fails to delete post" do
|
|
status = alice.post(
|
|
:status_message,
|
|
text: "hello",
|
|
public: true,
|
|
to: "all"
|
|
)
|
|
|
|
delete(
|
|
api_v1_post_path(status.guid),
|
|
params: {access_token: access_token_with_read_and_write}
|
|
)
|
|
expect(response.status).to eq(403)
|
|
expect(response.body).to eq(I18n.t("api.endpoint_errors.posts.failed_delete"))
|
|
end
|
|
end
|
|
end
|
|
|
|
def response_body(response)
|
|
JSON.parse(response.body)
|
|
end
|
|
|
|
private
|
|
|
|
# rubocop:disable Metrics/AbcSize
|
|
def confirm_post_format(post, user, reference_post, mentions=[])
|
|
confirm_post_top_level(post, reference_post)
|
|
confirm_person_format(post["author"], user)
|
|
confirm_interactions(post["interaction_counters"], reference_post)
|
|
|
|
mentions.each do |mention|
|
|
post_mentions = post["mentioned_people"]
|
|
post_mention = post_mentions.find {|m| m["guid"] == mention.guid }
|
|
confirm_person_format(post_mention, mention)
|
|
end
|
|
|
|
confirm_poll(post["poll"], reference_post.poll, false) if reference_post.poll
|
|
confirm_location(post["location"], reference_post.location) if reference_post.location
|
|
confirm_photos(post["photos"], reference_post.photos) if reference_post.photos
|
|
end
|
|
|
|
def confirm_post_top_level(post, reference_post)
|
|
expect(post.has_key?("guid")).to be_truthy
|
|
expect(post.has_key?("created_at")).to be_truthy
|
|
expect(post["created_at"]).not_to be_nil
|
|
expect(post["title"]).to eq(reference_post.message.title)
|
|
expect(post["body"]).to eq(reference_post.message.plain_text_for_json)
|
|
expect(post["post_type"]).to eq(reference_post.post_type)
|
|
expect(post["provider_display_name"]).to eq(reference_post.provider_display_name)
|
|
expect(post["public"]).to eq(reference_post.public)
|
|
expect(post["nsfw"]).to eq(reference_post.nsfw)
|
|
end
|
|
|
|
def confirm_interactions(interactions, reference_post)
|
|
expect(interactions["comments"]).to eq(reference_post.comments_count)
|
|
expect(interactions["likes"]).to eq(reference_post.likes_count)
|
|
expect(interactions["reshares"]).to eq(reference_post.reshares_count)
|
|
end
|
|
|
|
def confirm_person_format(post_person, user)
|
|
expect(post_person["guid"]).to eq(user.guid)
|
|
expect(post_person["diaspora_id"]).to eq(user.diaspora_handle)
|
|
expect(post_person["name"]).to eq(user.name)
|
|
expect(post_person["avatar"]).to eq(user.profile.image_url)
|
|
end
|
|
|
|
def confirm_poll(post_poll, ref_poll, expected_participation)
|
|
return unless ref_poll
|
|
|
|
expect(post_poll.has_key?("guid")).to be_truthy
|
|
expect(post_poll["participation_count"]).to eq(ref_poll.participation_count)
|
|
expect(post_poll["already_participated"]).to eq(expected_participation)
|
|
expect(post_poll["question"]).to eq(ref_poll.question)
|
|
|
|
answers = post_poll["poll_answers"]
|
|
answers.each do |answer|
|
|
actual_answer = ref_poll.poll_answers.find {|a| a[:answer] == answer["answer"] }
|
|
expect(answer["answer"]).to eq(actual_answer[:answer])
|
|
expect(answer["vote_count"]).to eq(actual_answer[:vote_count])
|
|
end
|
|
end
|
|
|
|
def confirm_location(location, ref_location)
|
|
expect(location["address"]).to eq(ref_location[:address])
|
|
expect(location["lat"]).to eq(ref_location[:lat])
|
|
expect(location["lng"]).to eq(ref_location[:lng])
|
|
end
|
|
|
|
def confirm_photos(photos, ref_photos)
|
|
expect(photos.size).to eq(ref_photos.size)
|
|
photos.each do |photo|
|
|
expect(photo["dimensions"].has_key?("height")).to be_truthy
|
|
expect(photo["dimensions"].has_key?("height")).to be_truthy
|
|
expect(photo["sizes"]["small"]).to be_truthy
|
|
expect(photo["sizes"]["medium"]).to be_truthy
|
|
expect(photo["sizes"]["large"]).to be_truthy
|
|
end
|
|
end
|
|
|
|
def confirm_reshare_format(post, root_post, root_poster)
|
|
root = post["root"]
|
|
expect(root.has_key?("guid")).to be_truthy
|
|
expect(root["guid"]).to eq(root_post[:guid])
|
|
expect(root.has_key?("created_at")).to be_truthy
|
|
confirm_person_format(root["author"], root_poster)
|
|
end
|
|
# rubocop:enable Metrics/AbcSize
|
|
end
|