mirror of
https://github.com/codeninjasllc/discourse.git
synced 2024-11-30 19:08:10 -05:00
386 lines
13 KiB
Ruby
386 lines
13 KiB
Ruby
# -*- encoding : utf-8 -*-
|
|
|
|
require 'spec_helper'
|
|
require 'email/receiver'
|
|
|
|
describe Email::Receiver do
|
|
|
|
before do
|
|
SiteSetting.stubs(:reply_by_email_address).returns("reply+%{reply_key}@appmail.adventuretime.ooo")
|
|
SiteSetting.stubs(:email_in).returns(false)
|
|
end
|
|
|
|
describe 'invalid emails' do
|
|
it "raises EmptyEmailError if the message is blank" do
|
|
expect { Email::Receiver.new("").process }.to raise_error(Email::Receiver::EmptyEmailError)
|
|
end
|
|
|
|
it "raises EmptyEmailError if the message is not an email" do
|
|
expect { Email::Receiver.new("asdf" * 30).process}.to raise_error(Email::Receiver::EmptyEmailError)
|
|
end
|
|
|
|
it "raises EmailUnparsableError if there is no reply content" do
|
|
expect { Email::Receiver.new(fixture_file("emails/no_content_reply.eml")).process}.to raise_error(Email::Receiver::EmailUnparsableError)
|
|
end
|
|
end
|
|
|
|
describe "with multipart" do
|
|
let(:reply_below) { fixture_file("emails/multipart.eml") }
|
|
let(:receiver) { Email::Receiver.new(reply_below) }
|
|
|
|
it "processes correctly" do
|
|
expect { receiver.process}.to raise_error(Email::Receiver::EmailLogNotFound)
|
|
expect(receiver.body).to eq(
|
|
"So presumably all the quoted garbage and my (proper) signature will get
|
|
stripped from my reply?")
|
|
end
|
|
end
|
|
|
|
describe "html only" do
|
|
let(:reply_below) { fixture_file("emails/html_only.eml") }
|
|
let(:receiver) { Email::Receiver.new(reply_below) }
|
|
|
|
it "processes correctly" do
|
|
expect { receiver.process}.to raise_error(Email::Receiver::EmailLogNotFound)
|
|
expect(receiver.body).to eq("The EC2 instance - I've seen that there tends to be odd and " +
|
|
"unrecommended settings on the Bitnami installs that I've checked out.")
|
|
end
|
|
end
|
|
|
|
describe "it supports a dutch reply" do
|
|
let(:dutch) { fixture_file("emails/dutch.eml") }
|
|
let(:receiver) { Email::Receiver.new(dutch) }
|
|
|
|
it "processes correctly" do
|
|
expect { receiver.process}.to raise_error(Email::Receiver::EmailLogNotFound)
|
|
expect(receiver.body).to eq("Dit is een antwoord in het Nederlands.")
|
|
end
|
|
end
|
|
|
|
describe "It supports a non english reply" do
|
|
let(:hebrew) { fixture_file("emails/hebrew.eml") }
|
|
let(:receiver) { Email::Receiver.new(hebrew) }
|
|
|
|
it "processes correctly" do
|
|
I18n.expects(:t).with('user_notifications.previous_discussion').returns('כלטוב')
|
|
expect { receiver.process}.to raise_error(Email::Receiver::EmailLogNotFound)
|
|
expect(receiver.body).to eq("שלום")
|
|
end
|
|
end
|
|
|
|
describe "It supports a non UTF-8 reply" do
|
|
let(:big5) { fixture_file("emails/big5.eml") }
|
|
let(:receiver) { Email::Receiver.new(big5) }
|
|
|
|
it "processes correctly" do
|
|
I18n.expects(:t).with('user_notifications.previous_discussion').returns('媽！我上電視了！')
|
|
expect { receiver.process}.to raise_error(Email::Receiver::EmailLogNotFound)
|
|
expect(receiver.body).to eq("媽！我上電視了！")
|
|
end
|
|
end
|
|
|
|
describe "via" do
|
|
let(:wrote) { fixture_file("emails/via_line.eml") }
|
|
let(:receiver) { Email::Receiver.new(wrote) }
|
|
|
|
it "removes via lines if we know them" do
|
|
expect { receiver.process}.to raise_error(Email::Receiver::EmailLogNotFound)
|
|
expect(receiver.body).to eq("Hello this email has content!")
|
|
end
|
|
end
|
|
|
|
describe "if wrote is on a second line" do
|
|
let(:wrote) { fixture_file("emails/multiline_wrote.eml") }
|
|
let(:receiver) { Email::Receiver.new(wrote) }
|
|
|
|
it "processes correctly" do
|
|
expect { receiver.process}.to raise_error(Email::Receiver::EmailLogNotFound)
|
|
expect(receiver.body).to eq("Thanks!")
|
|
end
|
|
end
|
|
|
|
describe "remove previous discussion" do
|
|
let(:previous) { fixture_file("emails/previous.eml") }
|
|
let(:receiver) { Email::Receiver.new(previous) }
|
|
|
|
it "processes correctly" do
|
|
expect { receiver.process}.to raise_error(Email::Receiver::EmailLogNotFound)
|
|
expect(receiver.body).to eq("This will not include the previous discussion that is present in this email.")
|
|
end
|
|
end
|
|
|
|
describe "multiple paragraphs" do
|
|
let(:paragraphs) { fixture_file("emails/paragraphs.eml") }
|
|
let(:receiver) { Email::Receiver.new(paragraphs) }
|
|
|
|
it "processes correctly" do
|
|
expect { receiver.process}.to raise_error(Email::Receiver::EmailLogNotFound)
|
|
expect(receiver.body).to eq(
|
|
"Is there any reason the *old* candy can't be be kept in silos while the new candy
|
|
is imported into *new* silos?
|
|
|
|
The thing about candy is it stays delicious for a long time -- we can just keep
|
|
it there without worrying about it too much, imo.
|
|
|
|
Thanks for listening.")
|
|
end
|
|
end
|
|
|
|
describe "with a valid email" do
|
|
let(:reply_key) { "59d8df8370b7e95c5a49fbf86aeb2c93" }
|
|
let(:valid_reply) { fixture_file("emails/valid_reply.eml") }
|
|
let(:receiver) { Email::Receiver.new(valid_reply) }
|
|
let(:post) { Fabricate.build(:post) }
|
|
let(:user) { Fabricate.build(:user) }
|
|
let(:email_log) { EmailLog.new(reply_key: reply_key, post_id: 1234, topic_id: 4567, user_id: 6677, post: post, user: user ) }
|
|
let(:reply_body) {
|
|
"I could not disagree more. I am obviously biased but adventure time is the
|
|
greatest show ever created. Everyone should watch it.
|
|
|
|
- Jake out" }
|
|
|
|
describe "email with non-existant email log" do
|
|
|
|
before do
|
|
EmailLog.expects(:for).returns(nil)
|
|
end
|
|
|
|
it "raises EmailLogNotFoundError" do
|
|
expect{ receiver.process }.to raise_error(Email::Receiver::EmailLogNotFound)
|
|
end
|
|
|
|
end
|
|
|
|
describe "with an email log" do
|
|
|
|
before do
|
|
EmailLog.expects(:for).with(reply_key).returns(email_log)
|
|
|
|
creator = mock
|
|
PostCreator.expects(:new).with(instance_of(User),
|
|
has_entries(raw: reply_body,
|
|
cooking_options: {traditional_markdown_linebreaks: true}))
|
|
.returns(creator)
|
|
|
|
creator.expects(:create)
|
|
end
|
|
|
|
let!(:result) { receiver.process }
|
|
|
|
it "extracts the body" do
|
|
expect(receiver.body).to eq(reply_body)
|
|
end
|
|
|
|
it "looks up the email log" do
|
|
expect(receiver.email_log).to eq(email_log)
|
|
end
|
|
|
|
it "extracts the key" do
|
|
expect(receiver.reply_key).to eq(reply_key)
|
|
end
|
|
|
|
end
|
|
|
|
describe "email with attachments" do
|
|
|
|
it "can find the message and create a post" do
|
|
user.id = -1
|
|
User.stubs(:find_by_email).returns(user)
|
|
EmailLog.stubs(:for).returns(email_log)
|
|
attachment_email = fixture_file("emails/attachment.eml")
|
|
r = Email::Receiver.new(attachment_email)
|
|
r.expects(:create_post)
|
|
expect { r.process }.to_not raise_error
|
|
expect(r.body).to match(/here is an image attachment\n<img src='\/uploads\/default\/\d+\/\w{16}\.png' width='289' height='126'>\n/)
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
describe "processes an email to a category" do
|
|
before do
|
|
SiteSetting.stubs(:email_in).returns(true)
|
|
end
|
|
|
|
let(:incoming_email) { fixture_file("emails/valid_incoming.eml") }
|
|
let(:receiver) { Email::Receiver.new(incoming_email) }
|
|
let(:user) { Fabricate.build(:user, id: 3456) }
|
|
let(:category) { Fabricate.build(:category, id: 10) }
|
|
let(:subject) { "We should have a post-by-email-feature." }
|
|
let(:email_body) {
|
|
"Hey folks,
|
|
|
|
I was thinking. Wouldn't it be great if we could post topics via email? Yes it would!
|
|
|
|
Jakie" }
|
|
|
|
describe "category not found" do
|
|
|
|
before do
|
|
Category.expects(:find_by_email).returns(nil)
|
|
end
|
|
|
|
it "raises EmailLogNotFoundError" do
|
|
expect{ receiver.process }.to raise_error(Email::Receiver::EmailLogNotFound)
|
|
end
|
|
|
|
end
|
|
|
|
describe "email from non user" do
|
|
|
|
before do
|
|
User.expects(:find_by_email).returns(nil)
|
|
Category.expects(:find_by_email).with(
|
|
"discourse-in@appmail.adventuretime.ooo").returns(category)
|
|
end
|
|
|
|
it "raises UserNotFoundError" do
|
|
expect{ receiver.process }.to raise_error(Email::Receiver::UserNotFoundError)
|
|
end
|
|
|
|
end
|
|
|
|
describe "email from untrusted user" do
|
|
before do
|
|
User.expects(:find_by_email).with(
|
|
"jake@adventuretime.ooo").returns(user)
|
|
Category.expects(:find_by_email).with(
|
|
"discourse-in@appmail.adventuretime.ooo").returns(category)
|
|
SiteSetting.stubs(:email_in_min_trust).returns(TrustLevel.levels[:elder].to_s)
|
|
end
|
|
|
|
it "raises untrusted user error" do
|
|
expect { receiver.process }.to raise_error(Email::Receiver::UserNotSufficientTrustLevelError)
|
|
end
|
|
|
|
end
|
|
|
|
describe "with proper user" do
|
|
|
|
before do
|
|
SiteSetting.stubs(:email_in_min_trust).returns(
|
|
TrustLevel.levels[:newuser].to_s)
|
|
User.expects(:find_by_email).with(
|
|
"jake@adventuretime.ooo").returns(user)
|
|
Category.expects(:find_by_email).with(
|
|
"discourse-in@appmail.adventuretime.ooo").returns(category)
|
|
|
|
topic_creator = mock()
|
|
TopicCreator.expects(:new).with(instance_of(User),
|
|
instance_of(Guardian),
|
|
has_entries(title: subject,
|
|
category: 10)) # Make sure it is posted to the right category
|
|
.returns(topic_creator)
|
|
|
|
topic_creator.expects(:create).returns(topic_creator)
|
|
topic_creator.expects(:id).twice.returns(12345)
|
|
|
|
|
|
post_creator = mock
|
|
PostCreator.expects(:new).with(instance_of(User),
|
|
has_entries(raw: email_body,
|
|
topic_id: 12345,
|
|
cooking_options: {traditional_markdown_linebreaks: true}))
|
|
.returns(post_creator)
|
|
|
|
post_creator.expects(:create)
|
|
|
|
EmailLog.expects(:create).with(has_entries(
|
|
email_type: 'topic_via_incoming_email',
|
|
to_address: "discourse-in@appmail.adventuretime.ooo",
|
|
user_id: 3456,
|
|
topic_id: 12345
|
|
))
|
|
end
|
|
|
|
let!(:result) { receiver.process }
|
|
|
|
it "extracts the body" do
|
|
expect(receiver.body).to eq(email_body)
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
describe "processes an unknown email sender to category" do
|
|
before do
|
|
SiteSetting.stubs(:email_in).returns(true)
|
|
end
|
|
|
|
let(:incoming_email) { fixture_file("emails/valid_incoming.eml") }
|
|
let(:receiver) { Email::Receiver.new(incoming_email) }
|
|
let(:non_inbox_email_category) { Fabricate.build(:category, id: 20, email_in_allow_strangers: false) }
|
|
let(:public_inbox_email_category) { Fabricate.build(:category, id: 25, email_in_allow_strangers: true) }
|
|
let(:subject) { "We should have a post-by-email-feature." }
|
|
let(:email_body) { "[quote=\"jake@adventuretime.ooo\"]
|
|
Hey folks,
|
|
|
|
I was thinking. Wouldn't it be great if we could post topics via email? Yes it would!
|
|
|
|
Jakie
|
|
[/quote]" }
|
|
|
|
describe "to disabled category" do
|
|
before do
|
|
User.expects(:find_by_email).with(
|
|
"jake@adventuretime.ooo").returns(nil)
|
|
Category.expects(:find_by_email).with(
|
|
"discourse-in@appmail.adventuretime.ooo").returns(non_inbox_email_category)
|
|
end
|
|
|
|
it "raises UserNotFoundError" do
|
|
expect{ receiver.process }.to raise_error(Email::Receiver::UserNotFoundError)
|
|
end
|
|
|
|
end
|
|
|
|
describe "to enabled category" do
|
|
|
|
before do
|
|
User.expects(:find_by_email).with(
|
|
"jake@adventuretime.ooo").returns(nil)
|
|
Category.expects(:find_by_email).with(
|
|
"discourse-in@appmail.adventuretime.ooo").returns(public_inbox_email_category)
|
|
|
|
topic_creator = mock()
|
|
TopicCreator.expects(:new).with(Discourse.system_user,
|
|
instance_of(Guardian),
|
|
has_entries(title: subject,
|
|
category: 25)) # Make sure it is posted to the right category
|
|
.returns(topic_creator)
|
|
|
|
topic_creator.expects(:create).returns(topic_creator)
|
|
topic_creator.expects(:id).twice.returns(135)
|
|
|
|
|
|
post_creator = mock
|
|
PostCreator.expects(:new).with(Discourse.system_user,
|
|
has_entries(raw: email_body,
|
|
topic_id: 135,
|
|
cooking_options: {traditional_markdown_linebreaks: true}))
|
|
.returns(post_creator)
|
|
|
|
post_creator.expects(:create)
|
|
|
|
EmailLog.expects(:create).with(has_entries(
|
|
email_type: 'topic_via_incoming_email',
|
|
to_address: "discourse-in@appmail.adventuretime.ooo",
|
|
user_id: Discourse.system_user.id,
|
|
topic_id: 135
|
|
))
|
|
end
|
|
|
|
let!(:result) { receiver.process }
|
|
|
|
it "extracts the body" do
|
|
expect(receiver.body).to eq(email_body)
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|