mirror of
https://github.com/opf/openproject.git
synced 2026-06-14 03:30:14 +00:00
Oliver Günther
1586 lines
50 KiB
Ruby
1586 lines
50 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
#-- copyright
|
|
# OpenProject is an open source project management software.
|
|
# Copyright (C) the OpenProject GmbH
|
|
#
|
|
# This program is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License version 3.
|
|
#
|
|
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
|
|
# Copyright (C) 2006-2013 Jean-Philippe Lang
|
|
# Copyright (C) 2010-2013 the ChiliProject Team
|
|
#
|
|
# This program is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License
|
|
# as published by the Free Software Foundation; either version 2
|
|
# of the License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
#
|
|
# See COPYRIGHT and LICENSE files for more details.
|
|
#++
|
|
|
|
require "spec_helper"
|
|
|
|
RSpec.describe IncomingEmails::MailHandler do # rubocop:disable RSpec/SpecFilePathFormat
|
|
# we need these run first so the anonymous and system users are created and
|
|
# there is a default work package priority to save any work packages
|
|
shared_let(:anno_user) { User.anonymous }
|
|
shared_let(:system_user) { User.system }
|
|
shared_let(:priority_low) { create(:priority_low, name: "Low", is_default: true) }
|
|
|
|
shared_let(:project) { create(:valid_project, identifier: "onlinestore", name: "OnlineStore", public: false) }
|
|
|
|
before do
|
|
allow(UserMailer)
|
|
.to receive(:incoming_email_error)
|
|
.and_return instance_double(ActionMailer::MessageDelivery, deliver_later: nil)
|
|
end
|
|
|
|
after do
|
|
User.current = nil
|
|
allow(Setting).to receive(:default_language).and_return("en")
|
|
end
|
|
|
|
shared_context "for wp_on_given_project" do
|
|
let(:permissions) { %i[add_work_packages assign_versions work_package_assigned] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let(:submit_options) { {} }
|
|
|
|
subject do
|
|
submit_email("wp_on_given_project.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "for wp_on_given_project_case_insensitive" do
|
|
let(:permissions) { %i[add_work_packages assign_versions] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let(:submit_options) { { allow_override: "version" } }
|
|
|
|
subject do
|
|
submit_email("wp_on_given_project_case_insensitive.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "for wp on given project group assignment" do
|
|
let(:permissions) { %i[add_work_packages] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let!(:group) do
|
|
create(:group,
|
|
lastname: "A-Team",
|
|
member_with_permissions: { project => [:work_package_assigned] })
|
|
end
|
|
let(:submit_options) { {} }
|
|
|
|
subject do
|
|
submit_email("wp_on_given_project_group_assignment.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "with a reply to a wp mention with quotes above" do
|
|
let(:permissions) { %i[edit_work_packages view_work_packages] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
|
|
let!(:work_package) do
|
|
create(:work_package,
|
|
id: 2,
|
|
project:) do |wp|
|
|
wp.journals.last.update_column(:id, 891223)
|
|
end
|
|
end
|
|
|
|
subject do
|
|
submit_email("wp_reply_with_quoted_reply_above.eml")
|
|
end
|
|
end
|
|
|
|
shared_context "with wp create with cc" do
|
|
let(:permissions) { %i[add_work_packages view_work_packages add_work_package_watchers] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let!(:cc_user) do
|
|
create(:user,
|
|
mail: "dlopper@somenet.foo",
|
|
firstname: "D",
|
|
lastname: "Lopper",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let(:submit_options) { { issue: { project: project.identifier } } }
|
|
|
|
subject do
|
|
submit_email("ticket_with_cc.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "with a reply to a wp mention" do
|
|
let(:permissions) { %i[add_work_package_comments view_work_packages] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "j.doe@openproject.org",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
|
|
let!(:work_package) do
|
|
create(:work_package,
|
|
subject: "Some subject of the bug",
|
|
id: 39733,
|
|
project:) do |wp|
|
|
wp.journals.last.update_column(:id, 99999999)
|
|
end
|
|
end
|
|
|
|
subject do
|
|
submit_email("wp_mention_reply.eml")
|
|
end
|
|
end
|
|
|
|
shared_context "with a reply to a wp mention with attributes" do
|
|
let(:permissions) { %i[add_work_package_comments view_work_packages edit_work_packages work_package_assigned] }
|
|
let(:role) do
|
|
create(:project_role, permissions:)
|
|
end
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "j.doe@openproject.org",
|
|
member_with_roles: { project => role })
|
|
end
|
|
|
|
let!(:work_package) do
|
|
create(:work_package,
|
|
subject: "Some subject of the bug",
|
|
id: 39733,
|
|
project:,
|
|
status: original_status) do |wp|
|
|
wp.journals.last.update_column(:id, 99999999)
|
|
end
|
|
end
|
|
let!(:original_status) do
|
|
create(:default_status)
|
|
end
|
|
let!(:resolved_status) do
|
|
create(:status,
|
|
name: "Resolved") do |status|
|
|
create(:workflow,
|
|
old_status: original_status,
|
|
new_status: status,
|
|
role:,
|
|
type: work_package.type)
|
|
end
|
|
end
|
|
let!(:other_user) do
|
|
create(:user,
|
|
mail: "jsmith@somenet.foo",
|
|
member_with_roles: { project => [role] })
|
|
end
|
|
let!(:float_cf) do
|
|
create(:float_wp_custom_field,
|
|
name: "float field") do |cf|
|
|
project.work_package_custom_fields << cf
|
|
work_package.type.custom_fields << cf
|
|
end
|
|
end
|
|
|
|
subject do
|
|
submit_email("wp_mention_reply_with_attributes.eml")
|
|
end
|
|
end
|
|
|
|
shared_context "with a reply to a message" do
|
|
let(:permissions) { %i[view_messages add_messages] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "j.doe@openproject.org",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
|
|
let!(:message) do
|
|
create(:message,
|
|
id: 70917,
|
|
forum: create(:forum, project:)) do |wp|
|
|
wp.journals.last.update_column(:id, 99999999)
|
|
end
|
|
end
|
|
|
|
subject do
|
|
submit_email("message_reply.eml")
|
|
end
|
|
end
|
|
|
|
shared_context "with a new work package with attributes" do
|
|
let(:permissions) { %i[add_work_packages assign_versions work_package_assigned] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let!(:feature_type) do
|
|
create(:type,
|
|
name: "Feature request") do |type|
|
|
project.types << type
|
|
end
|
|
end
|
|
let!(:stock_category) do
|
|
project.categories.create(name: "Stock management")
|
|
end
|
|
let!(:urgent_priority) do
|
|
create(:priority_urgent)
|
|
end
|
|
let!(:high_priority) do
|
|
create(:priority_high)
|
|
end
|
|
let(:submit_options) { {} }
|
|
|
|
subject do
|
|
submit_email("wp_with_attributes.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "with a new work package with attributes with additional spaces" do
|
|
let(:permissions) { %i[add_work_packages assign_versions work_package_assigned] }
|
|
let(:role) do
|
|
create(:project_role, permissions:)
|
|
end
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let!(:feature_type) do
|
|
create(:type,
|
|
name: "Feature request") do |type|
|
|
project.types << type
|
|
end
|
|
end
|
|
let!(:stock_category) do
|
|
project.categories.create(name: "Stock management")
|
|
end
|
|
let!(:urgent_priority) do
|
|
create(:priority_urgent)
|
|
end
|
|
let!(:high_priority) do
|
|
create(:priority_high)
|
|
end
|
|
let!(:version) { create(:version, name: "alpha", project:) }
|
|
let!(:original_status) do
|
|
create(:default_status)
|
|
end
|
|
let!(:resolved_status) do
|
|
create(:status,
|
|
name: "Resolved") do |status|
|
|
create(:workflow,
|
|
old_status: original_status,
|
|
new_status: status,
|
|
role:,
|
|
type: feature_type)
|
|
end
|
|
end
|
|
|
|
let(:submit_options) { {} }
|
|
|
|
subject do
|
|
submit_email("wp_with_spaces_between_attribute_and_separator.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "with a new work package with attributes in japanese" do
|
|
let(:permissions) { %i[add_work_packages] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let!(:japanese_type) do
|
|
create(:type,
|
|
name: "開発") do |type|
|
|
project.types << type
|
|
end
|
|
end
|
|
let(:submit_options) { {} }
|
|
|
|
subject do
|
|
submit_email("wp_with_attributes_japanese.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "with a new work package with attachment" do
|
|
# The work package is created first and only then the attachment is added.
|
|
let(:permissions) { %i[add_work_packages add_work_package_attachments] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let(:submit_options) { {} }
|
|
|
|
subject do
|
|
submit_email("wp_with_attachment.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "with a new work package with attachment in apple format" do
|
|
# The work package is created first and only then the attachment is added.
|
|
let(:permissions) { %i[add_work_packages add_work_package_attachments] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let(:submit_options) { {} }
|
|
|
|
subject do
|
|
submit_email("wp_with_attachment_apple.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "with a new work package with a custom field" do
|
|
let(:permissions) { %i[add_work_packages] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let!(:custom_field) do
|
|
create(:string_wp_custom_field, name: "Searchable field") do |cf|
|
|
project.work_package_custom_fields << cf
|
|
project.types.first.custom_fields << cf
|
|
end
|
|
end
|
|
let(:submit_options) { {} }
|
|
|
|
subject do
|
|
submit_email("wp_with_custom_field.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "with a new work package with invalid attributes" do
|
|
let(:permissions) { %i[add_work_packages] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let(:submit_options) { {} }
|
|
|
|
subject do
|
|
submit_email("wp_with_invalid_attributes.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "with a new work package with localized attributes" do
|
|
let(:permissions) { %i[add_work_packages] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
language: "de",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let(:submit_options) { {} }
|
|
|
|
let!(:feature_type) do
|
|
create(:type,
|
|
name: "Feature request") do |type|
|
|
project.types << type
|
|
end
|
|
end
|
|
let!(:stock_category) do
|
|
project.categories.create(name: "Stock management")
|
|
end
|
|
let!(:urgent_priority) do
|
|
create(:priority_urgent)
|
|
end
|
|
|
|
subject do
|
|
submit_email("wp_with_localized_attributes.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "with a new work package with iso 8859 1 subject" do
|
|
let(:permissions) { %i[add_work_packages] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
language: "de",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let(:submit_options) { {} }
|
|
|
|
subject do
|
|
submit_email("wp_with_iso_8859_1_subject.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "with a new work package with long subject" do
|
|
let(:permissions) { %i[add_work_packages] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
language: "de",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let(:submit_options) { {} }
|
|
|
|
subject do
|
|
submit_email("wp_with_long_subject.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "with a new work package with html only description" do
|
|
let(:permissions) { %i[add_work_packages] }
|
|
let!(:user) do
|
|
create(:user,
|
|
mail: "JSmith@somenet.foo",
|
|
firstname: "John",
|
|
lastname: "Smith",
|
|
language: "de",
|
|
member_with_permissions: { project => permissions })
|
|
end
|
|
let(:submit_options) { {} }
|
|
|
|
subject do
|
|
submit_email("wp_with_html_only_description.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
shared_context "with a new work package with the sender fullname in utf-8" do
|
|
let(:submit_options) { {} }
|
|
|
|
before do
|
|
ProjectRole.non_member.update_attribute :permissions, [:add_work_packages]
|
|
project.update_attribute :public, true
|
|
end
|
|
|
|
subject do
|
|
submit_email("wp_with_utf8_fullname_of_sender.eml", **submit_options)
|
|
end
|
|
end
|
|
|
|
describe "#receive" do
|
|
shared_examples_for "work package created" do
|
|
it "creates the work package" do
|
|
expect(subject)
|
|
.to be_a(WorkPackage)
|
|
|
|
expect(subject)
|
|
.to be_persisted
|
|
end
|
|
end
|
|
|
|
shared_examples_for "journal created" do
|
|
it "creates the journal" do
|
|
expect(subject)
|
|
.to be_a(Journal)
|
|
|
|
expect(subject)
|
|
.to be_persisted
|
|
end
|
|
end
|
|
|
|
context "when sending a mail not as a reply" do
|
|
context "for a given project" do
|
|
let(:type) { project.types.first }
|
|
let!(:status) { create(:status, name: "Resolved", workflow_for_type: type) }
|
|
let!(:version) { create(:version, name: "alpha", project:) }
|
|
|
|
include_context "for wp_on_given_project" do
|
|
let(:submit_options) { { allow_override: "version" } }
|
|
end
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the referenced project" do
|
|
expect(subject.project)
|
|
.to eql(project)
|
|
end
|
|
|
|
it "sets the first type in the project" do
|
|
expect(subject.type)
|
|
.to eql(type)
|
|
end
|
|
|
|
it "sets the subject" do
|
|
expect(subject.subject)
|
|
.to eql("New ticket on a given project")
|
|
end
|
|
|
|
it "sets the sender as the author" do
|
|
expect(subject.author)
|
|
.to eql(user)
|
|
end
|
|
|
|
it "set the description" do
|
|
expect(subject.description)
|
|
.to include("Lorem ipsum dolor sit amet, consectetuer adipiscing elit.")
|
|
end
|
|
|
|
it "sets the start date" do
|
|
expect(subject.start_date.to_s)
|
|
.to eql("2010-01-01")
|
|
end
|
|
|
|
it "sets the due date" do
|
|
expect(subject.due_date.to_s)
|
|
.to eql("2010-12-31")
|
|
end
|
|
|
|
it "sets the accountable" do
|
|
expect(subject.responsible)
|
|
.to eql(user)
|
|
end
|
|
|
|
it "sets the assignee" do
|
|
expect(subject.assigned_to)
|
|
.to eql(user)
|
|
end
|
|
|
|
it "sets the status" do
|
|
expect(subject.status)
|
|
.to eql(status)
|
|
end
|
|
|
|
it "sets the version" do
|
|
expect(subject.version)
|
|
.to eql(version)
|
|
end
|
|
|
|
it "sets the estimated_hours" do
|
|
expect(subject.estimated_hours)
|
|
.to be(2.5)
|
|
end
|
|
|
|
it "sets the done_ratio" do
|
|
expect(subject.done_ratio)
|
|
.to be(30)
|
|
end
|
|
|
|
it "removes keywords" do
|
|
expect(subject.description)
|
|
.not_to match(/^Project:/i)
|
|
|
|
expect(subject.description)
|
|
.not_to match(/^Status:/i)
|
|
|
|
expect(subject.description)
|
|
.not_to match(/^Start Date:/i)
|
|
end
|
|
|
|
it "sends notifications to watching users" do
|
|
# User gets all updates
|
|
user = create(:user,
|
|
member_with_permissions: { project => %i(view_work_packages) },
|
|
notification_settings: [build(:notification_setting, all: true)])
|
|
|
|
expect do
|
|
perform_enqueued_jobs do
|
|
subject
|
|
end
|
|
end.to change(Notification.where(recipient: user), :count).by(1)
|
|
end
|
|
|
|
it "does not send an error reply email" do
|
|
subject # send mail
|
|
|
|
expect(UserMailer).not_to have_received(:incoming_email_error)
|
|
end
|
|
end
|
|
|
|
context "for a given project with a default type" do
|
|
let(:default_type) do
|
|
create(:type, is_default: true) do |t|
|
|
project.types << t
|
|
end
|
|
end
|
|
|
|
include_context "for wp_on_given_project" do
|
|
let(:submit_options) { { issue: { type: default_type.name } } }
|
|
end
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the default type" do
|
|
expect(subject.type.name)
|
|
.to eql(default_type.name)
|
|
end
|
|
end
|
|
|
|
context "for a given project with a locked user" do
|
|
let!(:status) { create(:status, name: "Resolved") }
|
|
|
|
before do
|
|
user.locked!
|
|
end
|
|
|
|
include_context "for wp_on_given_project"
|
|
|
|
it "does not create the work package" do
|
|
expect { subject }
|
|
.not_to change(WorkPackage, :count)
|
|
end
|
|
end
|
|
|
|
context "for a given project with group assignment" do
|
|
include_context "for wp on given project group assignment"
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the accountable to the group" do
|
|
expect(subject.responsible)
|
|
.to eql(group)
|
|
end
|
|
|
|
it "sets the assignee to the group" do
|
|
expect(subject.assigned_to)
|
|
.to eql(group)
|
|
end
|
|
end
|
|
|
|
context "for an email by unknown user" do
|
|
context "with unknown_user: 'create'" do
|
|
it "adds a work_package by create user on public project" do
|
|
ProjectRole.non_member.update_attribute :permissions, [:add_work_packages]
|
|
project.update_attribute :public, true
|
|
expect do
|
|
work_package = submit_email("ticket_by_unknown_user.eml", issue: { project: "onlinestore" }, unknown_user: "create")
|
|
work_package_created(work_package)
|
|
expect(work_package.author).to be_active
|
|
expect(work_package.author.mail).to eq("john.doe@somenet.foo")
|
|
expect(work_package.author.firstname).to eq("John")
|
|
expect(work_package.author.lastname).to eq("Doe")
|
|
|
|
# account information
|
|
perform_enqueued_jobs
|
|
|
|
email = ActionMailer::Base.deliveries.first
|
|
expect(email).not_to be_nil
|
|
expect(email.subject).to eq(I18n.t("mail_subject_register", value: Setting.app_title))
|
|
login = email.body.encoded.match(/\* Username: (\S+)\s?$/)[1]
|
|
password = email.body.encoded.match(/\* Password: (\S+)\s?$/)[1]
|
|
|
|
# Can't log in here since randomly assigned password must be changed
|
|
found_user = User.find_by(login:)
|
|
expect(work_package.author).to eq(found_user)
|
|
expect(found_user).to be_check_password(password)
|
|
end.to change(User, :count).by(1)
|
|
end
|
|
end
|
|
|
|
context "with unknown_user: 'create' and an utf8 encoded fullname" do
|
|
include_context "with a new work package with the sender fullname in utf-8"
|
|
let(:submit_options) { { issue: { project: "onlinestore" }, unknown_user: "create" } }
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "adds the user with decoded fullname" do
|
|
expect do
|
|
expect(subject.author).to be_active
|
|
expect(subject.author.mail).to eq("foo@example.org")
|
|
expect(subject.author.firstname).to eq((+"\xc3\x84\xc3\xa4").force_encoding("UTF-8"))
|
|
expect(subject.author.lastname).to eq((+"\xc3\x96\xc3\xb6").force_encoding("UTF-8"))
|
|
end.to change(User, :count).by(1)
|
|
end
|
|
end
|
|
|
|
context "with unknown_user: nil (default)" do
|
|
let(:results) { [] }
|
|
|
|
before do
|
|
results << submit_email(
|
|
"ticket_by_unknown_user.eml",
|
|
issue: { project: project.identifier },
|
|
unknown_user: nil
|
|
)
|
|
end
|
|
|
|
it "ignores the email" do
|
|
expect(results).to eq [nil]
|
|
end
|
|
|
|
it "does not respond with an error email" do
|
|
expect(UserMailer).not_to have_received(:incoming_email_error)
|
|
end
|
|
end
|
|
|
|
context "with unknown_user: 'accept' and permission check present" do
|
|
let(:expected) do
|
|
"MailHandler: work_package could not be created by Anonymous due to " \
|
|
'#["Type was attempted to be written but is not writable.", ' \
|
|
'"Project was attempted to be written but is not writable.", ' \
|
|
'"Subject was attempted to be written but is not writable.", ' \
|
|
'"Description was attempted to be written but is not writable.", ' \
|
|
'"may not be accessed."]'
|
|
end
|
|
let(:permission) { nil }
|
|
|
|
subject(:work_package) do
|
|
submit_email(
|
|
"ticket_by_unknown_user.eml",
|
|
issue: { project: project.identifier },
|
|
unknown_user: "accept"
|
|
)
|
|
end
|
|
|
|
before do
|
|
allow(Rails.logger).to receive(:error).with(expected)
|
|
ProjectRole.anonymous.add_permission!(permission) if permission
|
|
end
|
|
|
|
context "with anonymous lacking permissions" do
|
|
before do
|
|
work_package
|
|
end
|
|
|
|
it "rejects the email, and does not save the work package" do
|
|
expect(work_package).to be_new_record
|
|
expect(work_package.errors).not_to be_empty
|
|
end
|
|
|
|
it "logs the error" do
|
|
expect(Rails.logger).to have_received(:error).with(expected)
|
|
end
|
|
|
|
context "with report_incoming_email_errors true (default)" do
|
|
it "responds with an error email" do
|
|
expect(UserMailer).to have_received(:incoming_email_error) do |user, mail, logs|
|
|
expect(user).to eq anno_user
|
|
expect(mail[:subject]).to eq "Ticket by unknown user"
|
|
expect(logs).to eq [expected.sub(/^MailHandler/, "error")]
|
|
end
|
|
end
|
|
end
|
|
|
|
context "with report_incoming_email_errors false", with_settings: { report_incoming_email_errors: false } do
|
|
it "does not respond with an error email" do
|
|
expect(UserMailer).not_to have_received(:incoming_email_error)
|
|
end
|
|
end
|
|
end
|
|
|
|
context "with anonymous having permissions in a public project" do
|
|
let(:permission) { :add_work_packages }
|
|
|
|
before do
|
|
project.update_attribute(:public, true)
|
|
end
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the author to anonymous" do
|
|
expect(work_package.author)
|
|
.to eql User.anonymous
|
|
end
|
|
|
|
it "creates no user" do
|
|
expect { work_package }
|
|
.not_to change(User, :count)
|
|
end
|
|
end
|
|
|
|
context "with anonymous having permissions in a private project" do
|
|
let(:permission) { :add_work_packages }
|
|
|
|
before do
|
|
project.update_attribute(:public, false)
|
|
end
|
|
|
|
it "creates no work package" do
|
|
expect { work_package }
|
|
.not_to change(WorkPackage, :count)
|
|
end
|
|
|
|
it "creates no user" do
|
|
expect { work_package }
|
|
.not_to change(User, :count)
|
|
end
|
|
end
|
|
end
|
|
|
|
context "for unknown_user: 'accept' and no_permission_check" do
|
|
subject(:work_package) do
|
|
submit_email "ticket_by_unknown_user.eml",
|
|
issue: { project: project.identifier },
|
|
unknown_user: "accept",
|
|
no_permission_check: 1
|
|
end
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the author to anonymous" do
|
|
expect(work_package.author).to eq(User.anonymous)
|
|
end
|
|
end
|
|
|
|
context "for unknown_user: 'accept' and without from header" do
|
|
subject(:work_package) do
|
|
ProjectRole.anonymous.add_permission!(:add_work_packages)
|
|
|
|
submit_email "wp_without_from_header.eml",
|
|
issue: { project: project.identifier },
|
|
unknown_user: "accept"
|
|
end
|
|
|
|
it "creates no work package" do
|
|
expect { work_package }
|
|
.not_to change(WorkPackage, :count)
|
|
end
|
|
end
|
|
|
|
context "for unknown_user: 'accept' and without permission checks and without from header" do
|
|
subject(:work_package) do
|
|
submit_email "wp_without_from_header.eml",
|
|
issue: { project: project.identifier },
|
|
unknown_user: "accept",
|
|
no_permission_check: 1
|
|
end
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the author to anonymous" do
|
|
expect(work_package.author).to eq(User.anonymous)
|
|
end
|
|
end
|
|
end
|
|
|
|
context "for email from emission address", with_settings: { mail_from: "openproject@example.net" } do
|
|
before do
|
|
ProjectRole.non_member.add_permission!(:add_work_packages)
|
|
end
|
|
|
|
subject do
|
|
project.update(public: true)
|
|
submit_email("ticket_from_emission_address.eml",
|
|
issue: { project: project.identifier },
|
|
unknown_user: "create")
|
|
end
|
|
|
|
it "returns false" do
|
|
expect(subject).to be_falsey
|
|
end
|
|
|
|
it "does not create the user" do
|
|
expect { subject }
|
|
.not_to(change(User, :count))
|
|
end
|
|
|
|
it "does not create the work_package" do
|
|
expect { subject }
|
|
.not_to(change(WorkPackage, :count))
|
|
end
|
|
|
|
it "does not result in an error email response" do
|
|
subject # send email
|
|
|
|
expect(UserMailer).not_to have_received(:incoming_email_error)
|
|
end
|
|
end
|
|
|
|
context "for wp with status" do
|
|
let(:type) { project.types.first }
|
|
let!(:status) { create(:status, name: "Resolved", workflow_for_type: type) }
|
|
|
|
# This email contains: 'Project: onlinestore' and 'Status: Resolved'
|
|
include_context "for wp_on_given_project"
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "assigns the status to the created work package" do
|
|
expect(subject.status)
|
|
.to eql(status)
|
|
end
|
|
end
|
|
|
|
context "for wp with status case insensitive" do
|
|
let(:type) { project.types.first }
|
|
let!(:status) { create(:status, name: "Resolved", workflow_for_type: type) }
|
|
let!(:version) { create(:version, name: "alpha", project:) }
|
|
|
|
# This email contains: 'Project: onlinestore' and 'Status: resolved'
|
|
include_context "for wp_on_given_project_case_insensitive"
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "assigns the status to the created work package" do
|
|
expect(subject.status).to eq(status)
|
|
expect(subject.version).to eq(version)
|
|
expect(subject.priority).to eq priority_low
|
|
end
|
|
end
|
|
|
|
context "for wp with cc" do
|
|
include_context "with wp create with cc"
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "assigns cc and author as watcher" do
|
|
expect(subject.watcher_users)
|
|
.to contain_exactly(user, cc_user)
|
|
end
|
|
end
|
|
|
|
context "for a wp overriding attributes" do
|
|
include_context "with a new work package with attributes"
|
|
let(:submit_options) { { allow_override: "type,category,priority" } }
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the provided attributes" do
|
|
expect(subject.project)
|
|
.to eql project
|
|
|
|
expect(subject.type)
|
|
.to eql feature_type
|
|
|
|
expect(subject.category)
|
|
.to eql stock_category
|
|
|
|
expect(subject.priority)
|
|
.to eql urgent_priority
|
|
end
|
|
end
|
|
|
|
context "for a wp overriding attributes partially" do
|
|
include_context "with a new work package with attributes"
|
|
let(:submit_options) { { issue: { priority: "High" }, allow_override: ["type"] } }
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the provided attributes only to the extend allowed and uses default" do
|
|
expect(subject.project)
|
|
.to eql project
|
|
|
|
expect(subject.type)
|
|
.to eql feature_type
|
|
|
|
expect(subject.category)
|
|
.to be_nil
|
|
|
|
expect(subject.priority)
|
|
.to eql high_priority
|
|
end
|
|
end
|
|
|
|
context "for a wp overriding attributes with spaces between attribute and separator" do
|
|
include_context "with a new work package with attributes with additional spaces"
|
|
let(:submit_options) { { allow_override: "type,category,priority" } }
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the provided attributes" do
|
|
expect(subject.project)
|
|
.to eql project
|
|
|
|
expect(subject.type)
|
|
.to eql feature_type
|
|
|
|
expect(subject.category)
|
|
.to eql stock_category
|
|
|
|
expect(subject.priority)
|
|
.to eql urgent_priority
|
|
end
|
|
end
|
|
|
|
context "for a wp overriding attributes in japanese" do
|
|
include_context "with a new work package with attributes in japanese"
|
|
let(:submit_options) { { issue: { project: "onlinestore" }, allow_override: "type" } }
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the provided attributes" do
|
|
expect(subject.type)
|
|
.to eql japanese_type
|
|
end
|
|
end
|
|
|
|
context "for a wp with attachment" do
|
|
include_context "with a new work package with attachment"
|
|
let(:submit_options) { { issue: { project: "onlinestore" } } }
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "adds the attachment" do
|
|
expect(subject.attachments.count)
|
|
.to be 1
|
|
|
|
expect(subject.attachments.first.filename)
|
|
.to eql "Paella.jpg"
|
|
|
|
expect(subject.attachments.first.content_type)
|
|
.to eql "image/jpeg"
|
|
|
|
expect(subject.attachments.first.filesize)
|
|
.to be 10790
|
|
end
|
|
end
|
|
|
|
context "for a wp with attachment in apple format" do
|
|
include_context "with a new work package with attachment in apple format"
|
|
let(:submit_options) { { issue: { project: "onlinestore" } } }
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "adds the attachment" do
|
|
expect(subject.attachments.count)
|
|
.to be 1
|
|
|
|
expect(subject.attachments.first.filename)
|
|
.to eql "paella.jpg"
|
|
|
|
expect(subject.attachments.first.content_type)
|
|
.to eql "image/jpeg"
|
|
|
|
expect(subject.attachments.first.filesize)
|
|
.to be 10790
|
|
end
|
|
end
|
|
|
|
context "for a wp with a custom field value" do
|
|
include_context "with a new work package with a custom field"
|
|
let(:submit_options) { { issue: { project: "onlinestore" } } }
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the custom field value and removes it from the text" do
|
|
expect(subject.custom_value_attributes)
|
|
.to eql(custom_field.id => "Value for a custom field")
|
|
|
|
expect(subject.description)
|
|
.not_to include "searchable field"
|
|
end
|
|
end
|
|
|
|
context "for a wp with invalid attributes" do
|
|
include_context "with a new work package with invalid attributes"
|
|
let(:submit_options) { { issue: { project: "onlinestore" }, allow_override: "type,category,priority" } }
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "ignores the invalid attributes and set default ones where possible" do
|
|
expect(subject.responsible)
|
|
.to be_nil
|
|
|
|
expect(subject.assigned_to)
|
|
.to be_nil
|
|
|
|
expect(subject.start_date)
|
|
.to be_nil
|
|
|
|
expect(subject.due_date)
|
|
.to be_nil
|
|
|
|
expect(subject.done_ratio)
|
|
.to be_nil
|
|
|
|
expect(subject.priority)
|
|
.to eql priority_low
|
|
end
|
|
end
|
|
|
|
context "for a wp with localized attributes" do
|
|
include_context "with a new work package with localized attributes"
|
|
let(:submit_options) { { allow_override: "type,category,priority" } }
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the provided attributes" do
|
|
expect(subject.project)
|
|
.to eql project
|
|
|
|
expect(subject.type)
|
|
.to eql feature_type
|
|
|
|
expect(subject.category)
|
|
.to eql stock_category
|
|
|
|
expect(subject.priority)
|
|
.to eql urgent_priority
|
|
end
|
|
end
|
|
|
|
context "for a wp with iso 8859 1 subject" do
|
|
include_context "with a new work package with iso 8859 1 subject"
|
|
let(:submit_options) { { issue: { project: "onlinestore" } } }
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the subject" do
|
|
expect(subject.subject)
|
|
.to eql "Testmail from Webmail: ä ö ü..."
|
|
end
|
|
end
|
|
|
|
context "for a wp with long subject" do
|
|
include_context "with a new work package with long subject"
|
|
let(:submit_options) { { issue: { project: "onlinestore" } } }
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the subject" do
|
|
original_subject = <<~MSG.squish
|
|
New ticket on a given project with a very long subject line
|
|
which exceeds 255 chars and should not be ignored but chopped off.
|
|
And if the subject line is still not long enough, we just add more text.
|
|
And more text. Wow, this is really annoying. Especially, if you have nothing to say...
|
|
MSG
|
|
|
|
expect(subject.subject)
|
|
.to eql original_subject[0, 255]
|
|
end
|
|
end
|
|
|
|
context "for a wp with html only description" do
|
|
include_context "with a new work package with html only description"
|
|
let(:submit_options) { { issue: { project: "onlinestore" } } }
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "sets the description" do
|
|
expect(subject.description)
|
|
.to eql "This is a html-only email."
|
|
end
|
|
end
|
|
|
|
context "for a wp with attribute keys" do
|
|
include_context "with a new work package with attributes with additional spaces"
|
|
it_behaves_like "work package created"
|
|
|
|
subject do
|
|
submit_email("wp_with_attribute_keys.eml", allow_override: ["category"])
|
|
end
|
|
|
|
it "sets the description" do
|
|
expect(subject.description).to eq("Some description here")
|
|
expect(subject.subject).to eq("New ticket with full attributes")
|
|
expect(subject.type).to eq(feature_type)
|
|
expect(subject.status).to eq(resolved_status)
|
|
expect(subject.version).to eq(version)
|
|
expect(subject.priority).to eq(urgent_priority)
|
|
expect(subject.assigned_to).to eq(user)
|
|
expect(subject.responsible).to eq(user)
|
|
expect(subject.start_date).to eq(Date.parse("2025-01-01"))
|
|
expect(subject.due_date).to eq(Date.parse("2025-12-31"))
|
|
expect(subject.estimated_hours).to eq(20)
|
|
expect(subject.remaining_hours).to eq(10.5)
|
|
expect(subject.category).to eq(stock_category)
|
|
end
|
|
|
|
context "with the user having a german locale" do
|
|
before do
|
|
user.update!(language: "de")
|
|
end
|
|
|
|
subject do
|
|
submit_email("wp_with_attributes_i18n_de.eml", allow_override: ["category"])
|
|
end
|
|
|
|
it "sets the description" do
|
|
expect(subject.description).to eq("Beschreibung würde hier stehen.")
|
|
expect(subject.subject).to eq("Neues Arbeitspaket")
|
|
expect(subject.type).to eq(feature_type)
|
|
expect(subject.status).to eq(resolved_status)
|
|
expect(subject.version).to eq(version)
|
|
expect(subject.priority).to eq(urgent_priority)
|
|
expect(subject.assigned_to).to eq(user)
|
|
expect(subject.responsible).to eq(user)
|
|
expect(subject.start_date).to eq(Date.parse("2025-01-01"))
|
|
expect(subject.due_date).to eq(Date.parse("2025-12-31"))
|
|
expect(subject.estimated_hours).to eq(20)
|
|
expect(subject.remaining_hours).to eq(10.5)
|
|
expect(subject.category).to eq(stock_category)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context "when sending a reply to work package mail" do
|
|
let!(:mail_user) { create(:admin, mail: "user@example.org") }
|
|
let!(:work_package) { create(:work_package, project:) }
|
|
|
|
before do
|
|
# Avoid trying to extract text
|
|
allow(OpenProject::Database).to receive(:allows_tsv?).and_return false
|
|
end
|
|
|
|
context "with attachments to be added" do
|
|
it "updates a work package with attachment" do
|
|
allow(WorkPackage).to receive(:find_by).with(id: 123).and_return(work_package)
|
|
|
|
# Mail with two attachments, one of which is skipped by signature.asc filename match
|
|
submit_email "update_ticket_with_attachment_and_sig.eml", issue: { project: "onlinestore" }
|
|
|
|
work_package.reload
|
|
|
|
# Expect comment
|
|
expect(work_package.journals.last.notes).to eq "Reply to work package #123"
|
|
expect(work_package.journals.last.user).to eq mail_user
|
|
|
|
# Expect filename without signature to be saved
|
|
expect(work_package.attachments.count).to eq(1)
|
|
expect(work_package.attachments.first.filename).to eq("Photo25.jpg")
|
|
end
|
|
end
|
|
|
|
context "with existing attachment" do
|
|
let!(:attachment) { create(:attachment, container: work_package) }
|
|
|
|
it "does not replace it (Regression #29722)" do
|
|
work_package.reload
|
|
allow(WorkPackage).to receive(:find_by).with(id: 123).and_return(work_package)
|
|
|
|
# Mail with two attachments, one of which is skipped by signature.asc filename match
|
|
submit_email "update_ticket_with_attachment_and_sig.eml", issue: { project: "onlinestore" }
|
|
|
|
expect(work_package.attachments.length).to eq 2
|
|
end
|
|
end
|
|
|
|
context "with reply text" do
|
|
include_context "with a reply to a wp mention with quotes above"
|
|
|
|
it_behaves_like "journal created"
|
|
|
|
it "sends notifications" do
|
|
assignee = create(:user,
|
|
member_with_permissions: { project => %i(view_work_packages) },
|
|
notification_settings: [build(:notification_setting, assignee: true, responsible: true)])
|
|
|
|
responsible = create(:user,
|
|
member_with_permissions: { project => %i(view_work_packages) },
|
|
notification_settings: [build(:notification_setting, assignee: true, responsible: true)])
|
|
work_package.update_column(:assigned_to_id, assignee.id)
|
|
work_package.update_column(:responsible_id, responsible.id)
|
|
|
|
# Sends notifications for the assignee and the author who is listening for all changes.
|
|
expect do
|
|
perform_enqueued_jobs do
|
|
subject
|
|
end
|
|
end.to change(Notification, :count).by(2)
|
|
end
|
|
end
|
|
|
|
context "when replying to mention mail with only text" do
|
|
include_context "with a reply to a wp mention"
|
|
|
|
it_behaves_like "journal created"
|
|
|
|
it "adds the content to the last journal" do
|
|
subject
|
|
|
|
expect(work_package.journals.reload.last.notes)
|
|
.to include "The text of the reply."
|
|
end
|
|
|
|
it "does not alter any attributes" do
|
|
subject
|
|
|
|
expect(work_package.journals.reload.last.details)
|
|
.to be_empty
|
|
end
|
|
|
|
it "performs the changes in the name of the sender" do
|
|
subject
|
|
|
|
expect(work_package.journals.reload.last.user)
|
|
.to eql user
|
|
end
|
|
end
|
|
|
|
context "when replying to mention mail with text and attributes" do
|
|
include_context "with a reply to a wp mention with attributes"
|
|
|
|
it_behaves_like "journal created"
|
|
|
|
it "adds the content to the last journal" do
|
|
subject
|
|
|
|
expect(work_package.journals.reload.last.notes)
|
|
.to include "The text of the reply."
|
|
end
|
|
|
|
it "alters the attributes" do
|
|
subject
|
|
|
|
expect(work_package.journals.reload.last.details)
|
|
.to eql(
|
|
"due_date" => [nil, Date.parse("Fri, 31 Dec 2010")],
|
|
"status_id" => [original_status.id, resolved_status.id],
|
|
"responsible_id" => [nil, other_user.id],
|
|
"assigned_to_id" => [nil, other_user.id],
|
|
"start_date" => [nil, Date.parse("Fri, 01 Jan 2010")],
|
|
"duration" => [nil, 365],
|
|
"custom_fields_#{float_cf.id}" => [nil, "52.6"]
|
|
)
|
|
end
|
|
|
|
it "performs the changes in the name of the sender" do
|
|
subject
|
|
|
|
expect(work_package.journals.reload.last.user)
|
|
.to eql user
|
|
end
|
|
end
|
|
|
|
context "with a custom field" do
|
|
let(:work_package) { create(:work_package, project:) }
|
|
let(:type) { create(:type) }
|
|
|
|
before do
|
|
type.custom_fields << custom_field
|
|
type.save!
|
|
|
|
allow(work_package).to receive(:available_custom_fields).and_return([custom_field])
|
|
|
|
allow(WorkPackage).to receive(:find_by).with(id: 42).and_return(work_package)
|
|
allow(User).to receive(:find_by_mail).with("h.wurst@openproject.com").and_return(mail_user)
|
|
end
|
|
|
|
context "as type text" do
|
|
let(:custom_field) { create(:text_wp_custom_field, name: "Notes") }
|
|
|
|
before do
|
|
submit_email "wp_reply_with_text_custom_field.eml", issue: { project: project.identifier }
|
|
|
|
work_package.reload
|
|
end
|
|
|
|
it "sets the value" do
|
|
value = work_package.custom_values.where(custom_field_id: custom_field.id).pick(:value)
|
|
|
|
expect(value).to eq "some text" # as given in .eml fixture
|
|
end
|
|
end
|
|
|
|
context "as type list" do
|
|
let(:custom_field) { create(:list_wp_custom_field, name: "Letters", possible_values: %w(A B C)) }
|
|
|
|
before do
|
|
submit_email "wp_reply_with_list_custom_field.eml", issue: { project: project.identifier }
|
|
|
|
work_package.reload
|
|
end
|
|
|
|
it "sets the value" do
|
|
option = CustomOption.where(custom_field_id: custom_field.id, value: "B").first # as given in .eml fixture
|
|
value = work_package.custom_values.where(custom_field_id: custom_field.id).pick(:value)
|
|
|
|
expect(value).to eq option.id.to_s
|
|
end
|
|
end
|
|
end
|
|
|
|
context "when receiving an auto reply" do
|
|
include_context "with a reply to a wp mention with quotes above" do
|
|
[
|
|
"X-Auto-Response-Suppress: OOF",
|
|
"Auto-Submitted: auto-replied",
|
|
"Auto-Submitted: Auto-Replied",
|
|
"Auto-Submitted: auto-generated"
|
|
].each do |header|
|
|
subject do
|
|
raw = File.read(File.join("#{File.dirname(__FILE__)}/../fixtures/mail_handler",
|
|
"wp_reply_with_quoted_reply_above.eml"))
|
|
raw = "#{header}\n#{raw}"
|
|
|
|
described_class.receive(raw)
|
|
end
|
|
|
|
it "does not update the work package" do
|
|
expect { subject }
|
|
.not_to change(Journal, :count)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context "when sending a reply to a message mail" do
|
|
include_context "with a reply to a message"
|
|
|
|
it "creates a new message in the name of the sender", :aggregate_failures do
|
|
expect(subject)
|
|
.to be_a Message
|
|
|
|
expect(subject.subject)
|
|
.to eql("Response to the original message")
|
|
|
|
expect(subject.content)
|
|
.to include("Test message")
|
|
|
|
expect(subject.author)
|
|
.to eql user
|
|
|
|
expect(subject.forum)
|
|
.to eql message.forum
|
|
|
|
expect(subject.parent)
|
|
.to eql message
|
|
end
|
|
end
|
|
|
|
describe "truncate emails based on the Setting" do
|
|
context "with no setting", with_settings: { mail_handler_body_delimiters: "" } do
|
|
include_context "for wp_on_given_project"
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "adds the entire email into the work_package" do
|
|
expect(subject.description)
|
|
.to include("---")
|
|
|
|
expect(subject.description)
|
|
.to include("This paragraph is after the delimiter")
|
|
end
|
|
end
|
|
|
|
context "with a single string", with_settings: { mail_handler_body_delimiters: "---" } do
|
|
include_context "for wp_on_given_project"
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "truncates the email at the delimiter for the work package" do
|
|
expect(subject.description)
|
|
.to include("This paragraph is before delimiters")
|
|
|
|
expect(subject.description)
|
|
.to include("--- This line starts with a delimiter")
|
|
|
|
expect(subject.description)
|
|
.not_to match(/^---$/)
|
|
|
|
expect(subject.description)
|
|
.not_to include("This paragraph is after the delimiter")
|
|
end
|
|
end
|
|
|
|
context "with a single quoted reply (e.g. reply to a OpenProject email notification)",
|
|
with_settings: { mail_handler_body_delimiters: "--- Reply above. Do not remove this line. ---" } do
|
|
include_context "with a reply to a wp mention with quotes above"
|
|
|
|
it_behaves_like "journal created"
|
|
|
|
it "truncates the email at the delimiter with the quoted reply symbols (>)" do
|
|
expect(subject.notes)
|
|
.to include("An update to the issue by the sender.")
|
|
|
|
expect(subject.notes)
|
|
.not_to match(Regexp.escape("--- Reply above. Do not remove this line. ---"))
|
|
|
|
expect(subject.notes)
|
|
.not_to include("Looks like the JSON api for projects was missed.")
|
|
end
|
|
end
|
|
|
|
context "with multiple strings",
|
|
with_settings: { mail_handler_body_delimiters: "---\nBREAK" } do
|
|
include_context "for wp_on_given_project"
|
|
|
|
it_behaves_like "work package created"
|
|
|
|
it "truncates the email at the first delimiter found (BREAK)" do
|
|
expect(subject.description)
|
|
.to include("This paragraph is before delimiters")
|
|
|
|
expect(subject.description)
|
|
.not_to include("BREAK")
|
|
|
|
expect(subject.description)
|
|
.not_to include("This paragraph is between delimiters")
|
|
|
|
expect(subject.description)
|
|
.not_to match(/^---$/)
|
|
|
|
expect(subject.description)
|
|
.not_to include("This paragraph is after the delimiter")
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "category" do
|
|
let!(:category) { create(:category, project:, name: "Foobar") }
|
|
|
|
it "adds a work_package with category" do
|
|
allow(Setting).to receive(:default_language).and_return("en")
|
|
ProjectRole.non_member.update_attribute :permissions, [:add_work_packages]
|
|
project.update_attribute :public, true
|
|
|
|
work_package = submit_email "ticket_with_category.eml",
|
|
issue: { project: "onlinestore" },
|
|
allow_override: ["category"],
|
|
unknown_user: "create"
|
|
work_package_created(work_package)
|
|
expect(work_package.category).to eq(category)
|
|
end
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
def read_email(filename)
|
|
File.read(File.join("#{File.dirname(__FILE__)}/../fixtures/mail_handler", filename))
|
|
end
|
|
|
|
def submit_email(filename, options = {})
|
|
IncomingEmails::MailHandler.receive(read_email(filename), options)
|
|
end
|
|
|
|
def work_package_created(work_package)
|
|
expect(work_package).to be_a(WorkPackage)
|
|
expect(work_package).not_to be_new_record
|
|
work_package.reload
|
|
end
|
|
end
|