discourse/spec/models/draft_spec.rb

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

300 lines
9.3 KiB
Ruby
Raw Normal View History

# frozen_string_literal: true
RSpec.describe Draft do
fab!(:user) { Fabricate(:user) }
fab!(:post) { Fabricate(:post) }
describe "system user" do
it "can not set drafts" do
# fake a sequence
DraftSequence.create!(user_id: Discourse.system_user.id, draft_key: "abc", sequence: 10)
seq = Draft.set(Discourse.system_user, "abc", 0, { reply: "hi" }.to_json)
expect(seq).to eq(0)
draft = Draft.get(Discourse.system_user, "abc", 0)
expect(draft).to eq(nil)
draft = Draft.get(Discourse.system_user, "abc", 1)
expect(draft).to eq(nil)
end
end
describe "backup_drafts_to_pm_length" do
it "correctly backs up drafts to a personal message" do
SiteSetting.backup_drafts_to_pm_length = 1
draft = { reply: "this is a reply", random_key: "random" }
seq = Draft.set(user, "xyz", 0, draft.to_json)
draft["reply"] = "test" * 100
half_grace = (SiteSetting.editing_grace_period / 2 + 1).seconds
freeze_time half_grace.from_now
seq = Draft.set(user, "xyz", seq, draft.to_json)
draft_post = BackupDraftPost.find_by(user_id: user.id, key: "xyz").post
expect(draft_post.revisions.count).to eq(0)
freeze_time half_grace.from_now
# this should trigger a post revision as 10 minutes have passed
draft["reply"] = "hello"
Draft.set(user, "xyz", seq, draft.to_json)
draft_topic = BackupDraftTopic.find_by(user_id: user.id)
expect(draft_topic.topic.posts_count).to eq(2)
draft_post.reload
expect(draft_post.revisions.count).to eq(1)
end
end
2013-02-25 11:42:20 -05:00
it "can get a draft by user" do
Draft.set(user, "test", 0, "data")
expect(Draft.get(user, "test", 0)).to eq "data"
2013-02-05 14:16:51 -05:00
end
it "uses the user id and key correctly" do
Draft.set(user, "test", 0, "data")
expect(Draft.get(Fabricate.build(:coding_horror), "test", 0)).to eq nil
2013-02-05 14:16:51 -05:00
end
2013-02-25 11:42:20 -05:00
it "should overwrite draft data correctly" do
seq = Draft.set(user, "test", 0, "data")
seq = Draft.set(user, "test", seq, "new data")
expect(Draft.get(user, "test", seq)).to eq "new data"
end
it "should increase the sequence on every save" do
seq = Draft.set(user, "test", 0, "data")
expect(seq).to eq(0)
seq = Draft.set(user, "test", 0, "data")
expect(seq).to eq(1)
2013-02-05 14:16:51 -05:00
end
2013-02-25 11:42:20 -05:00
it "should clear drafts on request" do
Draft.set(user, "test", 0, "data")
Draft.clear(user, "test", 0)
expect(Draft.get(user, "test", 0)).to eq nil
2013-02-05 14:16:51 -05:00
end
it "should cross check with DraftSequence table" do
Draft.set(user, "test", 0, "old")
expect(Draft.get(user, "test", 0)).to eq "old"
DraftSequence.next!(user, "test")
seq = DraftSequence.next!(user, "test")
expect(seq).to eq(2)
expect do Draft.set(user, "test", seq - 1, "error") end.to raise_error(Draft::OutOfSequence)
expect do Draft.set(user, "test", seq + 1, "error") end.to raise_error(Draft::OutOfSequence)
Draft.set(user, "test", seq, "data")
expect(Draft.get(user, "test", seq)).to eq "data"
expect do expect(Draft.get(user, "test", seq - 1)).to eq "data" end.to raise_error(
Draft::OutOfSequence,
)
expect do expect(Draft.get(user, "test", seq + 1)).to eq "data" end.to raise_error(
Draft::OutOfSequence,
)
end
2013-02-25 11:42:20 -05:00
it "should disregard old draft if sequence decreases" do
Draft.set(user, "test", 0, "data")
DraftSequence.next!(user, "test")
Draft.set(user, "test", 1, "hello")
expect do Draft.set(user, "test", 0, "foo") end.to raise_error(Draft::OutOfSequence)
expect do Draft.get(user, "test", 0) end.to raise_error(Draft::OutOfSequence)
expect(Draft.get(user, "test", 1)).to eq "hello"
2013-02-05 14:16:51 -05:00
end
it "should disregard draft sequence if force_save is true" do
Draft.set(user, "test", 0, "data")
DraftSequence.next!(user, "test")
Draft.set(user, "test", 1, "hello")
seq = Draft.set(user, "test", 0, "foo", nil, force_save: true)
expect(seq).to eq(2)
end
it "can cleanup old drafts" do
key = Draft::NEW_TOPIC
2015-06-02 06:27:47 -04:00
Draft.set(user, key, 0, "draft")
Draft.cleanup!
expect(Draft.count).to eq 1
expect(user.user_stat.draft_count).to eq(1)
2015-06-02 06:27:47 -04:00
seq = DraftSequence.next!(user, key)
Draft.set(user, key, seq, "draft")
DraftSequence.update_all("sequence = sequence + 1")
Draft.cleanup!
expect(Draft.count).to eq 0
expect(user.reload.user_stat.draft_count).to eq(0)
Draft.set(Fabricate(:user), Draft::NEW_TOPIC, 0, "draft")
Draft.cleanup!
expect(Draft.count).to eq 1
# should cleanup drafts more than 180 days old
2015-06-03 06:14:00 -04:00
SiteSetting.delete_drafts_older_than_n_days = 180
Draft.last.update_columns(updated_at: 200.days.ago)
Draft.cleanup!
expect(Draft.count).to eq 0
end
it "updates draft count when a draft is created or destroyed" do
Draft.set(Fabricate(:user), Draft::NEW_TOPIC, 0, "data")
messages =
MessageBus.track_publish("/user-drafts/#{user.id}") do
Draft.set(user, Draft::NEW_TOPIC, 0, "data")
end
expect(messages.first.data[:draft_count]).to eq(1)
expect(messages.first.data[:has_topic_draft]).to eq(true)
expect(messages.first.user_ids).to contain_exactly(user.id)
messages =
MessageBus.track_publish("/user-drafts/#{user.id}") { Draft.where(user: user).destroy_all }
expect(messages.first.data[:draft_count]).to eq(0)
expect(messages.first.data[:has_topic_draft]).to eq(false)
expect(messages.first.user_ids).to contain_exactly(user.id)
end
describe "#stream" do
fab!(:public_post) { Fabricate(:post) }
let(:public_topic) { public_post.topic }
let(:stream) { Draft.stream(user: user) }
it "should include the correct number of drafts in the stream" do
Draft.set(user, "test", 0, '{"reply":"hey.","action":"createTopic","title":"Hey"}')
Draft.set(user, "test2", 0, '{"reply":"howdy"}')
expect(stream.count).to eq(2)
end
it "should include the right topic id in a draft reply in the stream" do
Draft.set(user, "topic_#{public_topic.id}", 0, '{"reply":"hi"}')
draft_row = stream.first
expect(draft_row.topic_id).to eq(public_topic.id)
end
it "should include the right draft username in the stream" do
Draft.set(user, "topic_#{public_topic.id}", 0, '{"reply":"hey"}')
draft_row = stream.first
expect(draft_row.user.username).to eq(user.username)
end
end
describe "key expiry" do
2013-02-25 11:42:20 -05:00
it "nukes new topic draft after a topic is created" do
Draft.set(user, Draft::NEW_TOPIC, 0, "my draft")
_t = Fabricate(:topic, user: user, advance_draft: true)
s = DraftSequence.current(user, Draft::NEW_TOPIC)
expect(Draft.get(user, Draft::NEW_TOPIC, s)).to eq nil
expect(Draft.count).to eq 0
2013-02-05 14:16:51 -05:00
end
2013-02-25 11:42:20 -05:00
it "nukes new pm draft after a pm is created" do
Draft.set(user, Draft::NEW_PRIVATE_MESSAGE, 0, "my draft")
t =
Fabricate(
:topic,
user: user,
archetype: Archetype.private_message,
category_id: nil,
advance_draft: true,
)
2013-02-05 14:16:51 -05:00
s = DraftSequence.current(t.user, Draft::NEW_PRIVATE_MESSAGE)
expect(Draft.get(user, Draft::NEW_PRIVATE_MESSAGE, s)).to eq nil
2013-02-05 14:16:51 -05:00
end
2013-02-25 11:42:20 -05:00
it "does not nuke new topic draft after a pm is created" do
Draft.set(user, Draft::NEW_TOPIC, 0, "my draft")
t = Fabricate(:topic, user: user, archetype: Archetype.private_message, category_id: nil)
2013-02-05 14:16:51 -05:00
s = DraftSequence.current(t.user, Draft::NEW_TOPIC)
expect(Draft.get(user, Draft::NEW_TOPIC, s)).to eq "my draft"
2013-02-05 14:16:51 -05:00
end
it "nukes the post draft when a post is created" do
topic = Fabricate(:topic)
Draft.set(user, topic.draft_key, 0, "hello")
p =
PostCreator.new(
user,
raw: Fabricate.build(:post).raw,
topic_id: topic.id,
advance_draft: true,
).create
expect(
Draft.get(p.user, p.topic.draft_key, DraftSequence.current(p.user, p.topic.draft_key)),
).to eq nil
2013-02-05 14:16:51 -05:00
end
it "nukes the post draft when a post is revised" do
Draft.set(post.user, post.topic.draft_key, 0, "hello")
post.revise(post.user, raw: "another test")
s = DraftSequence.current(post.user, post.topic.draft_key)
expect(Draft.get(post.user, post.topic.draft_key, s)).to eq nil
2013-02-05 14:16:51 -05:00
end
it "increases revision each time you set" do
Draft.set(user, "new_topic", 0, "hello")
Draft.set(user, "new_topic", 0, "goodbye")
expect(Draft.find_by(user_id: user.id, draft_key: "new_topic").revisions).to eq(2)
end
it "handles owner switching gracefully" do
draft_seq = Draft.set(user, "new_topic", 0, "hello", _owner = "ABCDEF")
expect(draft_seq).to eq(0)
draft_seq = Draft.set(user, "new_topic", 0, "hello world", _owner = "HIJKL")
expect(draft_seq).to eq(1)
draft_seq = Draft.set(user, "new_topic", 1, "hello world", _owner = "HIJKL")
expect(draft_seq).to eq(2)
end
it "can correctly preload drafts" do
Draft.set(
user,
"#{Draft::EXISTING_TOPIC}#{post.topic_id}",
0,
{ raw: "hello", postId: post.id }.to_json,
)
drafts = Draft.where(user_id: user.id).to_a
Draft.preload_data(drafts, user)
expect(drafts[0].topic_preloaded?).to eq(true)
expect(drafts[0].topic.id).to eq(post.topic_id)
expect(drafts[0].post_preloaded?).to eq(true)
expect(drafts[0].post.id).to eq(post.id)
end
2013-02-05 14:16:51 -05:00
end
end