diff options
Diffstat (limited to 'actionmailer')
110 files changed, 6093 insertions, 0 deletions
diff --git a/actionmailer/CHANGELOG.md b/actionmailer/CHANGELOG.md new file mode 100644 index 0000000000..5f3fc44e6e --- /dev/null +++ b/actionmailer/CHANGELOG.md @@ -0,0 +1,65 @@ +* Add `MailDeliveryJob` for delivering both regular and parameterized mail. Deprecate using `DeliveryJob` and `Parameterized::DeliveryJob`. + + *Gannon McGibbon* + +* Fix ActionMailer assertions not working when a Mail defines + a custom delivery job class + + *Edouard Chin* + +* Mails with multipart `format` blocks with implicit render now also check for + a template name in options hash instead of only using the action name. + + *Marcus Ilgner* + +* `ActionDispatch::IntegrationTest` includes `ActionMailer::TestHelper` module by default. + + *Ricardo Díaz* + +* Add `perform_deliveries` to a payload of `deliver.action_mailer` notification. + + *Yoshiyuki Kinjo* + +* Change delivery logging message when `perform_deliveries` is false. + + *Yoshiyuki Kinjo* + +* Allow call `assert_enqueued_email_with` with no block. + + Example: + ``` + def test_email + ContactMailer.welcome.deliver_later + assert_enqueued_email_with ContactMailer, :welcome + end + + def test_email_with_arguments + ContactMailer.welcome("Hello", "Goodbye").deliver_later + assert_enqueued_email_with ContactMailer, :welcome, args: ["Hello", "Goodbye"] + end + ``` + + *bogdanvlviv* + +* Ensure mail gem is eager autoloaded when eager load is true to prevent thread deadlocks. + + *Samuel Cochran* + +* Perform email jobs in `assert_emails`. + + *Gannon McGibbon* + +* Add `Base.unregister_observer`, `Base.unregister_observers`, + `Base.unregister_interceptor`, `Base.unregister_interceptors`, + `Base.unregister_preview_interceptor` and `Base.unregister_preview_interceptors`. + This makes it possible to dynamically add and remove email observers and + interceptors at runtime in the same way they're registered. + + *Claudio Ortolina*, *Kota Miyake* + +* Rails 6 requires Ruby 2.5.0 or newer. + + *Jeremy Daer*, *Kasper Timm Hansen* + + +Please check [5-2-stable](https://github.com/rails/rails/blob/5-2-stable/actionmailer/CHANGELOG.md) for previous changes. diff --git a/actionmailer/MIT-LICENSE b/actionmailer/MIT-LICENSE new file mode 100644 index 0000000000..1cb3add0fc --- /dev/null +++ b/actionmailer/MIT-LICENSE @@ -0,0 +1,21 @@ +Copyright (c) 2004-2018 David Heinemeier Hansson + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/actionmailer/README.rdoc b/actionmailer/README.rdoc new file mode 100644 index 0000000000..14dfb82234 --- /dev/null +++ b/actionmailer/README.rdoc @@ -0,0 +1,175 @@ += Action Mailer -- Easy email delivery and testing + +Action Mailer is a framework for designing email service layers. These layers +are used to consolidate code for sending out forgotten passwords, welcome +wishes on signup, invoices for billing, and any other use case that requires +a written notification to either a person or another system. + +Action Mailer is in essence a wrapper around Action Controller and the +Mail gem. It provides a way to make emails using templates in the same +way that Action Controller renders views using templates. + +Additionally, an Action Mailer class can be used to process incoming email, +such as allowing a blog to accept new posts from an email (which could even +have been sent from a phone). + +== Sending emails + +The framework works by initializing any instance variables you want to be +available in the email template, followed by a call to +mail+ to deliver +the email. + +This can be as simple as: + + class Notifier < ActionMailer::Base + default from: 'system@loudthinking.com' + + def welcome(recipient) + @recipient = recipient + mail(to: recipient, + subject: "[Signed up] Welcome #{recipient}") + end + end + +The body of the email is created by using an Action View template (regular +ERB) that has the instance variables that are declared in the mailer action. + +So the corresponding body template for the method above could look like this: + + Hello there, + + Mr. <%= @recipient %> + + Thank you for signing up! + +If the recipient was given as "david@loudthinking.com", the email +generated would look like this: + + Date: Mon, 25 Jan 2010 22:48:09 +1100 + From: system@loudthinking.com + To: david@loudthinking.com + Message-ID: <4b5d84f9dd6a5_7380800b81ac29578@void.loudthinking.com.mail> + Subject: [Signed up] Welcome david@loudthinking.com + Mime-Version: 1.0 + Content-Type: text/plain; + charset="US-ASCII"; + Content-Transfer-Encoding: 7bit + + Hello there, + + Mr. david@loudthinking.com + + Thank you for signing up! + +In order to send mails, you simply call the method and then call +deliver_now+ on the return value. + +Calling the method returns a Mail Message object: + + message = Notifier.welcome("david@loudthinking.com") # => Returns a Mail::Message object + message.deliver_now # => delivers the email + +Or you can just chain the methods together like: + + Notifier.welcome("david@loudthinking.com").deliver_now # Creates the email and sends it immediately + +== Setting defaults + +It is possible to set default values that will be used in every method in your +Action Mailer class. To implement this functionality, you just call the public +class method +default+ which you get for free from <tt>ActionMailer::Base</tt>. +This method accepts a Hash as the parameter. You can use any of the headers, +email messages have, like +:from+ as the key. You can also pass in a string as +the key, like "Content-Type", but Action Mailer does this out of the box for you, +so you won't need to worry about that. Finally, it is also possible to pass in a +Proc that will get evaluated when it is needed. + +Note that every value you set with this method will get overwritten if you use the +same key in your mailer method. + +Example: + + class AuthenticationMailer < ActionMailer::Base + default from: "awesome@application.com", subject: Proc.new { "E-mail was generated at #{Time.now}" } + ..... + end + +== Receiving emails + +To receive emails, you need to implement a public instance method called ++receive+ that takes an email object as its single parameter. The Action Mailer +framework has a corresponding class method, which is also called +receive+, that +accepts a raw, unprocessed email as a string, which it then turns into the email +object and calls the receive instance method. + +Example: + + class Mailman < ActionMailer::Base + def receive(email) + page = Page.find_by(address: email.to.first) + page.emails.create( + subject: email.subject, body: email.body + ) + + if email.has_attachments? + email.attachments.each do |attachment| + page.attachments.create({ + file: attachment, description: email.subject + }) + end + end + end + end + +This Mailman can be the target for Postfix or other MTAs. In Rails, you would use +the runner in the trivial case like this: + + rails runner 'Mailman.receive(STDIN.read)' + +However, invoking Rails in the runner for each mail to be received is very +resource intensive. A single instance of Rails should be run within a daemon, if +it is going to process more than just a limited amount of email. + +== Configuration + +The Base class has the full list of configuration options. Here's an example: + + ActionMailer::Base.smtp_settings = { + address: 'smtp.yourserver.com', # default: localhost + port: '25', # default: 25 + user_name: 'user', + password: 'pass', + authentication: :plain # :plain, :login or :cram_md5 + } + + +== Download and installation + +The latest version of Action Mailer can be installed with RubyGems: + + $ gem install actionmailer + +Source code can be downloaded as part of the Rails project on GitHub: + +* https://github.com/rails/rails/tree/master/actionmailer + + +== License + +Action Mailer is released under the MIT license: + +* https://opensource.org/licenses/MIT + + +== Support + +API documentation is at + +* http://api.rubyonrails.org + +Bug reports for the Ruby on Rails project can be filed here: + +* https://github.com/rails/rails/issues + +Feature requests should be discussed on the rails-core mailing list here: + +* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core diff --git a/actionmailer/Rakefile b/actionmailer/Rakefile new file mode 100644 index 0000000000..6ac408e1cb --- /dev/null +++ b/actionmailer/Rakefile @@ -0,0 +1,25 @@ +# frozen_string_literal: true + +require "rake/testtask" + +desc "Default Task" +task default: [ :test ] + +task :package + +# Run the unit tests +Rake::TestTask.new { |t| + t.libs << "test" + t.pattern = "test/**/*_test.rb" + t.warning = true + t.verbose = true + t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION) +} + +namespace :test do + task :isolated do + Dir.glob("test/**/*_test.rb").all? do |file| + sh(Gem.ruby, "-w", "-Ilib:test", file) + end || raise("Failures") + end +end diff --git a/actionmailer/actionmailer.gemspec b/actionmailer/actionmailer.gemspec new file mode 100644 index 0000000000..a6c482f1a0 --- /dev/null +++ b/actionmailer/actionmailer.gemspec @@ -0,0 +1,38 @@ +# frozen_string_literal: true + +version = File.read(File.expand_path("../RAILS_VERSION", __dir__)).strip + +Gem::Specification.new do |s| + s.platform = Gem::Platform::RUBY + s.name = "actionmailer" + s.version = version + s.summary = "Email composition, delivery, and receiving framework (part of Rails)." + s.description = "Email on Rails. Compose, deliver, receive, and test emails using the familiar controller/view pattern. First-class support for multipart email and attachments." + + s.required_ruby_version = ">= 2.5.0" + + s.license = "MIT" + + s.author = "David Heinemeier Hansson" + s.email = "david@loudthinking.com" + s.homepage = "http://rubyonrails.org" + + s.files = Dir["CHANGELOG.md", "README.rdoc", "MIT-LICENSE", "lib/**/*"] + s.require_path = "lib" + s.requirements << "none" + + s.metadata = { + "source_code_uri" => "https://github.com/rails/rails/tree/v#{version}/actionmailer", + "changelog_uri" => "https://github.com/rails/rails/blob/v#{version}/actionmailer/CHANGELOG.md" + } + + # NOTE: Please read our dependency guidelines before updating versions: + # https://edgeguides.rubyonrails.org/security.html#dependency-management-and-cves + + s.add_dependency "actionpack", version + s.add_dependency "actionview", version + s.add_dependency "activejob", version + + s.add_dependency "mail", ["~> 2.5", ">= 2.5.4"] + s.add_dependency "rails-dom-testing", "~> 2.0" +end diff --git a/actionmailer/bin/test b/actionmailer/bin/test new file mode 100755 index 0000000000..c53377cc97 --- /dev/null +++ b/actionmailer/bin/test @@ -0,0 +1,5 @@ +#!/usr/bin/env ruby +# frozen_string_literal: true + +COMPONENT_ROOT = File.expand_path("..", __dir__) +require_relative "../../tools/test" diff --git a/actionmailer/lib/action_mailer.rb b/actionmailer/lib/action_mailer.rb new file mode 100644 index 0000000000..48f16180be --- /dev/null +++ b/actionmailer/lib/action_mailer.rb @@ -0,0 +1,70 @@ +# frozen_string_literal: true + +#-- +# Copyright (c) 2004-2018 David Heinemeier Hansson +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +#++ + +require "abstract_controller" +require "action_mailer/version" + +# Common Active Support usage in Action Mailer +require "active_support" +require "active_support/rails" +require "active_support/core_ext/class" +require "active_support/core_ext/module/attr_internal" +require "active_support/core_ext/string/inflections" +require "active_support/lazy_load_hooks" + +module ActionMailer + extend ::ActiveSupport::Autoload + + eager_autoload do + autoload :Collector + end + + autoload :Base + autoload :DeliveryMethods + autoload :InlinePreviewInterceptor + autoload :MailHelper + autoload :Parameterized + autoload :Preview + autoload :Previews, "action_mailer/preview" + autoload :TestCase + autoload :TestHelper + autoload :MessageDelivery + autoload :DeliveryJob + autoload :MailDeliveryJob + + def self.eager_load! + super + + require "mail" + Mail.eager_autoload! + end +end + +autoload :Mime, "action_dispatch/http/mime_type" + +ActiveSupport.on_load(:action_view) do + ActionView::Base.default_formats ||= Mime::SET.symbols + ActionView::Template::Types.delegate_to Mime +end diff --git a/actionmailer/lib/action_mailer/base.rb b/actionmailer/lib/action_mailer/base.rb new file mode 100644 index 0000000000..8ddc90b9df --- /dev/null +++ b/actionmailer/lib/action_mailer/base.rb @@ -0,0 +1,1021 @@ +# frozen_string_literal: true + +require "mail" +require "action_mailer/collector" +require "active_support/core_ext/string/inflections" +require "active_support/core_ext/hash/except" +require "active_support/core_ext/module/anonymous" + +require "action_mailer/log_subscriber" +require "action_mailer/rescuable" + +module ActionMailer + # Action Mailer allows you to send email from your application using a mailer model and views. + # + # = Mailer Models + # + # To use Action Mailer, you need to create a mailer model. + # + # $ rails generate mailer Notifier + # + # The generated model inherits from <tt>ApplicationMailer</tt> which in turn + # inherits from <tt>ActionMailer::Base</tt>. A mailer model defines methods + # used to generate an email message. In these methods, you can setup variables to be used in + # the mailer views, options on the mail itself such as the <tt>:from</tt> address, and attachments. + # + # class ApplicationMailer < ActionMailer::Base + # default from: 'from@example.com' + # layout 'mailer' + # end + # + # class NotifierMailer < ApplicationMailer + # default from: 'no-reply@example.com', + # return_path: 'system@example.com' + # + # def welcome(recipient) + # @account = recipient + # mail(to: recipient.email_address_with_name, + # bcc: ["bcc@example.com", "Order Watcher <watcher@example.com>"]) + # end + # end + # + # Within the mailer method, you have access to the following methods: + # + # * <tt>attachments[]=</tt> - Allows you to add attachments to your email in an intuitive + # manner; <tt>attachments['filename.png'] = File.read('path/to/filename.png')</tt> + # + # * <tt>attachments.inline[]=</tt> - Allows you to add an inline attachment to your email + # in the same manner as <tt>attachments[]=</tt> + # + # * <tt>headers[]=</tt> - Allows you to specify any header field in your email such + # as <tt>headers['X-No-Spam'] = 'True'</tt>. Note that declaring a header multiple times + # will add many fields of the same name. Read #headers doc for more information. + # + # * <tt>headers(hash)</tt> - Allows you to specify multiple headers in your email such + # as <tt>headers({'X-No-Spam' => 'True', 'In-Reply-To' => '1234@message.id'})</tt> + # + # * <tt>mail</tt> - Allows you to specify email to be sent. + # + # The hash passed to the mail method allows you to specify any header that a <tt>Mail::Message</tt> + # will accept (any valid email header including optional fields). + # + # The +mail+ method, if not passed a block, will inspect your views and send all the views with + # the same name as the method, so the above action would send the +welcome.text.erb+ view + # file as well as the +welcome.html.erb+ view file in a +multipart/alternative+ email. + # + # If you want to explicitly render only certain templates, pass a block: + # + # mail(to: user.email) do |format| + # format.text + # format.html + # end + # + # The block syntax is also useful in providing information specific to a part: + # + # mail(to: user.email) do |format| + # format.text(content_transfer_encoding: "base64") + # format.html + # end + # + # Or even to render a special view: + # + # mail(to: user.email) do |format| + # format.text + # format.html { render "some_other_template" } + # end + # + # = Mailer views + # + # Like Action Controller, each mailer class has a corresponding view directory in which each + # method of the class looks for a template with its name. + # + # To define a template to be used with a mailer, create an <tt>.erb</tt> file with the same + # name as the method in your mailer model. For example, in the mailer defined above, the template at + # <tt>app/views/notifier_mailer/welcome.text.erb</tt> would be used to generate the email. + # + # Variables defined in the methods of your mailer model are accessible as instance variables in their + # corresponding view. + # + # Emails by default are sent in plain text, so a sample view for our model example might look like this: + # + # Hi <%= @account.name %>, + # Thanks for joining our service! Please check back often. + # + # You can even use Action View helpers in these views. For example: + # + # You got a new note! + # <%= truncate(@note.body, length: 25) %> + # + # If you need to access the subject, from or the recipients in the view, you can do that through message object: + # + # You got a new note from <%= message.from %>! + # <%= truncate(@note.body, length: 25) %> + # + # + # = Generating URLs + # + # URLs can be generated in mailer views using <tt>url_for</tt> or named routes. Unlike controllers from + # Action Pack, the mailer instance doesn't have any context about the incoming request, so you'll need + # to provide all of the details needed to generate a URL. + # + # When using <tt>url_for</tt> you'll need to provide the <tt>:host</tt>, <tt>:controller</tt>, and <tt>:action</tt>: + # + # <%= url_for(host: "example.com", controller: "welcome", action: "greeting") %> + # + # When using named routes you only need to supply the <tt>:host</tt>: + # + # <%= users_url(host: "example.com") %> + # + # You should use the <tt>named_route_url</tt> style (which generates absolute URLs) and avoid using the + # <tt>named_route_path</tt> style (which generates relative URLs), since clients reading the mail will + # have no concept of a current URL from which to determine a relative path. + # + # It is also possible to set a default host that will be used in all mailers by setting the <tt>:host</tt> + # option as a configuration option in <tt>config/application.rb</tt>: + # + # config.action_mailer.default_url_options = { host: "example.com" } + # + # You can also define a <tt>default_url_options</tt> method on individual mailers to override these + # default settings per-mailer. + # + # By default when <tt>config.force_ssl</tt> is +true+, URLs generated for hosts will use the HTTPS protocol. + # + # = Sending mail + # + # Once a mailer action and template are defined, you can deliver your message or defer its creation and + # delivery for later: + # + # NotifierMailer.welcome(User.first).deliver_now # sends the email + # mail = NotifierMailer.welcome(User.first) # => an ActionMailer::MessageDelivery object + # mail.deliver_now # generates and sends the email now + # + # The <tt>ActionMailer::MessageDelivery</tt> class is a wrapper around a delegate that will call + # your method to generate the mail. If you want direct access to the delegator, or <tt>Mail::Message</tt>, + # you can call the <tt>message</tt> method on the <tt>ActionMailer::MessageDelivery</tt> object. + # + # NotifierMailer.welcome(User.first).message # => a Mail::Message object + # + # Action Mailer is nicely integrated with Active Job so you can generate and send emails in the background + # (example: outside of the request-response cycle, so the user doesn't have to wait on it): + # + # NotifierMailer.welcome(User.first).deliver_later # enqueue the email sending to Active Job + # + # Note that <tt>deliver_later</tt> will execute your method from the background job. + # + # You never instantiate your mailer class. Rather, you just call the method you defined on the class itself. + # All instance methods are expected to return a message object to be sent. + # + # = Multipart Emails + # + # Multipart messages can also be used implicitly because Action Mailer will automatically detect and use + # multipart templates, where each template is named after the name of the action, followed by the content + # type. Each such detected template will be added to the message, as a separate part. + # + # For example, if the following templates exist: + # * signup_notification.text.erb + # * signup_notification.html.erb + # * signup_notification.xml.builder + # * signup_notification.yml.erb + # + # Each would be rendered and added as a separate part to the message, with the corresponding content + # type. The content type for the entire message is automatically set to <tt>multipart/alternative</tt>, + # which indicates that the email contains multiple different representations of the same email + # body. The same instance variables defined in the action are passed to all email templates. + # + # Implicit template rendering is not performed if any attachments or parts have been added to the email. + # This means that you'll have to manually add each part to the email and set the content type of the email + # to <tt>multipart/alternative</tt>. + # + # = Attachments + # + # Sending attachment in emails is easy: + # + # class NotifierMailer < ApplicationMailer + # def welcome(recipient) + # attachments['free_book.pdf'] = File.read('path/to/file.pdf') + # mail(to: recipient, subject: "New account information") + # end + # end + # + # Which will (if it had both a <tt>welcome.text.erb</tt> and <tt>welcome.html.erb</tt> + # template in the view directory), send a complete <tt>multipart/mixed</tt> email with two parts, + # the first part being a <tt>multipart/alternative</tt> with the text and HTML email parts inside, + # and the second being a <tt>application/pdf</tt> with a Base64 encoded copy of the file.pdf book + # with the filename +free_book.pdf+. + # + # If you need to send attachments with no content, you need to create an empty view for it, + # or add an empty body parameter like this: + # + # class NotifierMailer < ApplicationMailer + # def welcome(recipient) + # attachments['free_book.pdf'] = File.read('path/to/file.pdf') + # mail(to: recipient, subject: "New account information", body: "") + # end + # end + # + # You can also send attachments with html template, in this case you need to add body, attachments, + # and custom content type like this: + # + # class NotifierMailer < ApplicationMailer + # def welcome(recipient) + # attachments["free_book.pdf"] = File.read("path/to/file.pdf") + # mail(to: recipient, + # subject: "New account information", + # content_type: "text/html", + # body: "<html><body>Hello there</body></html>") + # end + # end + # + # = Inline Attachments + # + # You can also specify that a file should be displayed inline with other HTML. This is useful + # if you want to display a corporate logo or a photo. + # + # class NotifierMailer < ApplicationMailer + # def welcome(recipient) + # attachments.inline['photo.png'] = File.read('path/to/photo.png') + # mail(to: recipient, subject: "Here is what we look like") + # end + # end + # + # And then to reference the image in the view, you create a <tt>welcome.html.erb</tt> file and + # make a call to +image_tag+ passing in the attachment you want to display and then call + # +url+ on the attachment to get the relative content id path for the image source: + # + # <h1>Please Don't Cringe</h1> + # + # <%= image_tag attachments['photo.png'].url -%> + # + # As we are using Action View's +image_tag+ method, you can pass in any other options you want: + # + # <h1>Please Don't Cringe</h1> + # + # <%= image_tag attachments['photo.png'].url, alt: 'Our Photo', class: 'photo' -%> + # + # = Observing and Intercepting Mails + # + # Action Mailer provides hooks into the Mail observer and interceptor methods. These allow you to + # register classes that are called during the mail delivery life cycle. + # + # An observer class must implement the <tt>:delivered_email(message)</tt> method which will be + # called once for every email sent after the email has been sent. + # + # An interceptor class must implement the <tt>:delivering_email(message)</tt> method which will be + # called before the email is sent, allowing you to make modifications to the email before it hits + # the delivery agents. Your class should make any needed modifications directly to the passed + # in <tt>Mail::Message</tt> instance. + # + # = Default Hash + # + # Action Mailer provides some intelligent defaults for your emails, these are usually specified in a + # default method inside the class definition: + # + # class NotifierMailer < ApplicationMailer + # default sender: 'system@example.com' + # end + # + # You can pass in any header value that a <tt>Mail::Message</tt> accepts. Out of the box, + # <tt>ActionMailer::Base</tt> sets the following: + # + # * <tt>mime_version: "1.0"</tt> + # * <tt>charset: "UTF-8"</tt> + # * <tt>content_type: "text/plain"</tt> + # * <tt>parts_order: [ "text/plain", "text/enriched", "text/html" ]</tt> + # + # <tt>parts_order</tt> and <tt>charset</tt> are not actually valid <tt>Mail::Message</tt> header fields, + # but Action Mailer translates them appropriately and sets the correct values. + # + # As you can pass in any header, you need to either quote the header as a string, or pass it in as + # an underscored symbol, so the following will work: + # + # class NotifierMailer < ApplicationMailer + # default 'Content-Transfer-Encoding' => '7bit', + # content_description: 'This is a description' + # end + # + # Finally, Action Mailer also supports passing <tt>Proc</tt> and <tt>Lambda</tt> objects into the default hash, + # so you can define methods that evaluate as the message is being generated: + # + # class NotifierMailer < ApplicationMailer + # default 'X-Special-Header' => Proc.new { my_method }, to: -> { @inviter.email_address } + # + # private + # def my_method + # 'some complex call' + # end + # end + # + # Note that the proc/lambda is evaluated right at the start of the mail message generation, so if you + # set something in the default hash using a proc, and then set the same thing inside of your + # mailer method, it will get overwritten by the mailer method. + # + # It is also possible to set these default options that will be used in all mailers through + # the <tt>default_options=</tt> configuration in <tt>config/application.rb</tt>: + # + # config.action_mailer.default_options = { from: "no-reply@example.org" } + # + # = Callbacks + # + # You can specify callbacks using <tt>before_action</tt> and <tt>after_action</tt> for configuring your messages. + # This may be useful, for example, when you want to add default inline attachments for all + # messages sent out by a certain mailer class: + # + # class NotifierMailer < ApplicationMailer + # before_action :add_inline_attachment! + # + # def welcome + # mail + # end + # + # private + # def add_inline_attachment! + # attachments.inline["footer.jpg"] = File.read('/path/to/filename.jpg') + # end + # end + # + # Callbacks in Action Mailer are implemented using + # <tt>AbstractController::Callbacks</tt>, so you can define and configure + # callbacks in the same manner that you would use callbacks in classes that + # inherit from <tt>ActionController::Base</tt>. + # + # Note that unless you have a specific reason to do so, you should prefer + # using <tt>before_action</tt> rather than <tt>after_action</tt> in your + # Action Mailer classes so that headers are parsed properly. + # + # = Previewing emails + # + # You can preview your email templates visually by adding a mailer preview file to the + # <tt>ActionMailer::Base.preview_path</tt>. Since most emails do something interesting + # with database data, you'll need to write some scenarios to load messages with fake data: + # + # class NotifierMailerPreview < ActionMailer::Preview + # def welcome + # NotifierMailer.welcome(User.first) + # end + # end + # + # Methods must return a <tt>Mail::Message</tt> object which can be generated by calling the mailer + # method without the additional <tt>deliver_now</tt> / <tt>deliver_later</tt>. The location of the + # mailer previews directory can be configured using the <tt>preview_path</tt> option which has a default + # of <tt>test/mailers/previews</tt>: + # + # config.action_mailer.preview_path = "#{Rails.root}/lib/mailer_previews" + # + # An overview of all previews is accessible at <tt>http://localhost:3000/rails/mailers</tt> + # on a running development server instance. + # + # Previews can also be intercepted in a similar manner as deliveries can be by registering + # a preview interceptor that has a <tt>previewing_email</tt> method: + # + # class CssInlineStyler + # def self.previewing_email(message) + # # inline CSS styles + # end + # end + # + # config.action_mailer.preview_interceptors :css_inline_styler + # + # Note that interceptors need to be registered both with <tt>register_interceptor</tt> + # and <tt>register_preview_interceptor</tt> if they should operate on both sending and + # previewing emails. + # + # = Configuration options + # + # These options are specified on the class level, like + # <tt>ActionMailer::Base.raise_delivery_errors = true</tt> + # + # * <tt>default_options</tt> - You can pass this in at a class level as well as within the class itself as + # per the above section. + # + # * <tt>logger</tt> - the logger is used for generating information on the mailing run if available. + # Can be set to +nil+ for no logging. Compatible with both Ruby's own +Logger+ and Log4r loggers. + # + # * <tt>smtp_settings</tt> - Allows detailed configuration for <tt>:smtp</tt> delivery method: + # * <tt>:address</tt> - Allows you to use a remote mail server. Just change it from its default + # "localhost" setting. + # * <tt>:port</tt> - On the off chance that your mail server doesn't run on port 25, you can change it. + # * <tt>:domain</tt> - If you need to specify a HELO domain, you can do it here. + # * <tt>:user_name</tt> - If your mail server requires authentication, set the username in this setting. + # * <tt>:password</tt> - If your mail server requires authentication, set the password in this setting. + # * <tt>:authentication</tt> - If your mail server requires authentication, you need to specify the + # authentication type here. + # This is a symbol and one of <tt>:plain</tt> (will send the password Base64 encoded), <tt>:login</tt> (will + # send the password Base64 encoded) or <tt>:cram_md5</tt> (combines a Challenge/Response mechanism to exchange + # information and a cryptographic Message Digest 5 algorithm to hash important information) + # * <tt>:enable_starttls_auto</tt> - Detects if STARTTLS is enabled in your SMTP server and starts + # to use it. Defaults to <tt>true</tt>. + # * <tt>:openssl_verify_mode</tt> - When using TLS, you can set how OpenSSL checks the certificate. This is + # really useful if you need to validate a self-signed and/or a wildcard certificate. You can use the name + # of an OpenSSL verify constant (<tt>'none'</tt> or <tt>'peer'</tt>) or directly the constant + # (<tt>OpenSSL::SSL::VERIFY_NONE</tt> or <tt>OpenSSL::SSL::VERIFY_PEER</tt>). + # <tt>:ssl/:tls</tt> Enables the SMTP connection to use SMTP/TLS (SMTPS: SMTP over direct TLS connection) + # + # * <tt>sendmail_settings</tt> - Allows you to override options for the <tt>:sendmail</tt> delivery method. + # * <tt>:location</tt> - The location of the sendmail executable. Defaults to <tt>/usr/sbin/sendmail</tt>. + # * <tt>:arguments</tt> - The command line arguments. Defaults to <tt>-i</tt> with <tt>-f sender@address</tt> + # added automatically before the message is sent. + # + # * <tt>file_settings</tt> - Allows you to override options for the <tt>:file</tt> delivery method. + # * <tt>:location</tt> - The directory into which emails will be written. Defaults to the application + # <tt>tmp/mails</tt>. + # + # * <tt>raise_delivery_errors</tt> - Whether or not errors should be raised if the email fails to be delivered. + # + # * <tt>delivery_method</tt> - Defines a delivery method. Possible values are <tt>:smtp</tt> (default), + # <tt>:sendmail</tt>, <tt>:test</tt>, and <tt>:file</tt>. Or you may provide a custom delivery method + # object e.g. +MyOwnDeliveryMethodClass+. See the Mail gem documentation on the interface you need to + # implement for a custom delivery agent. + # + # * <tt>perform_deliveries</tt> - Determines whether emails are actually sent from Action Mailer when you + # call <tt>.deliver</tt> on an email message or on an Action Mailer method. This is on by default but can + # be turned off to aid in functional testing. + # + # * <tt>deliveries</tt> - Keeps an array of all the emails sent out through the Action Mailer with + # <tt>delivery_method :test</tt>. Most useful for unit and functional testing. + # + # * <tt>deliver_later_queue_name</tt> - The name of the queue used with <tt>deliver_later</tt>. Defaults to +mailers+. + class Base < AbstractController::Base + include DeliveryMethods + include Rescuable + include Parameterized + include Previews + + abstract! + + include AbstractController::Rendering + + include AbstractController::Logger + include AbstractController::Helpers + include AbstractController::Translation + include AbstractController::AssetPaths + include AbstractController::Callbacks + include AbstractController::Caching + + include ActionView::Layouts + + PROTECTED_IVARS = AbstractController::Rendering::DEFAULT_PROTECTED_INSTANCE_VARIABLES + [:@_action_has_layout] + + def _protected_ivars # :nodoc: + PROTECTED_IVARS + end + + helper ActionMailer::MailHelper + + class_attribute :delivery_job, default: ::ActionMailer::MailDeliveryJob + class_attribute :default_params, default: { + mime_version: "1.0", + charset: "UTF-8", + content_type: "text/plain", + parts_order: [ "text/plain", "text/enriched", "text/html" ] + }.freeze + + class << self + # Register one or more Observers which will be notified when mail is delivered. + def register_observers(*observers) + observers.flatten.compact.each { |observer| register_observer(observer) } + end + + # Unregister one or more previously registered Observers. + def unregister_observers(*observers) + observers.flatten.compact.each { |observer| unregister_observer(observer) } + end + + # Register one or more Interceptors which will be called before mail is sent. + def register_interceptors(*interceptors) + interceptors.flatten.compact.each { |interceptor| register_interceptor(interceptor) } + end + + # Unregister one or more previously registered Interceptors. + def unregister_interceptors(*interceptors) + interceptors.flatten.compact.each { |interceptor| unregister_interceptor(interceptor) } + end + + # Register an Observer which will be notified when mail is delivered. + # Either a class, string or symbol can be passed in as the Observer. + # If a string or symbol is passed in it will be camelized and constantized. + def register_observer(observer) + Mail.register_observer(observer_class_for(observer)) + end + + # Unregister a previously registered Observer. + # Either a class, string or symbol can be passed in as the Observer. + # If a string or symbol is passed in it will be camelized and constantized. + def unregister_observer(observer) + Mail.unregister_observer(observer_class_for(observer)) + end + + # Register an Interceptor which will be called before mail is sent. + # Either a class, string or symbol can be passed in as the Interceptor. + # If a string or symbol is passed in it will be camelized and constantized. + def register_interceptor(interceptor) + Mail.register_interceptor(observer_class_for(interceptor)) + end + + # Unregister a previously registered Interceptor. + # Either a class, string or symbol can be passed in as the Interceptor. + # If a string or symbol is passed in it will be camelized and constantized. + def unregister_interceptor(interceptor) + Mail.unregister_interceptor(observer_class_for(interceptor)) + end + + def observer_class_for(value) # :nodoc: + case value + when String, Symbol + value.to_s.camelize.constantize + else + value + end + end + private :observer_class_for + + # Returns the name of the current mailer. This method is also being used as a path for a view lookup. + # If this is an anonymous mailer, this method will return +anonymous+ instead. + def mailer_name + @mailer_name ||= anonymous? ? "anonymous" : name.underscore + end + # Allows to set the name of current mailer. + attr_writer :mailer_name + alias :controller_path :mailer_name + + # Sets the defaults through app configuration: + # + # config.action_mailer.default(from: "no-reply@example.org") + # + # Aliased by ::default_options= + def default(value = nil) + self.default_params = default_params.merge(value).freeze if value + default_params + end + # Allows to set defaults through app configuration: + # + # config.action_mailer.default_options = { from: "no-reply@example.org" } + alias :default_options= :default + + # Receives a raw email, parses it into an email object, decodes it, + # instantiates a new mailer, and passes the email object to the mailer + # object's +receive+ method. + # + # If you want your mailer to be able to process incoming messages, you'll + # need to implement a +receive+ method that accepts the raw email string + # as a parameter: + # + # class MyMailer < ActionMailer::Base + # def receive(mail) + # # ... + # end + # end + def receive(raw_mail) + ActiveSupport::Notifications.instrument("receive.action_mailer") do |payload| + mail = Mail.new(raw_mail) + set_payload_for_mail(payload, mail) + new.receive(mail) + end + end + + # Wraps an email delivery inside of <tt>ActiveSupport::Notifications</tt> instrumentation. + # + # This method is actually called by the <tt>Mail::Message</tt> object itself + # through a callback when you call <tt>:deliver</tt> on the <tt>Mail::Message</tt>, + # calling +deliver_mail+ directly and passing a <tt>Mail::Message</tt> will do + # nothing except tell the logger you sent the email. + def deliver_mail(mail) #:nodoc: + ActiveSupport::Notifications.instrument("deliver.action_mailer") do |payload| + set_payload_for_mail(payload, mail) + yield # Let Mail do the delivery actions + end + end + + private + + def set_payload_for_mail(payload, mail) + payload[:mailer] = name + payload[:message_id] = mail.message_id + payload[:subject] = mail.subject + payload[:to] = mail.to + payload[:from] = mail.from + payload[:bcc] = mail.bcc if mail.bcc.present? + payload[:cc] = mail.cc if mail.cc.present? + payload[:date] = mail.date + payload[:mail] = mail.encoded + payload[:perform_deliveries] = mail.perform_deliveries + end + + def method_missing(method_name, *args) + if action_methods.include?(method_name.to_s) + MessageDelivery.new(self, method_name, *args) + else + super + end + end + + def respond_to_missing?(method, include_all = false) + action_methods.include?(method.to_s) || super + end + end + + attr_internal :message + + def initialize + super() + @_mail_was_called = false + @_message = Mail.new + end + + def process(method_name, *args) #:nodoc: + payload = { + mailer: self.class.name, + action: method_name, + args: args + } + + ActiveSupport::Notifications.instrument("process.action_mailer", payload) do + super + @_message = NullMail.new unless @_mail_was_called + end + end + + class NullMail #:nodoc: + def body; "" end + def header; {} end + + def respond_to?(string, include_all = false) + true + end + + def method_missing(*args) + nil + end + end + + # Returns the name of the mailer object. + def mailer_name + self.class.mailer_name + end + + # Allows you to pass random and unusual headers to the new <tt>Mail::Message</tt> + # object which will add them to itself. + # + # headers['X-Special-Domain-Specific-Header'] = "SecretValue" + # + # You can also pass a hash into headers of header field names and values, + # which will then be set on the <tt>Mail::Message</tt> object: + # + # headers 'X-Special-Domain-Specific-Header' => "SecretValue", + # 'In-Reply-To' => incoming.message_id + # + # The resulting <tt>Mail::Message</tt> will have the following in its header: + # + # X-Special-Domain-Specific-Header: SecretValue + # + # Note about replacing already defined headers: + # + # * +subject+ + # * +sender+ + # * +from+ + # * +to+ + # * +cc+ + # * +bcc+ + # * +reply-to+ + # * +orig-date+ + # * +message-id+ + # * +references+ + # + # Fields can only appear once in email headers while other fields such as + # <tt>X-Anything</tt> can appear multiple times. + # + # If you want to replace any header which already exists, first set it to + # +nil+ in order to reset the value otherwise another field will be added + # for the same header. + def headers(args = nil) + if args + @_message.headers(args) + else + @_message + end + end + + # Allows you to add attachments to an email, like so: + # + # mail.attachments['filename.jpg'] = File.read('/path/to/filename.jpg') + # + # If you do this, then Mail will take the file name and work out the mime type. + # It will also set the Content-Type, Content-Disposition, Content-Transfer-Encoding + # and encode the contents of the attachment in Base64. + # + # You can also specify overrides if you want by passing a hash instead of a string: + # + # mail.attachments['filename.jpg'] = {mime_type: 'application/gzip', + # content: File.read('/path/to/filename.jpg')} + # + # If you want to use encoding other than Base64 then you will need to pass encoding + # type along with the pre-encoded content as Mail doesn't know how to decode the + # data: + # + # file_content = SpecialEncode(File.read('/path/to/filename.jpg')) + # mail.attachments['filename.jpg'] = {mime_type: 'application/gzip', + # encoding: 'SpecialEncoding', + # content: file_content } + # + # You can also search for specific attachments: + # + # # By Filename + # mail.attachments['filename.jpg'] # => Mail::Part object or nil + # + # # or by index + # mail.attachments[0] # => Mail::Part (first attachment) + # + def attachments + if @_mail_was_called + LateAttachmentsProxy.new(@_message.attachments) + else + @_message.attachments + end + end + + class LateAttachmentsProxy < SimpleDelegator + def inline; _raise_error end + def []=(_name, _content); _raise_error end + + private + def _raise_error + raise RuntimeError, "Can't add attachments after `mail` was called.\n" \ + "Make sure to use `attachments[]=` before calling `mail`." + end + end + + # The main method that creates the message and renders the email templates. There are + # two ways to call this method, with a block, or without a block. + # + # It accepts a headers hash. This hash allows you to specify + # the most used headers in an email message, these are: + # + # * +:subject+ - The subject of the message, if this is omitted, Action Mailer will + # ask the Rails I18n class for a translated +:subject+ in the scope of + # <tt>[mailer_scope, action_name]</tt> or if this is missing, will translate the + # humanized version of the +action_name+ + # * +:to+ - Who the message is destined for, can be a string of addresses, or an array + # of addresses. + # * +:from+ - Who the message is from + # * +:cc+ - Who you would like to Carbon-Copy on this email, can be a string of addresses, + # or an array of addresses. + # * +:bcc+ - Who you would like to Blind-Carbon-Copy on this email, can be a string of + # addresses, or an array of addresses. + # * +:reply_to+ - Who to set the Reply-To header of the email to. + # * +:date+ - The date to say the email was sent on. + # + # You can set default values for any of the above headers (except +:date+) + # by using the ::default class method: + # + # class Notifier < ActionMailer::Base + # default from: 'no-reply@test.lindsaar.net', + # bcc: 'email_logger@test.lindsaar.net', + # reply_to: 'bounces@test.lindsaar.net' + # end + # + # If you need other headers not listed above, you can either pass them in + # as part of the headers hash or use the <tt>headers['name'] = value</tt> + # method. + # + # When a +:return_path+ is specified as header, that value will be used as + # the 'envelope from' address for the Mail message. Setting this is useful + # when you want delivery notifications sent to a different address than the + # one in +:from+. Mail will actually use the +:return_path+ in preference + # to the +:sender+ in preference to the +:from+ field for the 'envelope + # from' value. + # + # If you do not pass a block to the +mail+ method, it will find all + # templates in the view paths using by default the mailer name and the + # method name that it is being called from, it will then create parts for + # each of these templates intelligently, making educated guesses on correct + # content type and sequence, and return a fully prepared <tt>Mail::Message</tt> + # ready to call <tt>:deliver</tt> on to send. + # + # For example: + # + # class Notifier < ActionMailer::Base + # default from: 'no-reply@test.lindsaar.net' + # + # def welcome + # mail(to: 'mikel@test.lindsaar.net') + # end + # end + # + # Will look for all templates at "app/views/notifier" with name "welcome". + # If no welcome template exists, it will raise an ActionView::MissingTemplate error. + # + # However, those can be customized: + # + # mail(template_path: 'notifications', template_name: 'another') + # + # And now it will look for all templates at "app/views/notifications" with name "another". + # + # If you do pass a block, you can render specific templates of your choice: + # + # mail(to: 'mikel@test.lindsaar.net') do |format| + # format.text + # format.html + # end + # + # You can even render plain text directly without using a template: + # + # mail(to: 'mikel@test.lindsaar.net') do |format| + # format.text { render plain: "Hello Mikel!" } + # format.html { render html: "<h1>Hello Mikel!</h1>".html_safe } + # end + # + # Which will render a +multipart/alternative+ email with +text/plain+ and + # +text/html+ parts. + # + # The block syntax also allows you to customize the part headers if desired: + # + # mail(to: 'mikel@test.lindsaar.net') do |format| + # format.text(content_transfer_encoding: "base64") + # format.html + # end + # + def mail(headers = {}, &block) + return message if @_mail_was_called && headers.blank? && !block + + # At the beginning, do not consider class default for content_type + content_type = headers[:content_type] + + headers = apply_defaults(headers) + + # Apply charset at the beginning so all fields are properly quoted + message.charset = charset = headers[:charset] + + # Set configure delivery behavior + wrap_delivery_behavior!(headers[:delivery_method], headers[:delivery_method_options]) + + assign_headers_to_message(message, headers) + + # Render the templates and blocks + responses = collect_responses(headers, &block) + @_mail_was_called = true + + create_parts_from_responses(message, responses) + + # Setup content type, reapply charset and handle parts order + message.content_type = set_content_type(message, content_type, headers[:content_type]) + message.charset = charset + + if message.multipart? + message.body.set_sort_order(headers[:parts_order]) + message.body.sort_parts! + end + + message + end + + private + + # Used by #mail to set the content type of the message. + # + # It will use the given +user_content_type+, or multipart if the mail + # message has any attachments. If the attachments are inline, the content + # type will be "multipart/related", otherwise "multipart/mixed". + # + # If there is no content type passed in via headers, and there are no + # attachments, or the message is multipart, then the default content type is + # used. + def set_content_type(m, user_content_type, class_default) # :doc: + params = m.content_type_parameters || {} + case + when user_content_type.present? + user_content_type + when m.has_attachments? + if m.attachments.detect(&:inline?) + ["multipart", "related", params] + else + ["multipart", "mixed", params] + end + when m.multipart? + ["multipart", "alternative", params] + else + m.content_type || class_default + end + end + + # Translates the +subject+ using Rails I18n class under <tt>[mailer_scope, action_name]</tt> scope. + # If it does not find a translation for the +subject+ under the specified scope it will default to a + # humanized version of the <tt>action_name</tt>. + # If the subject has interpolations, you can pass them through the +interpolations+ parameter. + def default_i18n_subject(interpolations = {}) # :doc: + mailer_scope = self.class.mailer_name.tr("/", ".") + I18n.t(:subject, interpolations.merge(scope: [mailer_scope, action_name], default: action_name.humanize)) + end + + # Emails do not support relative path links. + def self.supports_path? # :doc: + false + end + + def apply_defaults(headers) + default_values = self.class.default.map do |key, value| + [ + key, + compute_default(value) + ] + end.to_h + + headers_with_defaults = headers.reverse_merge(default_values) + headers_with_defaults[:subject] ||= default_i18n_subject + headers_with_defaults + end + + def compute_default(value) + return value unless value.is_a?(Proc) + + if value.arity == 1 + instance_exec(self, &value) + else + instance_exec(&value) + end + end + + def assign_headers_to_message(message, headers) + assignable = headers.except(:parts_order, :content_type, :body, :template_name, + :template_path, :delivery_method, :delivery_method_options) + assignable.each { |k, v| message[k] = v } + end + + def collect_responses(headers) + if block_given? + collect_responses_from_block(headers, &Proc.new) + elsif headers[:body] + collect_responses_from_text(headers) + else + collect_responses_from_templates(headers) + end + end + + def collect_responses_from_block(headers) + templates_name = headers[:template_name] || action_name + collector = ActionMailer::Collector.new(lookup_context) { render(templates_name) } + yield(collector) + collector.responses + end + + def collect_responses_from_text(headers) + [{ + body: headers.delete(:body), + content_type: headers[:content_type] || "text/plain" + }] + end + + def collect_responses_from_templates(headers) + templates_path = headers[:template_path] || self.class.mailer_name + templates_name = headers[:template_name] || action_name + + each_template(Array(templates_path), templates_name).map do |template| + self.formats = template.formats + { + body: render(template: template), + content_type: template.type.to_s + } + end + end + + def each_template(paths, name, &block) + templates = lookup_context.find_all(name, paths) + if templates.empty? + raise ActionView::MissingTemplate.new(paths, name, paths, false, "mailer") + else + templates.uniq(&:formats).each(&block) + end + end + + def create_parts_from_responses(m, responses) + if responses.size == 1 && !m.has_attachments? + responses[0].each { |k, v| m[k] = v } + elsif responses.size > 1 && m.has_attachments? + container = Mail::Part.new + container.content_type = "multipart/alternative" + responses.each { |r| insert_part(container, r, m.charset) } + m.add_part(container) + else + responses.each { |r| insert_part(m, r, m.charset) } + end + end + + def insert_part(container, response, charset) + response[:charset] ||= charset + part = Mail::Part.new(response) + container.add_part(part) + end + + # This and #instrument_name is for caching instrument + def instrument_payload(key) + { + mailer: mailer_name, + key: key + } + end + + def instrument_name + "action_mailer" + end + + ActiveSupport.run_load_hooks(:action_mailer, self) + end +end diff --git a/actionmailer/lib/action_mailer/collector.rb b/actionmailer/lib/action_mailer/collector.rb new file mode 100644 index 0000000000..888410fa75 --- /dev/null +++ b/actionmailer/lib/action_mailer/collector.rb @@ -0,0 +1,32 @@ +# frozen_string_literal: true + +require "abstract_controller/collector" +require "active_support/core_ext/hash/reverse_merge" +require "active_support/core_ext/array/extract_options" + +module ActionMailer + class Collector + include AbstractController::Collector + attr_reader :responses + + def initialize(context, &block) + @context = context + @responses = [] + @default_render = block + end + + def any(*args, &block) + options = args.extract_options! + raise ArgumentError, "You have to supply at least one format" if args.empty? + args.each { |type| send(type, options.dup, &block) } + end + alias :all :any + + def custom(mime, options = {}) + options.reverse_merge!(content_type: mime.to_s) + @context.formats = [mime.to_sym] + options[:body] = block_given? ? yield : @default_render.call + @responses << options + end + end +end diff --git a/actionmailer/lib/action_mailer/delivery_job.rb b/actionmailer/lib/action_mailer/delivery_job.rb new file mode 100644 index 0000000000..f228006920 --- /dev/null +++ b/actionmailer/lib/action_mailer/delivery_job.rb @@ -0,0 +1,44 @@ +# frozen_string_literal: true + +require "active_job" + +module ActionMailer + # The <tt>ActionMailer::DeliveryJob</tt> class is used when you + # want to send emails outside of the request-response cycle. + # + # Exceptions are rescued and handled by the mailer class. + class DeliveryJob < ActiveJob::Base # :nodoc: + queue_as { ActionMailer::Base.deliver_later_queue_name } + + rescue_from StandardError, with: :handle_exception_with_mailer_class + + before_perform do + ActiveSupport::Deprecation.warn <<~MSG.squish + Sending mail with DeliveryJob and Parameterized::DeliveryJob + is deprecated and will be removed in Rails 6.1. + Please use MailDeliveryJob instead. + MSG + end + + def perform(mailer, mail_method, delivery_method, *args) #:nodoc: + mailer.constantize.public_send(mail_method, *args).send(delivery_method) + end + + private + # "Deserialize" the mailer class name by hand in case another argument + # (like a Global ID reference) raised DeserializationError. + def mailer_class + if mailer = Array(@serialized_arguments).first || Array(arguments).first + mailer.constantize + end + end + + def handle_exception_with_mailer_class(exception) + if klass = mailer_class + klass.handle_exception exception + else + raise exception + end + end + end +end diff --git a/actionmailer/lib/action_mailer/delivery_methods.rb b/actionmailer/lib/action_mailer/delivery_methods.rb new file mode 100644 index 0000000000..5cd62307e6 --- /dev/null +++ b/actionmailer/lib/action_mailer/delivery_methods.rb @@ -0,0 +1,82 @@ +# frozen_string_literal: true + +require "tmpdir" + +module ActionMailer + # This module handles everything related to mail delivery, from registering + # new delivery methods to configuring the mail object to be sent. + module DeliveryMethods + extend ActiveSupport::Concern + + included do + # Do not make this inheritable, because we always want it to propagate + cattr_accessor :raise_delivery_errors, default: true + cattr_accessor :perform_deliveries, default: true + cattr_accessor :deliver_later_queue_name, default: :mailers + + class_attribute :delivery_methods, default: {}.freeze + class_attribute :delivery_method, default: :smtp + + add_delivery_method :smtp, Mail::SMTP, + address: "localhost", + port: 25, + domain: "localhost.localdomain", + user_name: nil, + password: nil, + authentication: nil, + enable_starttls_auto: true + + add_delivery_method :file, Mail::FileDelivery, + location: defined?(Rails.root) ? "#{Rails.root}/tmp/mails" : "#{Dir.tmpdir}/mails" + + add_delivery_method :sendmail, Mail::Sendmail, + location: "/usr/sbin/sendmail", + arguments: "-i" + + add_delivery_method :test, Mail::TestMailer + end + + # Helpers for creating and wrapping delivery behavior, used by DeliveryMethods. + module ClassMethods + # Provides a list of emails that have been delivered by Mail::TestMailer + delegate :deliveries, :deliveries=, to: Mail::TestMailer + + # Adds a new delivery method through the given class using the given + # symbol as alias and the default options supplied. + # + # add_delivery_method :sendmail, Mail::Sendmail, + # location: '/usr/sbin/sendmail', + # arguments: '-i' + def add_delivery_method(symbol, klass, default_options = {}) + class_attribute(:"#{symbol}_settings") unless respond_to?(:"#{symbol}_settings") + send(:"#{symbol}_settings=", default_options) + self.delivery_methods = delivery_methods.merge(symbol.to_sym => klass).freeze + end + + def wrap_delivery_behavior(mail, method = nil, options = nil) # :nodoc: + method ||= delivery_method + mail.delivery_handler = self + + case method + when NilClass + raise "Delivery method cannot be nil" + when Symbol + if klass = delivery_methods[method] + mail.delivery_method(klass, (send(:"#{method}_settings") || {}).merge(options || {})) + else + raise "Invalid delivery method #{method.inspect}" + end + else + mail.delivery_method(method) + end + + mail.perform_deliveries = perform_deliveries + mail.raise_delivery_errors = raise_delivery_errors + end + end + + def wrap_delivery_behavior!(*args) # :nodoc: + self.class.wrap_delivery_behavior(message, *args) + end + end +end diff --git a/actionmailer/lib/action_mailer/gem_version.rb b/actionmailer/lib/action_mailer/gem_version.rb new file mode 100644 index 0000000000..72eb5d61e8 --- /dev/null +++ b/actionmailer/lib/action_mailer/gem_version.rb @@ -0,0 +1,17 @@ +# frozen_string_literal: true + +module ActionMailer + # Returns the version of the currently loaded Action Mailer as a <tt>Gem::Version</tt>. + def self.gem_version + Gem::Version.new VERSION::STRING + end + + module VERSION + MAJOR = 6 + MINOR = 0 + TINY = 0 + PRE = "alpha" + + STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".") + end +end diff --git a/actionmailer/lib/action_mailer/inline_preview_interceptor.rb b/actionmailer/lib/action_mailer/inline_preview_interceptor.rb new file mode 100644 index 0000000000..2b97ac5b94 --- /dev/null +++ b/actionmailer/lib/action_mailer/inline_preview_interceptor.rb @@ -0,0 +1,57 @@ +# frozen_string_literal: true + +require "base64" + +module ActionMailer + # Implements a mailer preview interceptor that converts image tag src attributes + # that use inline cid: style URLs to data: style URLs so that they are visible + # when previewing an HTML email in a web browser. + # + # This interceptor is enabled by default. To disable it, delete it from the + # <tt>ActionMailer::Base.preview_interceptors</tt> array: + # + # ActionMailer::Base.preview_interceptors.delete(ActionMailer::InlinePreviewInterceptor) + # + class InlinePreviewInterceptor + PATTERN = /src=(?:"cid:[^"]+"|'cid:[^']+')/i + + include Base64 + + def self.previewing_email(message) #:nodoc: + new(message).transform! + end + + def initialize(message) #:nodoc: + @message = message + end + + def transform! #:nodoc: + return message if html_part.blank? + + html_part.body = html_part.decoded.gsub(PATTERN) do |match| + if part = find_part(match[9..-2]) + %[src="#{data_url(part)}"] + else + match + end + end + + message + end + + private + attr_reader :message + + def html_part + @html_part ||= message.html_part + end + + def data_url(part) + "data:#{part.mime_type};base64,#{strict_encode64(part.body.raw_source)}" + end + + def find_part(cid) + message.all_parts.find { |p| p.attachment? && p.cid == cid } + end + end +end diff --git a/actionmailer/lib/action_mailer/log_subscriber.rb b/actionmailer/lib/action_mailer/log_subscriber.rb new file mode 100644 index 0000000000..25c99342c2 --- /dev/null +++ b/actionmailer/lib/action_mailer/log_subscriber.rb @@ -0,0 +1,46 @@ +# frozen_string_literal: true + +require "active_support/log_subscriber" + +module ActionMailer + # Implements the ActiveSupport::LogSubscriber for logging notifications when + # email is delivered or received. + class LogSubscriber < ActiveSupport::LogSubscriber + # An email was delivered. + def deliver(event) + info do + perform_deliveries = event.payload[:perform_deliveries] + recipients = Array(event.payload[:to]).join(", ") + if perform_deliveries + "Sent mail to #{recipients} (#{event.duration.round(1)}ms)" + else + "Skipped sending mail to #{recipients} as `perform_deliveries` is false" + end + end + + debug { event.payload[:mail] } + end + + # An email was received. + def receive(event) + info { "Received mail (#{event.duration.round(1)}ms)" } + debug { event.payload[:mail] } + end + + # An email was generated. + def process(event) + debug do + mailer = event.payload[:mailer] + action = event.payload[:action] + "#{mailer}##{action}: processed outbound mail in #{event.duration.round(1)}ms" + end + end + + # Use the logger configured for ActionMailer::Base. + def logger + ActionMailer::Base.logger + end + end +end + +ActionMailer::LogSubscriber.attach_to :action_mailer diff --git a/actionmailer/lib/action_mailer/mail_delivery_job.rb b/actionmailer/lib/action_mailer/mail_delivery_job.rb new file mode 100644 index 0000000000..93778edfce --- /dev/null +++ b/actionmailer/lib/action_mailer/mail_delivery_job.rb @@ -0,0 +1,38 @@ +# frozen_string_literal: true + +require "active_job" + +module ActionMailer + # The <tt>ActionMailer::NewDeliveryJob</tt> class is used when you + # want to send emails outside of the request-response cycle. It supports + # sending either parameterized or normal mail. + # + # Exceptions are rescued and handled by the mailer class. + class MailDeliveryJob < ActiveJob::Base # :nodoc: + queue_as { ActionMailer::Base.deliver_later_queue_name } + + rescue_from StandardError, with: :handle_exception_with_mailer_class + + def perform(mailer, mail_method, delivery_method, args:, params: nil) #:nodoc: + mailer_class = params ? mailer.constantize.with(params) : mailer.constantize + mailer_class.public_send(mail_method, *args).send(delivery_method) + end + + private + # "Deserialize" the mailer class name by hand in case another argument + # (like a Global ID reference) raised DeserializationError. + def mailer_class + if mailer = Array(@serialized_arguments).first || Array(arguments).first + mailer.constantize + end + end + + def handle_exception_with_mailer_class(exception) + if klass = mailer_class + klass.handle_exception exception + else + raise exception + end + end + end +end diff --git a/actionmailer/lib/action_mailer/mail_helper.rb b/actionmailer/lib/action_mailer/mail_helper.rb new file mode 100644 index 0000000000..e7bed41f8d --- /dev/null +++ b/actionmailer/lib/action_mailer/mail_helper.rb @@ -0,0 +1,72 @@ +# frozen_string_literal: true + +module ActionMailer + # Provides helper methods for ActionMailer::Base that can be used for easily + # formatting messages, accessing mailer or message instances, and the + # attachments list. + module MailHelper + # Take the text and format it, indented two spaces for each line, and + # wrapped at 72 columns: + # + # text = <<-TEXT + # This is + # the paragraph. + # + # * item1 * item2 + # TEXT + # + # block_format text + # # => " This is the paragraph.\n\n * item1\n * item2\n" + def block_format(text) + formatted = text.split(/\n\r?\n/).collect { |paragraph| + format_paragraph(paragraph) + }.join("\n\n") + + # Make list points stand on their own line + formatted.gsub!(/[ ]*([*]+) ([^*]*)/) { " #{$1} #{$2.strip}\n" } + formatted.gsub!(/[ ]*([#]+) ([^#]*)/) { " #{$1} #{$2.strip}\n" } + + formatted + end + + # Access the mailer instance. + def mailer + @_controller + end + + # Access the message instance. + def message + @_message + end + + # Access the message attachments list. + def attachments + mailer.attachments + end + + # Returns +text+ wrapped at +len+ columns and indented +indent+ spaces. + # By default column length +len+ equals 72 characters and indent + # +indent+ equal two spaces. + # + # my_text = 'Here is a sample text with more than 40 characters' + # + # format_paragraph(my_text, 25, 4) + # # => " Here is a sample text with\n more than 40 characters" + def format_paragraph(text, len = 72, indent = 2) + sentences = [[]] + + text.split.each do |word| + if sentences.first.present? && (sentences.last + [word]).join(" ").length > len + sentences << [word] + else + sentences.last << word + end + end + + indentation = " " * indent + sentences.map! { |sentence| + "#{indentation}#{sentence.join(' ')}" + }.join "\n" + end + end +end diff --git a/actionmailer/lib/action_mailer/message_delivery.rb b/actionmailer/lib/action_mailer/message_delivery.rb new file mode 100644 index 0000000000..1e5cab6d47 --- /dev/null +++ b/actionmailer/lib/action_mailer/message_delivery.rb @@ -0,0 +1,152 @@ +# frozen_string_literal: true + +require "delegate" + +module ActionMailer + # The <tt>ActionMailer::MessageDelivery</tt> class is used by + # ActionMailer::Base when creating a new mailer. + # <tt>MessageDelivery</tt> is a wrapper (+Delegator+ subclass) around a lazy + # created <tt>Mail::Message</tt>. You can get direct access to the + # <tt>Mail::Message</tt>, deliver the email or schedule the email to be sent + # through Active Job. + # + # Notifier.welcome(User.first) # an ActionMailer::MessageDelivery object + # Notifier.welcome(User.first).deliver_now # sends the email + # Notifier.welcome(User.first).deliver_later # enqueue email delivery as a job through Active Job + # Notifier.welcome(User.first).message # a Mail::Message object + class MessageDelivery < Delegator + def initialize(mailer_class, action, *args) #:nodoc: + @mailer_class, @action, @args = mailer_class, action, args + + # The mail is only processed if we try to call any methods on it. + # Typical usage will leave it unloaded and call deliver_later. + @processed_mailer = nil + @mail_message = nil + end + + # Method calls are delegated to the Mail::Message that's ready to deliver. + def __getobj__ #:nodoc: + @mail_message ||= processed_mailer.message + end + + # Unused except for delegator internals (dup, marshalling). + def __setobj__(mail_message) #:nodoc: + @mail_message = mail_message + end + + # Returns the resulting Mail::Message + def message + __getobj__ + end + + # Was the delegate loaded, causing the mailer action to be processed? + def processed? + @processed_mailer || @mail_message + end + + # Enqueues the email to be delivered through Active Job. When the + # job runs it will send the email using +deliver_now!+. That means + # that the message will be sent bypassing checking +perform_deliveries+ + # and +raise_delivery_errors+, so use with caution. + # + # Notifier.welcome(User.first).deliver_later! + # Notifier.welcome(User.first).deliver_later!(wait: 1.hour) + # Notifier.welcome(User.first).deliver_later!(wait_until: 10.hours.from_now) + # + # Options: + # + # * <tt>:wait</tt> - Enqueue the email to be delivered with a delay + # * <tt>:wait_until</tt> - Enqueue the email to be delivered at (after) a specific date / time + # * <tt>:queue</tt> - Enqueue the email on the specified queue + # + # By default, the email will be enqueued using <tt>ActionMailer::DeliveryJob</tt>. Each + # <tt>ActionMailer::Base</tt> class can specify the job to use by setting the class variable + # +delivery_job+. + # + # class AccountRegistrationMailer < ApplicationMailer + # self.delivery_job = RegistrationDeliveryJob + # end + def deliver_later!(options = {}) + enqueue_delivery :deliver_now!, options + end + + # Enqueues the email to be delivered through Active Job. When the + # job runs it will send the email using +deliver_now+. + # + # Notifier.welcome(User.first).deliver_later + # Notifier.welcome(User.first).deliver_later(wait: 1.hour) + # Notifier.welcome(User.first).deliver_later(wait_until: 10.hours.from_now) + # + # Options: + # + # * <tt>:wait</tt> - Enqueue the email to be delivered with a delay. + # * <tt>:wait_until</tt> - Enqueue the email to be delivered at (after) a specific date / time. + # * <tt>:queue</tt> - Enqueue the email on the specified queue. + # + # By default, the email will be enqueued using <tt>ActionMailer::DeliveryJob</tt>. Each + # <tt>ActionMailer::Base</tt> class can specify the job to use by setting the class variable + # +delivery_job+. + # + # class AccountRegistrationMailer < ApplicationMailer + # self.delivery_job = RegistrationDeliveryJob + # end + def deliver_later(options = {}) + enqueue_delivery :deliver_now, options + end + + # Delivers an email without checking +perform_deliveries+ and +raise_delivery_errors+, + # so use with caution. + # + # Notifier.welcome(User.first).deliver_now! + # + def deliver_now! + processed_mailer.handle_exceptions do + message.deliver! + end + end + + # Delivers an email: + # + # Notifier.welcome(User.first).deliver_now + # + def deliver_now + processed_mailer.handle_exceptions do + message.deliver + end + end + + private + # Returns the processed Mailer instance. We keep this instance + # on hand so we can delegate exception handling to it. + def processed_mailer + @processed_mailer ||= @mailer_class.new.tap do |mailer| + mailer.process @action, *@args + end + end + + def enqueue_delivery(delivery_method, options = {}) + if processed? + ::Kernel.raise "You've accessed the message before asking to " \ + "deliver it later, so you may have made local changes that would " \ + "be silently lost if we enqueued a job to deliver it. Why? Only " \ + "the mailer method *arguments* are passed with the delivery job! " \ + "Do not access the message in any way if you mean to deliver it " \ + "later. Workarounds: 1. don't touch the message before calling " \ + "#deliver_later, 2. only touch the message *within your mailer " \ + "method*, or 3. use a custom Active Job instead of #deliver_later." + else + job = @mailer_class.delivery_job + args = arguments_for(job, delivery_method) + job.set(options).perform_later(*args) + end + end + + def arguments_for(delivery_job, delivery_method) + if delivery_job <= MailDeliveryJob + [@mailer_class.name, @action.to_s, delivery_method.to_s, args: @args] + else + [@mailer_class.name, @action.to_s, delivery_method.to_s, *@args] + end + end + end +end diff --git a/actionmailer/lib/action_mailer/parameterized.rb b/actionmailer/lib/action_mailer/parameterized.rb new file mode 100644 index 0000000000..999435919e --- /dev/null +++ b/actionmailer/lib/action_mailer/parameterized.rb @@ -0,0 +1,163 @@ +# frozen_string_literal: true + +module ActionMailer + # Provides the option to parameterize mailers in order to share instance variable + # setup, processing, and common headers. + # + # Consider this example that does not use parameterization: + # + # class InvitationsMailer < ApplicationMailer + # def account_invitation(inviter, invitee) + # @account = inviter.account + # @inviter = inviter + # @invitee = invitee + # + # subject = "#{@inviter.name} invited you to their Basecamp (#{@account.name})" + # + # mail \ + # subject: subject, + # to: invitee.email_address, + # from: common_address(inviter), + # reply_to: inviter.email_address_with_name + # end + # + # def project_invitation(project, inviter, invitee) + # @account = inviter.account + # @project = project + # @inviter = inviter + # @invitee = invitee + # @summarizer = ProjectInvitationSummarizer.new(@project.bucket) + # + # subject = "#{@inviter.name.familiar} added you to a project in Basecamp (#{@account.name})" + # + # mail \ + # subject: subject, + # to: invitee.email_address, + # from: common_address(inviter), + # reply_to: inviter.email_address_with_name + # end + # + # def bulk_project_invitation(projects, inviter, invitee) + # @account = inviter.account + # @projects = projects.sort_by(&:name) + # @inviter = inviter + # @invitee = invitee + # + # subject = "#{@inviter.name.familiar} added you to some new stuff in Basecamp (#{@account.name})" + # + # mail \ + # subject: subject, + # to: invitee.email_address, + # from: common_address(inviter), + # reply_to: inviter.email_address_with_name + # end + # end + # + # InvitationsMailer.account_invitation(person_a, person_b).deliver_later + # + # Using parameterized mailers, this can be rewritten as: + # + # class InvitationsMailer < ApplicationMailer + # before_action { @inviter, @invitee = params[:inviter], params[:invitee] } + # before_action { @account = params[:inviter].account } + # + # default to: -> { @invitee.email_address }, + # from: -> { common_address(@inviter) }, + # reply_to: -> { @inviter.email_address_with_name } + # + # def account_invitation + # mail subject: "#{@inviter.name} invited you to their Basecamp (#{@account.name})" + # end + # + # def project_invitation + # @project = params[:project] + # @summarizer = ProjectInvitationSummarizer.new(@project.bucket) + # + # mail subject: "#{@inviter.name.familiar} added you to a project in Basecamp (#{@account.name})" + # end + # + # def bulk_project_invitation + # @projects = params[:projects].sort_by(&:name) + # + # mail subject: "#{@inviter.name.familiar} added you to some new stuff in Basecamp (#{@account.name})" + # end + # end + # + # InvitationsMailer.with(inviter: person_a, invitee: person_b).account_invitation.deliver_later + module Parameterized + extend ActiveSupport::Concern + + included do + attr_accessor :params + end + + module ClassMethods + # Provide the parameters to the mailer in order to use them in the instance methods and callbacks. + # + # InvitationsMailer.with(inviter: person_a, invitee: person_b).account_invitation.deliver_later + # + # See Parameterized documentation for full example. + def with(params) + ActionMailer::Parameterized::Mailer.new(self, params) + end + end + + class Mailer # :nodoc: + def initialize(mailer, params) + @mailer, @params = mailer, params + end + + private + def method_missing(method_name, *args) + if @mailer.action_methods.include?(method_name.to_s) + ActionMailer::Parameterized::MessageDelivery.new(@mailer, method_name, @params, *args) + else + super + end + end + + def respond_to_missing?(method, include_all = false) + @mailer.respond_to?(method, include_all) + end + end + + class DeliveryJob < ActionMailer::DeliveryJob # :nodoc: + def perform(mailer, mail_method, delivery_method, params, *args) + mailer.constantize.with(params).public_send(mail_method, *args).send(delivery_method) + end + end + + class MessageDelivery < ActionMailer::MessageDelivery # :nodoc: + def initialize(mailer_class, action, params, *args) + super(mailer_class, action, *args) + @params = params + end + + private + def processed_mailer + @processed_mailer ||= @mailer_class.new.tap do |mailer| + mailer.params = @params + mailer.process @action, *@args + end + end + + def enqueue_delivery(delivery_method, options = {}) + if processed? + super + else + job = @mailer_class.delivery_job + args = arguments_for(job, delivery_method) + job.set(options).perform_later(*args) + end + end + + def arguments_for(delivery_job, delivery_method) + if delivery_job <= MailDeliveryJob + [@mailer_class.name, @action.to_s, delivery_method.to_s, params: @params, args: @args] + else + [@mailer_class.name, @action.to_s, delivery_method.to_s, @params, *@args] + end + end + end + end +end diff --git a/actionmailer/lib/action_mailer/preview.rb b/actionmailer/lib/action_mailer/preview.rb new file mode 100644 index 0000000000..500b3bede0 --- /dev/null +++ b/actionmailer/lib/action_mailer/preview.rb @@ -0,0 +1,143 @@ +# frozen_string_literal: true + +require "active_support/descendants_tracker" + +module ActionMailer + module Previews #:nodoc: + extend ActiveSupport::Concern + + included do + # Set the location of mailer previews through app configuration: + # + # config.action_mailer.preview_path = "#{Rails.root}/lib/mailer_previews" + # + mattr_accessor :preview_path, instance_writer: false + + # Enable or disable mailer previews through app configuration: + # + # config.action_mailer.show_previews = true + # + # Defaults to +true+ for development environment + # + mattr_accessor :show_previews, instance_writer: false + + # :nodoc: + mattr_accessor :preview_interceptors, instance_writer: false, default: [ActionMailer::InlinePreviewInterceptor] + end + + module ClassMethods + # Register one or more Interceptors which will be called before mail is previewed. + def register_preview_interceptors(*interceptors) + interceptors.flatten.compact.each { |interceptor| register_preview_interceptor(interceptor) } + end + + # Unregister one or more previously registered Interceptors. + def unregister_preview_interceptors(*interceptors) + interceptors.flatten.compact.each { |interceptor| unregister_preview_interceptor(interceptor) } + end + + # Register an Interceptor which will be called before mail is previewed. + # Either a class or a string can be passed in as the Interceptor. If a + # string is passed in it will be constantized. + def register_preview_interceptor(interceptor) + preview_interceptor = interceptor_class_for(interceptor) + + unless preview_interceptors.include?(preview_interceptor) + preview_interceptors << preview_interceptor + end + end + + # Unregister a previously registered Interceptor. + # Either a class or a string can be passed in as the Interceptor. If a + # string is passed in it will be constantized. + def unregister_preview_interceptor(interceptor) + preview_interceptors.delete(interceptor_class_for(interceptor)) + end + + private + + def interceptor_class_for(interceptor) + case interceptor + when String, Symbol + interceptor.to_s.camelize.constantize + else + interceptor + end + end + end + end + + class Preview + extend ActiveSupport::DescendantsTracker + + attr_reader :params + + def initialize(params = {}) + @params = params + end + + class << self + # Returns all mailer preview classes. + def all + load_previews if descendants.empty? + descendants + end + + # Returns the mail object for the given email name. The registered preview + # interceptors will be informed so that they can transform the message + # as they would if the mail was actually being delivered. + def call(email, params = {}) + preview = new(params) + message = preview.public_send(email) + inform_preview_interceptors(message) + message + end + + # Returns all of the available email previews. + def emails + public_instance_methods(false).map(&:to_s).sort + end + + # Returns +true+ if the email exists. + def email_exists?(email) + emails.include?(email) + end + + # Returns +true+ if the preview exists. + def exists?(preview) + all.any? { |p| p.preview_name == preview } + end + + # Find a mailer preview by its underscored class name. + def find(preview) + all.find { |p| p.preview_name == preview } + end + + # Returns the underscored name of the mailer preview without the suffix. + def preview_name + name.sub(/Preview$/, "").underscore + end + + private + def load_previews + if preview_path + Dir["#{preview_path}/**/*_preview.rb"].sort.each { |file| require_dependency file } + end + end + + def preview_path + Base.preview_path + end + + def show_previews + Base.show_previews + end + + def inform_preview_interceptors(message) + Base.preview_interceptors.each do |interceptor| + interceptor.previewing_email(message) + end + end + end + end +end diff --git a/actionmailer/lib/action_mailer/railtie.rb b/actionmailer/lib/action_mailer/railtie.rb new file mode 100644 index 0000000000..bb6141b406 --- /dev/null +++ b/actionmailer/lib/action_mailer/railtie.rb @@ -0,0 +1,85 @@ +# frozen_string_literal: true + +require "active_job/railtie" +require "action_mailer" +require "rails" +require "abstract_controller/railties/routes_helpers" + +module ActionMailer + class Railtie < Rails::Railtie # :nodoc: + config.action_mailer = ActiveSupport::OrderedOptions.new + config.eager_load_namespaces << ActionMailer + + initializer "action_mailer.logger" do + ActiveSupport.on_load(:action_mailer) { self.logger ||= Rails.logger } + end + + initializer "action_mailer.set_configs" do |app| + paths = app.config.paths + options = app.config.action_mailer + + if app.config.force_ssl + options.default_url_options ||= {} + options.default_url_options[:protocol] ||= "https" + end + + options.assets_dir ||= paths["public"].first + options.javascripts_dir ||= paths["public/javascripts"].first + options.stylesheets_dir ||= paths["public/stylesheets"].first + options.show_previews = Rails.env.development? if options.show_previews.nil? + options.cache_store ||= Rails.cache + + if options.show_previews + options.preview_path ||= defined?(Rails.root) ? "#{Rails.root}/test/mailers/previews" : nil + end + + # make sure readers methods get compiled + options.asset_host ||= app.config.asset_host + options.relative_url_root ||= app.config.relative_url_root + + ActiveSupport.on_load(:action_mailer) do + include AbstractController::UrlFor + extend ::AbstractController::Railties::RoutesHelpers.with(app.routes, false) + include app.routes.mounted_helpers + + register_interceptors(options.delete(:interceptors)) + register_preview_interceptors(options.delete(:preview_interceptors)) + register_observers(options.delete(:observers)) + + options.each { |k, v| send("#{k}=", v) } + end + + ActiveSupport.on_load(:action_dispatch_integration_test) do + include ActionMailer::TestHelper + include ActionMailer::TestCase::ClearTestDeliveries + end + end + + initializer "action_mailer.compile_config_methods" do + ActiveSupport.on_load(:action_mailer) do + config.compile_methods! if config.respond_to?(:compile_methods!) + end + end + + initializer "action_mailer.eager_load_actions" do + ActiveSupport.on_load(:after_initialize) do + ActionMailer::Base.descendants.each(&:action_methods) if config.eager_load + end + end + + config.after_initialize do |app| + options = app.config.action_mailer + + if options.show_previews + app.routes.prepend do + get "/rails/mailers" => "rails/mailers#index", internal: true + get "/rails/mailers/*path" => "rails/mailers#preview", internal: true + end + + if options.preview_path + ActiveSupport::Dependencies.autoload_paths << options.preview_path + end + end + end + end +end diff --git a/actionmailer/lib/action_mailer/rescuable.rb b/actionmailer/lib/action_mailer/rescuable.rb new file mode 100644 index 0000000000..5b567eb500 --- /dev/null +++ b/actionmailer/lib/action_mailer/rescuable.rb @@ -0,0 +1,29 @@ +# frozen_string_literal: true + +module ActionMailer #:nodoc: + # Provides +rescue_from+ for mailers. Wraps mailer action processing, + # mail job processing, and mail delivery. + module Rescuable + extend ActiveSupport::Concern + include ActiveSupport::Rescuable + + class_methods do + def handle_exception(exception) #:nodoc: + rescue_with_handler(exception) || raise(exception) + end + end + + def handle_exceptions #:nodoc: + yield + rescue => exception + rescue_with_handler(exception) || raise + end + + private + def process(*) + handle_exceptions do + super + end + end + end +end diff --git a/actionmailer/lib/action_mailer/test_case.rb b/actionmailer/lib/action_mailer/test_case.rb new file mode 100644 index 0000000000..ee5a864847 --- /dev/null +++ b/actionmailer/lib/action_mailer/test_case.rb @@ -0,0 +1,123 @@ +# frozen_string_literal: true + +require "active_support/test_case" +require "rails-dom-testing" + +module ActionMailer + class NonInferrableMailerError < ::StandardError + def initialize(name) + super "Unable to determine the mailer to test from #{name}. " \ + "You'll need to specify it using tests YourMailer in your " \ + "test case definition" + end + end + + class TestCase < ActiveSupport::TestCase + module ClearTestDeliveries + extend ActiveSupport::Concern + + included do + setup :clear_test_deliveries + teardown :clear_test_deliveries + end + + private + + def clear_test_deliveries + if ActionMailer::Base.delivery_method == :test + ActionMailer::Base.deliveries.clear + end + end + end + + module Behavior + extend ActiveSupport::Concern + + include ActiveSupport::Testing::ConstantLookup + include TestHelper + include Rails::Dom::Testing::Assertions::SelectorAssertions + include Rails::Dom::Testing::Assertions::DomAssertions + + included do + class_attribute :_mailer_class + setup :initialize_test_deliveries + setup :set_expected_mail + teardown :restore_test_deliveries + ActiveSupport.run_load_hooks(:action_mailer_test_case, self) + end + + module ClassMethods + def tests(mailer) + case mailer + when String, Symbol + self._mailer_class = mailer.to_s.camelize.constantize + when Module + self._mailer_class = mailer + else + raise NonInferrableMailerError.new(mailer) + end + end + + def mailer_class + if mailer = _mailer_class + mailer + else + tests determine_default_mailer(name) + end + end + + def determine_default_mailer(name) + mailer = determine_constant_from_test_name(name) do |constant| + Class === constant && constant < ActionMailer::Base + end + raise NonInferrableMailerError.new(name) if mailer.nil? + mailer + end + end + + private + + def initialize_test_deliveries + set_delivery_method :test + @old_perform_deliveries = ActionMailer::Base.perform_deliveries + ActionMailer::Base.perform_deliveries = true + ActionMailer::Base.deliveries.clear + end + + def restore_test_deliveries + restore_delivery_method + ActionMailer::Base.perform_deliveries = @old_perform_deliveries + end + + def set_delivery_method(method) + @old_delivery_method = ActionMailer::Base.delivery_method + ActionMailer::Base.delivery_method = method + end + + def restore_delivery_method + ActionMailer::Base.deliveries.clear + ActionMailer::Base.delivery_method = @old_delivery_method + end + + def set_expected_mail + @expected = Mail.new + @expected.content_type ["text", "plain", { "charset" => charset }] + @expected.mime_version = "1.0" + end + + def charset + "UTF-8" + end + + def encode(subject) + Mail::Encodings.q_value_encode(subject, charset) + end + + def read_fixture(action) + IO.readlines(File.join(Rails.root, "test", "fixtures", self.class.mailer_class.name.underscore, action)) + end + end + + include Behavior + end +end diff --git a/actionmailer/lib/action_mailer/test_helper.rb b/actionmailer/lib/action_mailer/test_helper.rb new file mode 100644 index 0000000000..e222301dff --- /dev/null +++ b/actionmailer/lib/action_mailer/test_helper.rb @@ -0,0 +1,162 @@ +# frozen_string_literal: true + +require "active_job" + +module ActionMailer + # Provides helper methods for testing Action Mailer, including #assert_emails + # and #assert_no_emails. + module TestHelper + include ActiveJob::TestHelper + + # Asserts that the number of emails sent matches the given number. + # + # def test_emails + # assert_emails 0 + # ContactMailer.welcome.deliver_now + # assert_emails 1 + # ContactMailer.welcome.deliver_now + # assert_emails 2 + # end + # + # If a block is passed, that block should cause the specified number of + # emails to be sent. + # + # def test_emails_again + # assert_emails 1 do + # ContactMailer.welcome.deliver_now + # end + # + # assert_emails 2 do + # ContactMailer.welcome.deliver_now + # ContactMailer.welcome.deliver_later + # end + # end + def assert_emails(number, &block) + if block_given? + original_count = ActionMailer::Base.deliveries.size + perform_enqueued_jobs(only: ->(job) { delivery_job_filter(job) }, &block) + new_count = ActionMailer::Base.deliveries.size + assert_equal number, new_count - original_count, "#{number} emails expected, but #{new_count - original_count} were sent" + else + assert_equal number, ActionMailer::Base.deliveries.size + end + end + + # Asserts that no emails have been sent. + # + # def test_emails + # assert_no_emails + # ContactMailer.welcome.deliver_now + # assert_emails 1 + # end + # + # If a block is passed, that block should not cause any emails to be sent. + # + # def test_emails_again + # assert_no_emails do + # # No emails should be sent from this block + # end + # end + # + # Note: This assertion is simply a shortcut for: + # + # assert_emails 0, &block + def assert_no_emails(&block) + assert_emails 0, &block + end + + # Asserts that the number of emails enqueued for later delivery matches + # the given number. + # + # def test_emails + # assert_enqueued_emails 0 + # ContactMailer.welcome.deliver_later + # assert_enqueued_emails 1 + # ContactMailer.welcome.deliver_later + # assert_enqueued_emails 2 + # end + # + # If a block is passed, that block should cause the specified number of + # emails to be enqueued. + # + # def test_emails_again + # assert_enqueued_emails 1 do + # ContactMailer.welcome.deliver_later + # end + # + # assert_enqueued_emails 2 do + # ContactMailer.welcome.deliver_later + # ContactMailer.welcome.deliver_later + # end + # end + def assert_enqueued_emails(number, &block) + assert_enqueued_jobs(number, only: ->(job) { delivery_job_filter(job) }, &block) + end + + # Asserts that a specific email has been enqueued, optionally + # matching arguments. + # + # def test_email + # ContactMailer.welcome.deliver_later + # assert_enqueued_email_with ContactMailer, :welcome + # end + # + # def test_email_with_arguments + # ContactMailer.welcome("Hello", "Goodbye").deliver_later + # assert_enqueued_email_with ContactMailer, :welcome, args: ["Hello", "Goodbye"] + # end + # + # If a block is passed, that block should cause the specified email + # to be enqueued. + # + # def test_email_in_block + # assert_enqueued_email_with ContactMailer, :welcome do + # ContactMailer.welcome.deliver_later + # end + # end + # + # If +args+ is provided as a Hash, a parameterized email is matched. + # + # def test_parameterized_email + # assert_enqueued_email_with ContactMailer, :welcome, + # args: {email: 'user@example.com'} do + # ContactMailer.with(email: 'user@example.com').welcome.deliver_later + # end + # end + def assert_enqueued_email_with(mailer, method, args: nil, queue: "mailers", &block) + args = if args.is_a?(Hash) + [mailer.to_s, method.to_s, "deliver_now", params: args, args: []] + else + [mailer.to_s, method.to_s, "deliver_now", args: Array(args)] + end + assert_enqueued_with(job: mailer.delivery_job, args: args, queue: queue, &block) + end + + # Asserts that no emails are enqueued for later delivery. + # + # def test_no_emails + # assert_no_enqueued_emails + # ContactMailer.welcome.deliver_later + # assert_enqueued_emails 1 + # end + # + # If a block is provided, it should not cause any emails to be enqueued. + # + # def test_no_emails + # assert_no_enqueued_emails do + # # No emails should be enqueued from this block + # end + # end + def assert_no_enqueued_emails(&block) + assert_enqueued_emails 0, &block + end + + private + + def delivery_job_filter(job) + job_class = job.is_a?(Hash) ? job.fetch(:job) : job.class + + Base.descendants.map(&:delivery_job).include?(job_class) + end + end +end diff --git a/actionmailer/lib/action_mailer/version.rb b/actionmailer/lib/action_mailer/version.rb new file mode 100644 index 0000000000..4549d6eb57 --- /dev/null +++ b/actionmailer/lib/action_mailer/version.rb @@ -0,0 +1,11 @@ +# frozen_string_literal: true + +require_relative "gem_version" + +module ActionMailer + # Returns the version of the currently loaded Action Mailer as a + # <tt>Gem::Version</tt>. + def self.version + gem_version + end +end diff --git a/actionmailer/lib/rails/generators/mailer/USAGE b/actionmailer/lib/rails/generators/mailer/USAGE new file mode 100644 index 0000000000..2b0a078109 --- /dev/null +++ b/actionmailer/lib/rails/generators/mailer/USAGE @@ -0,0 +1,17 @@ +Description: +============ + Stubs out a new mailer and its views. Passes the mailer name, either + CamelCased or under_scored, and an optional list of emails as arguments. + + This generates a mailer class in app/mailers and invokes your template + engine and test framework generators. + +Example: +======== + rails generate mailer Notifications signup forgot_password invoice + + creates a Notifications mailer class, views, and test: + Mailer: app/mailers/notifications_mailer.rb + Views: app/views/notifications_mailer/signup.text.erb [...] + Test: test/mailers/notifications_mailer_test.rb + diff --git a/actionmailer/lib/rails/generators/mailer/mailer_generator.rb b/actionmailer/lib/rails/generators/mailer/mailer_generator.rb new file mode 100644 index 0000000000..c37a74c762 --- /dev/null +++ b/actionmailer/lib/rails/generators/mailer/mailer_generator.rb @@ -0,0 +1,38 @@ +# frozen_string_literal: true + +module Rails + module Generators + class MailerGenerator < NamedBase + source_root File.expand_path("templates", __dir__) + + argument :actions, type: :array, default: [], banner: "method method" + + check_class_collision suffix: "Mailer" + + def create_mailer_file + template "mailer.rb", File.join("app/mailers", class_path, "#{file_name}_mailer.rb") + + in_root do + if behavior == :invoke && !File.exist?(application_mailer_file_name) + template "application_mailer.rb", application_mailer_file_name + end + end + end + + hook_for :template_engine, :test_framework + + private + def file_name # :doc: + @_file_name ||= super.sub(/_mailer\z/i, "") + end + + def application_mailer_file_name + @_application_mailer_file_name ||= if mountable_engine? + "app/mailers/#{namespaced_path}/application_mailer.rb" + else + "app/mailers/application_mailer.rb" + end + end + end + end +end diff --git a/actionmailer/lib/rails/generators/mailer/templates/application_mailer.rb.tt b/actionmailer/lib/rails/generators/mailer/templates/application_mailer.rb.tt new file mode 100644 index 0000000000..00fb9bd48f --- /dev/null +++ b/actionmailer/lib/rails/generators/mailer/templates/application_mailer.rb.tt @@ -0,0 +1,6 @@ +<% module_namespacing do -%> +class ApplicationMailer < ActionMailer::Base + default from: 'from@example.com' + layout 'mailer' +end +<% end %> diff --git a/actionmailer/lib/rails/generators/mailer/templates/mailer.rb.tt b/actionmailer/lib/rails/generators/mailer/templates/mailer.rb.tt new file mode 100644 index 0000000000..348d314758 --- /dev/null +++ b/actionmailer/lib/rails/generators/mailer/templates/mailer.rb.tt @@ -0,0 +1,17 @@ +<% module_namespacing do -%> +class <%= class_name %>Mailer < ApplicationMailer +<% actions.each do |action| -%> + + # Subject can be set in your I18n file at config/locales/en.yml + # with the following lookup: + # + # en.<%= file_path.tr("/",".") %>_mailer.<%= action %>.subject + # + def <%= action %> + @greeting = "Hi" + + mail to: "to@example.org" + end +<% end -%> +end +<% end -%> diff --git a/actionmailer/test/abstract_unit.rb b/actionmailer/test/abstract_unit.rb new file mode 100644 index 0000000000..f647896374 --- /dev/null +++ b/actionmailer/test/abstract_unit.rb @@ -0,0 +1,49 @@ +# frozen_string_literal: true + +require "active_support/core_ext/kernel/reporting" + +# These are the normal settings that will be set up by Railties +# TODO: Have these tests support other combinations of these values +silence_warnings do + Encoding.default_internal = Encoding::UTF_8 + Encoding.default_external = Encoding::UTF_8 +end + +module Rails + def self.root + File.expand_path("..", __dir__) + end +end + +require "active_support/testing/autorun" +require "active_support/testing/method_call_assertions" +require "action_mailer" +require "action_mailer/test_case" + +# Emulate AV railtie +require "action_view" +ActionMailer::Base.include(ActionView::Layouts) + +# Show backtraces for deprecated behavior for quicker cleanup. +ActiveSupport::Deprecation.debug = true + +# Disable available locale checks to avoid warnings running the test suite. +I18n.enforce_available_locales = false + +FIXTURE_LOAD_PATH = File.expand_path("fixtures", __dir__) +ActionMailer::Base.view_paths = FIXTURE_LOAD_PATH + +class ActiveSupport::TestCase + include ActiveSupport::Testing::MethodCallAssertions + + private + # Skips the current run on Rubinius using Minitest::Assertions#skip + def rubinius_skip(message = "") + skip message if RUBY_ENGINE == "rbx" + end + + # Skips the current run on JRuby using Minitest::Assertions#skip + def jruby_skip(message = "") + skip message if defined?(JRUBY_VERSION) + end +end diff --git a/actionmailer/test/assert_select_email_test.rb b/actionmailer/test/assert_select_email_test.rb new file mode 100644 index 0000000000..9699fe4000 --- /dev/null +++ b/actionmailer/test/assert_select_email_test.rb @@ -0,0 +1,49 @@ +# frozen_string_literal: true + +require "abstract_unit" + +class AssertSelectEmailTest < ActionMailer::TestCase + class AssertSelectMailer < ActionMailer::Base + def test(html) + mail body: html, content_type: "text/html", + subject: "Test e-mail", from: "test@test.host", to: "test <test@test.host>" + end + end + + class AssertMultipartSelectMailer < ActionMailer::Base + def test(options) + mail subject: "Test e-mail", from: "test@test.host", to: "test <test@test.host>" do |format| + format.text { render plain: options[:text] } + format.html { render plain: options[:html] } + end + end + end + + # + # Test assert_select_email + # + + def test_assert_select_email + assert_raise ActiveSupport::TestCase::Assertion do + assert_select_email { } + end + + AssertSelectMailer.test("<div><p>foo</p><p>bar</p></div>").deliver_now + assert_select_email do + assert_select "div:root" do + assert_select "p:first-child", "foo" + assert_select "p:last-child", "bar" + end + end + end + + def test_assert_select_email_multipart + AssertMultipartSelectMailer.test(html: "<div><p>foo</p><p>bar</p></div>", text: "foo bar").deliver_now + assert_select_email do + assert_select "div:root" do + assert_select "p:first-child", "foo" + assert_select "p:last-child", "bar" + end + end + end +end diff --git a/actionmailer/test/asset_host_test.rb b/actionmailer/test/asset_host_test.rb new file mode 100644 index 0000000000..9cd8cae88c --- /dev/null +++ b/actionmailer/test/asset_host_test.rb @@ -0,0 +1,39 @@ +# frozen_string_literal: true + +require "abstract_unit" +require "action_controller" + +class AssetHostMailer < ActionMailer::Base + def email_with_asset + mail to: "test@localhost", + subject: "testing email containing asset path while asset_host is set", + from: "tester@example.com" + end +end + +class AssetHostTest < ActionMailer::TestCase + def setup + AssetHostMailer.configure do |c| + c.asset_host = "http://www.example.com" + end + end + + def teardown + restore_delivery_method + end + + def test_asset_host_as_string + mail = AssetHostMailer.email_with_asset + assert_dom_equal '<img src="http://www.example.com/images/somelogo.png" />', mail.body.to_s.strip + end + + def test_asset_host_as_one_argument_proc + AssetHostMailer.config.asset_host = Proc.new { |source| + if source.starts_with?("/images") + "http://images.example.com" + end + } + mail = AssetHostMailer.email_with_asset + assert_dom_equal '<img src="http://images.example.com/images/somelogo.png" />', mail.body.to_s.strip + end +end diff --git a/actionmailer/test/base_test.rb b/actionmailer/test/base_test.rb new file mode 100644 index 0000000000..d0c4f189fd --- /dev/null +++ b/actionmailer/test/base_test.rb @@ -0,0 +1,1066 @@ +# frozen_string_literal: true + +require "abstract_unit" +require "set" + +require "action_dispatch" +require "active_support/time" + +require "mailers/base_mailer" +require "mailers/proc_mailer" +require "mailers/asset_mailer" + +class BaseTest < ActiveSupport::TestCase + include Rails::Dom::Testing::Assertions::DomAssertions + + setup do + @original_delivery_method = ActionMailer::Base.delivery_method + ActionMailer::Base.delivery_method = :test + @original_asset_host = ActionMailer::Base.asset_host + @original_assets_dir = ActionMailer::Base.assets_dir + end + + teardown do + ActionMailer::Base.asset_host = @original_asset_host + ActionMailer::Base.assets_dir = @original_assets_dir + BaseMailer.deliveries.clear + ActionMailer::Base.delivery_method = @original_delivery_method + end + + test "method call to mail does not raise error" do + assert_nothing_raised { BaseMailer.welcome } + end + + # Basic mail usage without block + test "mail() should set the headers of the mail message" do + email = BaseMailer.welcome + assert_equal(["system@test.lindsaar.net"], email.to) + assert_equal(["jose@test.plataformatec.com"], email.from) + assert_equal("The first email on new API!", email.subject) + end + + test "mail() with from overwrites the class level default" do + email = BaseMailer.welcome(from: "someone@example.com", + to: "another@example.org") + assert_equal(["someone@example.com"], email.from) + assert_equal(["another@example.org"], email.to) + end + + test "mail() with bcc, cc, content_type, charset, mime_version, reply_to and date" do + time = Time.now.beginning_of_day.to_datetime + email = BaseMailer.welcome(bcc: "bcc@test.lindsaar.net", + cc: "cc@test.lindsaar.net", + content_type: "multipart/mixed", + charset: "iso-8559-1", + mime_version: "2.0", + reply_to: "reply-to@test.lindsaar.net", + date: time) + assert_equal(["bcc@test.lindsaar.net"], email.bcc) + assert_equal(["cc@test.lindsaar.net"], email.cc) + assert_equal("multipart/mixed; charset=iso-8559-1", email.content_type) + assert_equal("iso-8559-1", email.charset) + assert_equal("2.0", email.mime_version) + assert_equal(["reply-to@test.lindsaar.net"], email.reply_to) + assert_equal(time, email.date) + end + + test "mail() renders the template using the method being processed" do + email = BaseMailer.welcome + assert_equal("Welcome", email.body.encoded) + end + + test "can pass in :body to the mail method hash" do + email = BaseMailer.welcome(body: "Hello there") + assert_equal("text/plain", email.mime_type) + assert_equal("Hello there", email.body.encoded) + end + + test "should set template content type if mail has only one part" do + mail = BaseMailer.html_only + assert_equal("text/html", mail.mime_type) + mail = BaseMailer.plain_text_only + assert_equal("text/plain", mail.mime_type) + end + + # Custom headers + test "custom headers" do + email = BaseMailer.welcome + assert_equal("Not SPAM", email["X-SPAM"].decoded) + end + + test "can pass random headers in as a hash to mail" do + hash = { "X-Special-Domain-Specific-Header" => "SecretValue", + "In-Reply-To" => "<1234@mikel.me.com>" } + mail = BaseMailer.welcome(hash) + assert_equal("SecretValue", mail["X-Special-Domain-Specific-Header"].decoded) + assert_equal("<1234@mikel.me.com>", mail["In-Reply-To"].decoded) + end + + test "can pass random headers in as a hash to headers" do + hash = { "X-Special-Domain-Specific-Header" => "SecretValue", + "In-Reply-To" => "<1234@mikel.me.com>" } + mail = BaseMailer.welcome_with_headers(hash) + assert_equal("SecretValue", mail["X-Special-Domain-Specific-Header"].decoded) + assert_equal("<1234@mikel.me.com>", mail["In-Reply-To"].decoded) + end + + # Attachments + test "attachment with content" do + email = BaseMailer.attachment_with_content + assert_equal(1, email.attachments.length) + assert_equal("invoice.pdf", email.attachments[0].filename) + assert_equal("This is test File content", email.attachments["invoice.pdf"].decoded) + end + + test "attachment gets content type from filename" do + email = BaseMailer.attachment_with_content + assert_equal("invoice.pdf", email.attachments[0].filename) + assert_equal("application/pdf", email.attachments[0].mime_type) + end + + test "attachment with hash" do + email = BaseMailer.attachment_with_hash + assert_equal(1, email.attachments.length) + assert_equal("invoice.jpg", email.attachments[0].filename) + expected = +"\312\213\254\232)b" + expected.force_encoding(Encoding::BINARY) + assert_equal expected, email.attachments["invoice.jpg"].decoded + end + + test "attachment with hash using default mail encoding" do + email = BaseMailer.attachment_with_hash_default_encoding + assert_equal(1, email.attachments.length) + assert_equal("invoice.jpg", email.attachments[0].filename) + expected = +"\312\213\254\232)b" + expected.force_encoding(Encoding::BINARY) + assert_equal expected, email.attachments["invoice.jpg"].decoded + end + + test "sets mime type to multipart/mixed when attachment is included" do + email = BaseMailer.attachment_with_content + assert_equal(1, email.attachments.length) + assert_equal("multipart/mixed", email.mime_type) + end + + test "set mime type to text/html when attachment is included and body is set" do + email = BaseMailer.attachment_with_content(body: "Hello there", content_type: "text/html") + assert_equal("text/html", email.mime_type) + end + + test "adds the rendered template as part" do + email = BaseMailer.attachment_with_content + assert_equal(2, email.parts.length) + assert_equal("multipart/mixed", email.mime_type) + assert_equal("text/html", email.parts[0].mime_type) + assert_equal("Attachment with content", email.parts[0].decoded) + assert_equal("application/pdf", email.parts[1].mime_type) + assert_equal("This is test File content", email.parts[1].decoded) + end + + test "adds the given :body as part" do + email = BaseMailer.attachment_with_content(body: "I'm the eggman") + assert_equal(2, email.parts.length) + assert_equal("multipart/mixed", email.mime_type) + assert_equal("text/plain", email.parts[0].mime_type) + assert_equal("I'm the eggman", email.parts[0].decoded) + assert_equal("application/pdf", email.parts[1].mime_type) + assert_equal("This is test File content", email.parts[1].decoded) + end + + test "can embed an inline attachment" do + email = BaseMailer.inline_attachment + # Need to call #encoded to force the JIT sort on parts + email.encoded + assert_equal(2, email.parts.length) + assert_equal("multipart/related", email.mime_type) + assert_equal("multipart/alternative", email.parts[0].mime_type) + assert_equal("text/plain", email.parts[0].parts[0].mime_type) + assert_equal("text/html", email.parts[0].parts[1].mime_type) + assert_equal("logo.png", email.parts[1].filename) + end + + # Defaults values + test "uses default charset from class" do + with_default BaseMailer, charset: "US-ASCII" do + email = BaseMailer.welcome + assert_equal("US-ASCII", email.charset) + + email = BaseMailer.welcome(charset: "iso-8559-1") + assert_equal("iso-8559-1", email.charset) + end + end + + test "uses default content type from class" do + with_default BaseMailer, content_type: "text/html" do + email = BaseMailer.welcome + assert_equal("text/html", email.mime_type) + + email = BaseMailer.welcome(content_type: "text/plain") + assert_equal("text/plain", email.mime_type) + end + end + + test "uses default mime version from class" do + with_default BaseMailer, mime_version: "2.0" do + email = BaseMailer.welcome + assert_equal("2.0", email.mime_version) + + email = BaseMailer.welcome(mime_version: "1.0") + assert_equal("1.0", email.mime_version) + end + end + + test "uses random default headers from class" do + with_default BaseMailer, "X-Custom" => "Custom" do + email = BaseMailer.welcome + assert_equal("Custom", email["X-Custom"].decoded) + end + end + + test "subject gets default from I18n" do + with_default BaseMailer, subject: nil do + email = BaseMailer.welcome(subject: nil) + assert_equal "Welcome", email.subject + + with_translation "en", base_mailer: { welcome: { subject: "New Subject!" } } do + email = BaseMailer.welcome(subject: nil) + assert_equal "New Subject!", email.subject + end + end + end + + test "default subject can have interpolations" do + with_translation "en", base_mailer: { with_subject_interpolations: { subject: "Will the real %{rapper_or_impersonator} please stand up?" } } do + email = BaseMailer.with_subject_interpolations + assert_equal "Will the real Slim Shady please stand up?", email.subject + end + end + + test "translations are scoped properly" do + with_translation "en", base_mailer: { email_with_translations: { greet_user: "Hello %{name}!" } } do + email = BaseMailer.email_with_translations + assert_equal "Hello lifo!", email.body.encoded + end + end + + test "adding attachments after mail was called raises exception" do + class LateAttachmentMailer < ActionMailer::Base + def welcome + mail body: "yay", from: "welcome@example.com", to: "to@example.com" + attachments["invoice.pdf"] = "This is test File content" + end + end + + e = assert_raises(RuntimeError) { LateAttachmentMailer.welcome.message } + assert_match(/Can't add attachments after `mail` was called./, e.message) + end + + test "adding inline attachments after mail was called raises exception" do + class LateInlineAttachmentMailer < ActionMailer::Base + def welcome + mail body: "yay", from: "welcome@example.com", to: "to@example.com" + attachments.inline["invoice.pdf"] = "This is test File content" + end + end + + e = assert_raises(RuntimeError) { LateInlineAttachmentMailer.welcome.message } + assert_match(/Can't add attachments after `mail` was called./, e.message) + end + + test "adding inline attachments while rendering mail works" do + class LateInlineAttachmentMailer < ActionMailer::Base + def on_render + mail from: "welcome@example.com", to: "to@example.com" + end + end + + mail = LateInlineAttachmentMailer.on_render + assert_nothing_raised { mail.message } + + assert_equal ["image/jpeg; filename=controller_attachments.jpg", + "image/jpeg; filename=attachments.jpg"], mail.attachments.inline.map { |a| a["Content-Type"].to_s } + end + + test "accessing attachments works after mail was called" do + class LateAttachmentAccessorMailer < ActionMailer::Base + def welcome + attachments["invoice.pdf"] = "This is test File content" + mail body: "yay", from: "welcome@example.com", to: "to@example.com" + + unless attachments.map(&:filename) == ["invoice.pdf"] + raise Minitest::Assertion, "Should allow access to attachments" + end + end + end + + assert_nothing_raised { LateAttachmentAccessorMailer.welcome.message } + end + + # Implicit multipart + test "implicit multipart" do + email = BaseMailer.implicit_multipart + assert_equal(2, email.parts.size) + assert_equal("multipart/alternative", email.mime_type) + assert_equal("text/plain", email.parts[0].mime_type) + assert_equal("TEXT Implicit Multipart", email.parts[0].body.encoded) + assert_equal("text/html", email.parts[1].mime_type) + assert_equal("HTML Implicit Multipart", email.parts[1].body.encoded) + end + + test "implicit multipart with sort order" do + order = ["text/html", "text/plain"] + with_default BaseMailer, parts_order: order do + email = BaseMailer.implicit_multipart + assert_equal("text/html", email.parts[0].mime_type) + assert_equal("text/plain", email.parts[1].mime_type) + + email = BaseMailer.implicit_multipart(parts_order: order.reverse) + assert_equal("text/plain", email.parts[0].mime_type) + assert_equal("text/html", email.parts[1].mime_type) + end + end + + test "implicit multipart with attachments creates nested parts" do + email = BaseMailer.implicit_multipart(attachments: true) + assert_equal(%w[ application/pdf multipart/alternative ], email.parts.map(&:mime_type).sort) + multipart = email.parts.detect { |p| p.mime_type == "multipart/alternative" } + assert_equal("text/plain", multipart.parts[0].mime_type) + assert_equal("TEXT Implicit Multipart", multipart.parts[0].body.encoded) + assert_equal("text/html", multipart.parts[1].mime_type) + assert_equal("HTML Implicit Multipart", multipart.parts[1].body.encoded) + end + + test "implicit multipart with attachments and sort order" do + order = ["text/html", "text/plain"] + with_default BaseMailer, parts_order: order do + email = BaseMailer.implicit_multipart(attachments: true) + assert_equal(%w[ application/pdf multipart/alternative ], email.parts.map(&:mime_type).sort) + multipart = email.parts.detect { |p| p.mime_type == "multipart/alternative" } + assert_equal(%w[ text/html text/plain ], multipart.parts.map(&:mime_type).sort) + end + end + + test "implicit multipart with default locale" do + email = BaseMailer.implicit_with_locale + assert_equal(2, email.parts.size) + assert_equal("multipart/alternative", email.mime_type) + assert_equal("text/plain", email.parts[0].mime_type) + assert_equal("Implicit with locale TEXT", email.parts[0].body.encoded) + assert_equal("text/html", email.parts[1].mime_type) + assert_equal("Implicit with locale EN HTML", email.parts[1].body.encoded) + end + + test "implicit multipart with other locale" do + swap I18n, locale: :pl do + email = BaseMailer.implicit_with_locale + assert_equal(2, email.parts.size) + assert_equal("multipart/alternative", email.mime_type) + assert_equal("text/plain", email.parts[0].mime_type) + assert_equal("Implicit with locale PL TEXT", email.parts[0].body.encoded) + assert_equal("text/html", email.parts[1].mime_type) + assert_equal("Implicit with locale EN HTML", email.parts[1].body.encoded) + end + end + + test "implicit multipart with fallback locale" do + fallback_backend = Class.new(I18n::Backend::Simple) do + include I18n::Backend::Fallbacks + end + + begin + backend = I18n.backend + I18n.backend = fallback_backend.new + I18n.fallbacks[:"de-AT"] = [:de] + + swap I18n, locale: "de-AT" do + email = BaseMailer.implicit_with_locale + assert_equal(2, email.parts.size) + assert_equal("multipart/alternative", email.mime_type) + assert_equal("text/plain", email.parts[0].mime_type) + assert_equal("Implicit with locale DE-AT TEXT", email.parts[0].body.encoded) + assert_equal("text/html", email.parts[1].mime_type) + assert_equal("Implicit with locale DE HTML", email.parts[1].body.encoded) + end + ensure + I18n.backend = backend + end + end + + test "implicit multipart with several view paths uses the first one with template" do + old = BaseMailer.view_paths + begin + BaseMailer.view_paths = [File.join(FIXTURE_LOAD_PATH, "another.path")] + old.dup + email = BaseMailer.welcome + assert_equal("Welcome from another path", email.body.encoded) + ensure + BaseMailer.view_paths = old + end + end + + test "implicit multipart with inexistent templates uses the next view path" do + old = BaseMailer.view_paths + begin + BaseMailer.view_paths = [File.join(FIXTURE_LOAD_PATH, "unknown")] + old.dup + email = BaseMailer.welcome + assert_equal("Welcome", email.body.encoded) + ensure + BaseMailer.view_paths = old + end + end + + # Explicit multipart + test "explicit multipart" do + email = BaseMailer.explicit_multipart + assert_equal(2, email.parts.size) + assert_equal("multipart/alternative", email.mime_type) + assert_equal("text/plain", email.parts[0].mime_type) + assert_equal("TEXT Explicit Multipart", email.parts[0].body.encoded) + assert_equal("text/html", email.parts[1].mime_type) + assert_equal("HTML Explicit Multipart", email.parts[1].body.encoded) + end + + test "explicit multipart have a boundary" do + mail = BaseMailer.explicit_multipart + assert_not_nil(mail.content_type_parameters[:boundary]) + end + + test "explicit multipart with attachments creates nested parts" do + email = BaseMailer.explicit_multipart(attachments: true) + assert_equal(%w[ application/pdf multipart/alternative ], email.parts.map(&:mime_type).sort) + multipart = email.parts.detect { |p| p.mime_type == "multipart/alternative" } + assert_equal("text/plain", multipart.parts[0].mime_type) + assert_equal("TEXT Explicit Multipart", multipart.parts[0].body.encoded) + assert_equal("text/html", multipart.parts[1].mime_type) + assert_equal("HTML Explicit Multipart", multipart.parts[1].body.encoded) + end + + test "explicit multipart with templates" do + email = BaseMailer.explicit_multipart_templates + assert_equal(2, email.parts.size) + assert_equal("multipart/alternative", email.mime_type) + assert_equal("text/plain", email.parts[0].mime_type) + assert_equal("TEXT Explicit Multipart Templates", email.parts[0].body.encoded) + assert_equal("text/html", email.parts[1].mime_type) + assert_equal("HTML Explicit Multipart Templates", email.parts[1].body.encoded) + end + + test "explicit multipart with format.any" do + email = BaseMailer.explicit_multipart_with_any + assert_equal(2, email.parts.size) + assert_equal("multipart/alternative", email.mime_type) + assert_equal("text/plain", email.parts[0].mime_type) + assert_equal("Format with any!", email.parts[0].body.encoded) + assert_equal("text/html", email.parts[1].mime_type) + assert_equal("Format with any!", email.parts[1].body.encoded) + end + + test "explicit without specifying format with format.any" do + error = assert_raises(ArgumentError) do + BaseMailer.explicit_without_specifying_format_with_any.parts + end + assert_equal "You have to supply at least one format", error.message + end + + test "explicit multipart with format(Hash)" do + email = BaseMailer.explicit_multipart_with_options(true) + email.ready_to_send! + assert_equal(2, email.parts.size) + assert_equal("multipart/alternative", email.mime_type) + assert_equal("text/plain", email.parts[0].mime_type) + assert_equal("base64", email.parts[0].content_transfer_encoding) + assert_equal("text/html", email.parts[1].mime_type) + assert_equal("7bit", email.parts[1].content_transfer_encoding) + end + + test "explicit multipart with one part is rendered as body and options are merged" do + email = BaseMailer.explicit_multipart_with_options + assert_equal(0, email.parts.size) + assert_equal("text/plain", email.mime_type) + assert_equal("base64", email.content_transfer_encoding) + end + + test "explicit multipart with one template has the expected format" do + email = BaseMailer.explicit_multipart_with_one_template + assert_equal(2, email.parts.size) + assert_equal("multipart/alternative", email.mime_type) + assert_equal("text/plain", email.parts[0].mime_type) + assert_equal("[:text]", email.parts[0].body.encoded) + assert_equal("text/html", email.parts[1].mime_type) + assert_equal("[:html]", email.parts[1].body.encoded) + end + + test "explicit multipart with sort order" do + order = ["text/html", "text/plain"] + with_default BaseMailer, parts_order: order do + email = BaseMailer.explicit_multipart + assert_equal("text/html", email.parts[0].mime_type) + assert_equal("text/plain", email.parts[1].mime_type) + + email = BaseMailer.explicit_multipart(parts_order: order.reverse) + assert_equal("text/plain", email.parts[0].mime_type) + assert_equal("text/html", email.parts[1].mime_type) + end + end + + # Class level API with method missing + test "should respond to action methods" do + assert_respond_to BaseMailer, :welcome + assert_respond_to BaseMailer, :implicit_multipart + assert_not_respond_to BaseMailer, :mail + assert_not_respond_to BaseMailer, :headers + end + + test "calling just the action should return the generated mail object" do + email = BaseMailer.welcome + assert_equal(0, BaseMailer.deliveries.length) + assert_equal("The first email on new API!", email.subject) + end + + test "calling deliver on the action should deliver the mail object" do + assert_called(BaseMailer, :deliver_mail) do + mail = BaseMailer.welcome.deliver_now + assert_equal "The first email on new API!", mail.subject + end + end + + test "calling deliver on the action should increment the deliveries collection if using the test mailer" do + BaseMailer.welcome.deliver_now + assert_equal(1, BaseMailer.deliveries.length) + end + + test "calling deliver, ActionMailer should yield back to mail to let it call :do_delivery on itself" do + mail = Mail::Message.new + assert_called(mail, :do_delivery) do + assert_called(BaseMailer, :welcome, returns: mail) do + BaseMailer.welcome.deliver + end + end + end + + # Rendering + test "you can specify a different template for implicit render" do + mail = BaseMailer.implicit_different_template("implicit_multipart").deliver_now + assert_equal("HTML Implicit Multipart", mail.html_part.body.decoded) + assert_equal("TEXT Implicit Multipart", mail.text_part.body.decoded) + end + + test "you can specify a different template for multipart render" do + mail = BaseMailer.implicit_different_template_with_block("explicit_multipart_templates").deliver + assert_equal("HTML Explicit Multipart Templates", mail.html_part.body.decoded) + assert_equal("TEXT Explicit Multipart Templates", mail.text_part.body.decoded) + end + + test "should raise if missing template in implicit render" do + assert_raises ActionView::MissingTemplate do + BaseMailer.implicit_different_template("missing_template").deliver_now + end + assert_equal(0, BaseMailer.deliveries.length) + end + + test "you can specify a different template for explicit render" do + mail = BaseMailer.explicit_different_template("explicit_multipart_templates").deliver_now + assert_equal("HTML Explicit Multipart Templates", mail.html_part.body.decoded) + assert_equal("TEXT Explicit Multipart Templates", mail.text_part.body.decoded) + end + + test "you can specify a different layout" do + mail = BaseMailer.different_layout("different_layout").deliver_now + assert_equal("HTML -- HTML", mail.html_part.body.decoded) + assert_equal("PLAIN -- PLAIN", mail.text_part.body.decoded) + end + + test "you can specify the template path for implicit lookup" do + mail = BaseMailer.welcome_from_another_path("another.path/base_mailer").deliver_now + assert_equal("Welcome from another path", mail.body.encoded) + + mail = BaseMailer.welcome_from_another_path(["unknown/invalid", "another.path/base_mailer"]).deliver_now + assert_equal("Welcome from another path", mail.body.encoded) + end + + test "assets tags should use ActionMailer's asset_host settings" do + ActionMailer::Base.config.asset_host = "http://global.com" + ActionMailer::Base.config.assets_dir = "global/" + + mail = AssetMailer.welcome + + assert_dom_equal(%{<img src="http://global.com/images/dummy.png" />}, mail.body.to_s.strip) + end + + test "assets tags should use a Mailer's asset_host settings when available" do + ActionMailer::Base.config.asset_host = "http://global.com" + ActionMailer::Base.config.assets_dir = "global/" + + TempAssetMailer = Class.new(AssetMailer) do + self.mailer_name = "asset_mailer" + self.asset_host = "http://local.com" + end + + mail = TempAssetMailer.welcome + + assert_dom_equal(%{<img src="http://local.com/images/dummy.png" />}, mail.body.to_s.strip) + end + + test "the view is not rendered when mail was never called" do + mail = BaseMailer.without_mail_call + assert_equal("", mail.body.to_s.strip) + mail.deliver_now + end + + test "the return value of mailer methods is not relevant" do + mail = BaseMailer.with_nil_as_return_value + assert_equal("Welcome", mail.body.to_s.strip) + mail.deliver_now + end + + # Before and After hooks + + class MyObserver + def self.delivered_email(mail) + end + end + + class MySecondObserver + def self.delivered_email(mail) + end + end + + test "you can register and unregister an observer to the mail object that gets informed on email delivery" do + mail_side_effects do + ActionMailer::Base.register_observer(MyObserver) + mail = BaseMailer.welcome + assert_called_with(MyObserver, :delivered_email, [mail]) do + mail.deliver_now + end + + ActionMailer::Base.unregister_observer(MyObserver) + assert_not_called(MyObserver, :delivered_email, returns: mail) do + mail.deliver_now + end + end + end + + test "you can register and unregister an observer using its stringified name to the mail object that gets informed on email delivery" do + mail_side_effects do + ActionMailer::Base.register_observer("BaseTest::MyObserver") + mail = BaseMailer.welcome + assert_called_with(MyObserver, :delivered_email, [mail]) do + mail.deliver_now + end + + ActionMailer::Base.unregister_observer("BaseTest::MyObserver") + assert_not_called(MyObserver, :delivered_email, returns: mail) do + mail.deliver_now + end + end + end + + test "you can register and unregister an observer using its symbolized underscored name to the mail object that gets informed on email delivery" do + mail_side_effects do + ActionMailer::Base.register_observer(:"base_test/my_observer") + mail = BaseMailer.welcome + assert_called_with(MyObserver, :delivered_email, [mail]) do + mail.deliver_now + end + + ActionMailer::Base.unregister_observer(:"base_test/my_observer") + assert_not_called(MyObserver, :delivered_email, returns: mail) do + mail.deliver_now + end + end + end + + test "you can register and unregister multiple observers to the mail object that both get informed on email delivery" do + mail_side_effects do + ActionMailer::Base.register_observers("BaseTest::MyObserver", MySecondObserver) + mail = BaseMailer.welcome + assert_called_with(MyObserver, :delivered_email, [mail]) do + assert_called_with(MySecondObserver, :delivered_email, [mail]) do + mail.deliver_now + end + end + + ActionMailer::Base.unregister_observers("BaseTest::MyObserver", MySecondObserver) + assert_not_called(MyObserver, :delivered_email, returns: mail) do + mail.deliver_now + end + assert_not_called(MySecondObserver, :delivered_email, returns: mail) do + mail.deliver_now + end + end + end + + class MyInterceptor + def self.delivering_email(mail); end + def self.previewing_email(mail); end + end + + class MySecondInterceptor + def self.delivering_email(mail); end + def self.previewing_email(mail); end + end + + test "you can register and unregister an interceptor to the mail object that gets passed the mail object before delivery" do + mail_side_effects do + ActionMailer::Base.register_interceptor(MyInterceptor) + mail = BaseMailer.welcome + assert_called_with(MyInterceptor, :delivering_email, [mail]) do + mail.deliver_now + end + + ActionMailer::Base.unregister_interceptor(MyInterceptor) + assert_not_called(MyInterceptor, :delivering_email, returns: mail) do + mail.deliver_now + end + end + end + + test "you can register and unregister an interceptor using its stringified name to the mail object that gets passed the mail object before delivery" do + mail_side_effects do + ActionMailer::Base.register_interceptor("BaseTest::MyInterceptor") + mail = BaseMailer.welcome + assert_called_with(MyInterceptor, :delivering_email, [mail]) do + mail.deliver_now + end + + ActionMailer::Base.unregister_interceptor("BaseTest::MyInterceptor") + assert_not_called(MyInterceptor, :delivering_email, returns: mail) do + mail.deliver_now + end + end + end + + test "you can register and unregister an interceptor using its symbolized underscored name to the mail object that gets passed the mail object before delivery" do + mail_side_effects do + ActionMailer::Base.register_interceptor(:"base_test/my_interceptor") + mail = BaseMailer.welcome + assert_called_with(MyInterceptor, :delivering_email, [mail]) do + mail.deliver_now + end + + ActionMailer::Base.unregister_interceptor(:"base_test/my_interceptor") + assert_not_called(MyInterceptor, :delivering_email, returns: mail) do + mail.deliver_now + end + end + end + + test "you can register and unregister multiple interceptors to the mail object that both get passed the mail object before delivery" do + mail_side_effects do + ActionMailer::Base.register_interceptors("BaseTest::MyInterceptor", MySecondInterceptor) + mail = BaseMailer.welcome + assert_called_with(MyInterceptor, :delivering_email, [mail]) do + assert_called_with(MySecondInterceptor, :delivering_email, [mail]) do + mail.deliver_now + end + end + + ActionMailer::Base.unregister_interceptors("BaseTest::MyInterceptor", MySecondInterceptor) + assert_not_called(MyInterceptor, :delivering_email, returns: mail) do + mail.deliver_now + end + assert_not_called(MySecondInterceptor, :delivering_email, returns: mail) do + mail.deliver_now + end + end + end + + test "being able to put proc's into the defaults hash and they get evaluated on mail sending" do + mail1 = ProcMailer.welcome["X-Proc-Method"] + yesterday = 1.day.ago + Time.stub(:now, yesterday) do + mail2 = ProcMailer.welcome["X-Proc-Method"] + assert(mail1.to_s.to_i > mail2.to_s.to_i) + end + end + + test "default values which have to_proc (e.g. symbols) should not be considered procs" do + assert(ProcMailer.welcome["x-has-to-proc"].to_s == "symbol") + end + + test "proc default values can have arity of 1 where arg is a mailer instance" do + assert_equal(ProcMailer.welcome["X-Lambda-Arity-1-arg"].to_s, "complex_value") + assert_equal(ProcMailer.welcome["X-Lambda-Arity-1-self"].to_s, "complex_value") + end + + test "proc default values with fixed arity of 0 can be called" do + assert_equal("0", ProcMailer.welcome["X-Lambda-Arity-0"].to_s) + end + + test "we can call other defined methods on the class as needed" do + mail = ProcMailer.welcome + assert_equal("Thanks for signing up this afternoon", mail.subject) + end + + test "modifying the mail message with a before_action" do + class BeforeActionMailer < ActionMailer::Base + before_action :add_special_header! + + def welcome ; mail ; end + + private + def add_special_header! + headers("X-Special-Header" => "Wow, so special") + end + end + + assert_equal("Wow, so special", BeforeActionMailer.welcome["X-Special-Header"].to_s) + end + + test "modifying the mail message with an after_action" do + class AfterActionMailer < ActionMailer::Base + after_action :add_special_header! + + def welcome ; mail ; end + + private + def add_special_header! + headers("X-Special-Header" => "Testing") + end + end + + assert_equal("Testing", AfterActionMailer.welcome["X-Special-Header"].to_s) + end + + test "adding an inline attachment using a before_action" do + class DefaultInlineAttachmentMailer < ActionMailer::Base + before_action :add_inline_attachment! + + def welcome ; mail ; end + + private + def add_inline_attachment! + attachments.inline["footer.jpg"] = "hey there" + end + end + + mail = DefaultInlineAttachmentMailer.welcome + assert_equal("image/jpeg; filename=footer.jpg", mail.attachments.inline.first["Content-Type"].to_s) + end + + test "action methods should be refreshed after defining new method" do + class FooMailer < ActionMailer::Base + # This triggers action_methods. + respond_to?(:foo) + + def notify + end + end + + assert_equal Set.new(["notify"]), FooMailer.action_methods + end + + test "mailer can be anonymous" do + mailer = Class.new(ActionMailer::Base) do + def welcome + mail + end + end + + assert_equal "anonymous", mailer.mailer_name + + assert_equal "Welcome", mailer.welcome.subject + assert_equal "Anonymous mailer body", mailer.welcome.body.encoded.strip + end + + test "default_from can be set" do + class DefaultFromMailer < ActionMailer::Base + default to: "system@test.lindsaar.net" + self.default_options = { from: "robert.pankowecki@gmail.com" } + + def welcome + mail(subject: "subject", body: "hello world") + end + end + + assert_equal ["robert.pankowecki@gmail.com"], DefaultFromMailer.welcome.from + end + + test "mail() without arguments serves as getter for the current mail message" do + class MailerWithCallback < ActionMailer::Base + after_action :a_callback + + def welcome + headers("X-Special-Header" => "special indeed!") + mail subject: "subject", body: "hello world", to: ["joe@example.com"] + end + + def a_callback + mail.to << "jane@example.com" + end + end + + mail = MailerWithCallback.welcome + assert_equal "subject", mail.subject + assert_equal ["joe@example.com", "jane@example.com"], mail.to + assert_equal "hello world", mail.body.encoded.strip + assert_equal "special indeed!", mail["X-Special-Header"].to_s + end + + test "notification for process" do + events = [] + ActiveSupport::Notifications.subscribe("process.action_mailer") do |*args| + events << ActiveSupport::Notifications::Event.new(*args) + end + + BaseMailer.welcome(body: "Hello there").deliver_now + + assert_equal 1, events.length + assert_equal "process.action_mailer", events[0].name + assert_equal "BaseMailer", events[0].payload[:mailer] + assert_equal :welcome, events[0].payload[:action] + assert_equal [{ body: "Hello there" }], events[0].payload[:args] + ensure + ActiveSupport::Notifications.unsubscribe "process.action_mailer" + end + + private + + # Execute the block setting the given values and restoring old values after + # the block is executed. + def swap(klass, new_values) + old_values = {} + new_values.each do |key, value| + old_values[key] = klass.send key + klass.send :"#{key}=", value + end + yield + ensure + old_values.each do |key, value| + klass.send :"#{key}=", value + end + end + + def with_default(klass, new_values) + old = klass.default_params + klass.default(new_values) + yield + ensure + klass.default_params = old + end + + def mail_side_effects + old_observers = Mail.class_variable_get(:@@delivery_notification_observers) + old_delivery_interceptors = Mail.class_variable_get(:@@delivery_interceptors) + yield + ensure + Mail.class_variable_set(:@@delivery_notification_observers, old_observers) + Mail.class_variable_set(:@@delivery_interceptors, old_delivery_interceptors) + end + + def with_translation(locale, data) + I18n.backend.store_translations(locale, data) + yield + ensure + I18n.backend.reload! + end +end + +class BasePreviewInterceptorsTest < ActiveSupport::TestCase + teardown do + ActionMailer::Base.preview_interceptors.clear + end + + class BaseMailerPreview < ActionMailer::Preview + def welcome + BaseMailer.welcome + end + end + + class MyInterceptor + def self.delivering_email(mail); end + def self.previewing_email(mail); end + end + + class MySecondInterceptor + def self.delivering_email(mail); end + def self.previewing_email(mail); end + end + + test "you can register and unregister a preview interceptor to the mail object that gets passed the mail object before previewing" do + ActionMailer::Base.register_preview_interceptor(MyInterceptor) + mail = BaseMailer.welcome + stub_any_instance(BaseMailerPreview) do |instance| + instance.stub(:welcome, mail) do + assert_called_with(MyInterceptor, :previewing_email, [mail]) do + BaseMailerPreview.call(:welcome) + end + end + end + + ActionMailer::Base.unregister_preview_interceptor(MyInterceptor) + assert_not_called(MyInterceptor, :previewing_email, returns: mail) do + BaseMailerPreview.call(:welcome) + end + end + + test "you can register and unregister a preview interceptor using its stringified name to the mail object that gets passed the mail object before previewing" do + ActionMailer::Base.register_preview_interceptor("BasePreviewInterceptorsTest::MyInterceptor") + mail = BaseMailer.welcome + stub_any_instance(BaseMailerPreview) do |instance| + instance.stub(:welcome, mail) do + assert_called_with(MyInterceptor, :previewing_email, [mail]) do + BaseMailerPreview.call(:welcome) + end + end + end + + ActionMailer::Base.unregister_preview_interceptor("BasePreviewInterceptorsTest::MyInterceptor") + assert_not_called(MyInterceptor, :previewing_email, returns: mail) do + BaseMailerPreview.call(:welcome) + end + end + + test "you can register and unregister a preview interceptor using its symbolized underscored name to the mail object that gets passed the mail object before previewing" do + ActionMailer::Base.register_preview_interceptor(:"base_preview_interceptors_test/my_interceptor") + mail = BaseMailer.welcome + stub_any_instance(BaseMailerPreview) do |instance| + instance.stub(:welcome, mail) do + assert_called_with(MyInterceptor, :previewing_email, [mail]) do + BaseMailerPreview.call(:welcome) + end + end + end + + ActionMailer::Base.unregister_preview_interceptor(:"base_preview_interceptors_test/my_interceptor") + assert_not_called(MyInterceptor, :previewing_email, returns: mail) do + BaseMailerPreview.call(:welcome) + end + end + + test "you can register and unregister multiple preview interceptors to the mail object that both get passed the mail object before previewing" do + ActionMailer::Base.register_preview_interceptors("BasePreviewInterceptorsTest::MyInterceptor", MySecondInterceptor) + mail = BaseMailer.welcome + stub_any_instance(BaseMailerPreview) do |instance| + instance.stub(:welcome, mail) do + assert_called_with(MyInterceptor, :previewing_email, [mail]) do + assert_called_with(MySecondInterceptor, :previewing_email, [mail]) do + BaseMailerPreview.call(:welcome) + end + end + end + end + + ActionMailer::Base.unregister_preview_interceptors("BasePreviewInterceptorsTest::MyInterceptor", MySecondInterceptor) + assert_not_called(MyInterceptor, :previewing_email, returns: mail) do + BaseMailerPreview.call(:welcome) + end + assert_not_called(MySecondInterceptor, :previewing_email, returns: mail) do + BaseMailerPreview.call(:welcome) + end + end +end + +class BasePreviewTest < ActiveSupport::TestCase + class BaseMailerPreview < ActionMailer::Preview + def welcome + BaseMailer.welcome(params) + end + end + + test "has access to params" do + params = { name: "World" } + + message = BaseMailerPreview.call(:welcome, params) + assert_equal "World", message["name"].decoded + end +end diff --git a/actionmailer/test/caching_test.rb b/actionmailer/test/caching_test.rb new file mode 100644 index 0000000000..22f310f39f --- /dev/null +++ b/actionmailer/test/caching_test.rb @@ -0,0 +1,271 @@ +# frozen_string_literal: true + +require "fileutils" +require "abstract_unit" +require "mailers/base_mailer" +require "mailers/caching_mailer" + +CACHE_DIR = "test_cache" +# Don't change '/../temp/' cavalierly or you might hose something you don't want hosed +FILE_STORE_PATH = File.join(__dir__, "/../temp/", CACHE_DIR) + +class FragmentCachingMailer < ActionMailer::Base + abstract! + + def some_action; end +end + +class BaseCachingTest < ActiveSupport::TestCase + def setup + super + @store = ActiveSupport::Cache::MemoryStore.new + @mailer = FragmentCachingMailer.new + @mailer.perform_caching = true + @mailer.cache_store = @store + end +end + +class FragmentCachingTest < BaseCachingTest + def test_read_fragment_with_caching_enabled + @store.write("views/name", "value") + assert_equal "value", @mailer.read_fragment("name") + end + + def test_read_fragment_with_caching_disabled + @mailer.perform_caching = false + @store.write("views/name", "value") + assert_nil @mailer.read_fragment("name") + end + + def test_fragment_exist_with_caching_enabled + @store.write("views/name", "value") + assert @mailer.fragment_exist?("name") + assert_not @mailer.fragment_exist?("other_name") + end + + def test_fragment_exist_with_caching_disabled + @mailer.perform_caching = false + @store.write("views/name", "value") + assert_not @mailer.fragment_exist?("name") + assert_not @mailer.fragment_exist?("other_name") + end + + def test_write_fragment_with_caching_enabled + assert_nil @store.read("views/name") + assert_equal "value", @mailer.write_fragment("name", "value") + assert_equal "value", @store.read("views/name") + end + + def test_write_fragment_with_caching_disabled + assert_nil @store.read("views/name") + @mailer.perform_caching = false + assert_equal "value", @mailer.write_fragment("name", "value") + assert_nil @store.read("views/name") + end + + def test_expire_fragment_with_simple_key + @store.write("views/name", "value") + @mailer.expire_fragment "name" + assert_nil @store.read("views/name") + end + + def test_expire_fragment_with_regexp + @store.write("views/name", "value") + @store.write("views/another_name", "another_value") + @store.write("views/primalgrasp", "will not expire ;-)") + + @mailer.expire_fragment(/name/) + + assert_nil @store.read("views/name") + assert_nil @store.read("views/another_name") + assert_equal "will not expire ;-)", @store.read("views/primalgrasp") + end + + def test_fragment_for + @store.write("views/expensive", "fragment content") + fragment_computed = false + + view_context = @mailer.view_context + + buffer = "generated till now -> ".html_safe + buffer << view_context.send(:fragment_for, "expensive") { fragment_computed = true } + + assert_not fragment_computed + assert_equal "generated till now -> fragment content", buffer + end + + def test_html_safety + assert_nil @store.read("views/name") + content = "value".html_safe + assert_equal content, @mailer.write_fragment("name", content) + + cached = @store.read("views/name") + assert_equal content, cached + assert_equal String, cached.class + + html_safe = @mailer.read_fragment("name") + assert_equal content, html_safe + assert_predicate html_safe, :html_safe? + end +end + +class FunctionalFragmentCachingTest < BaseCachingTest + def setup + super + @store = ActiveSupport::Cache::MemoryStore.new + @mailer = CachingMailer.new + @mailer.perform_caching = true + @mailer.cache_store = @store + end + + def test_fragment_caching + email = @mailer.fragment_cache + expected_body = "\"Welcome\"" + + assert_match expected_body, email.body.encoded + assert_match expected_body, + @store.read("views/caching_mailer/fragment_cache:#{template_digest("caching_mailer/fragment_cache")}/caching") + end + + def test_fragment_caching_in_partials + email = @mailer.fragment_cache_in_partials + expected_body = "Old fragment caching in a partial" + assert_match(expected_body, email.body.encoded) + + assert_match(expected_body, + @store.read("views/caching_mailer/_partial:#{template_digest("caching_mailer/_partial")}/caching")) + end + + def test_skip_fragment_cache_digesting + email = @mailer.skip_fragment_cache_digesting + expected_body = "No Digest" + + assert_match expected_body, email.body.encoded + assert_match expected_body, @store.read("views/no_digest") + end + + def test_fragment_caching_options + time = Time.now + email = @mailer.fragment_caching_options + expected_body = "No Digest" + + assert_match expected_body, email.body.encoded + Time.stub(:now, time + 11) do + assert_nil @store.read("views/no_digest") + end + end + + def test_multipart_fragment_caching + email = @mailer.multipart_cache + + expected_text_body = "\"Welcome text\"" + expected_html_body = "\"Welcome html\"" + encoded_body = email.body.encoded + assert_match expected_text_body, encoded_body + assert_match expected_html_body, encoded_body + assert_match expected_text_body, + @store.read("views/text_caching") + assert_match expected_html_body, + @store.read("views/html_caching") + end + + def test_fragment_cache_instrumentation + @mailer.enable_fragment_cache_logging = true + payload = nil + + subscriber = proc do |*args| + event = ActiveSupport::Notifications::Event.new(*args) + payload = event.payload + end + + ActiveSupport::Notifications.subscribed(subscriber, "read_fragment.action_mailer") do + @mailer.fragment_cache + end + + assert_equal "caching_mailer", payload[:mailer] + assert_equal [ :views, "caching_mailer/fragment_cache:#{template_digest("caching_mailer/fragment_cache")}", :caching ], payload[:key] + ensure + @mailer.enable_fragment_cache_logging = true + end + + private + + def template_digest(name) + ActionView::Digestor.digest(name: name, finder: @mailer.lookup_context) + end +end + +class CacheHelperOutputBufferTest < BaseCachingTest + class MockController + def read_fragment(name, options) + false + end + + def write_fragment(name, fragment, options) + fragment + end + end + + def setup + super + end + + def test_output_buffer + output_buffer = ActionView::OutputBuffer.new + controller = MockController.new + cache_helper = Class.new do + def self.controller; end + def self.output_buffer; end + def self.output_buffer=; end + end + cache_helper.extend(ActionView::Helpers::CacheHelper) + + cache_helper.stub :controller, controller do + cache_helper.stub :output_buffer, output_buffer do + assert_called_with cache_helper, :output_buffer=, [output_buffer.class.new(output_buffer)] do + assert_nothing_raised do + cache_helper.send :fragment_for, "Test fragment name", "Test fragment", &Proc.new { nil } + end + end + end + end + end + + def test_safe_buffer + output_buffer = ActiveSupport::SafeBuffer.new + controller = MockController.new + cache_helper = Class.new do + def self.controller; end + def self.output_buffer; end + def self.output_buffer=; end + end + cache_helper.extend(ActionView::Helpers::CacheHelper) + + cache_helper.stub :controller, controller do + cache_helper.stub :output_buffer, output_buffer do + assert_called_with cache_helper, :output_buffer=, [output_buffer.class.new(output_buffer)] do + assert_nothing_raised do + cache_helper.send :fragment_for, "Test fragment name", "Test fragment", &Proc.new { nil } + end + end + end + end + end +end + +class ViewCacheDependencyTest < BaseCachingTest + class NoDependenciesMailer < ActionMailer::Base + end + class HasDependenciesMailer < ActionMailer::Base + view_cache_dependency { "trombone" } + view_cache_dependency { "flute" } + end + + def test_view_cache_dependencies_are_empty_by_default + assert_empty NoDependenciesMailer.new.view_cache_dependencies + end + + def test_view_cache_dependencies_are_listed_in_declaration_order + assert_equal %w(trombone flute), HasDependenciesMailer.new.view_cache_dependencies + end +end diff --git a/actionmailer/test/delivery_methods_test.rb b/actionmailer/test/delivery_methods_test.rb new file mode 100644 index 0000000000..025f7152bb --- /dev/null +++ b/actionmailer/test/delivery_methods_test.rb @@ -0,0 +1,248 @@ +# frozen_string_literal: true + +require "abstract_unit" + +class MyCustomDelivery +end + +class MyOptionedDelivery + attr_reader :options + def initialize(options) + @options = options + end +end + +class BogusDelivery + def initialize(*) + end + + def deliver!(mail) + raise "failed" + end +end + +class DefaultsDeliveryMethodsTest < ActiveSupport::TestCase + test "default smtp settings" do + settings = { address: "localhost", + port: 25, + domain: "localhost.localdomain", + user_name: nil, + password: nil, + authentication: nil, + enable_starttls_auto: true } + assert_equal settings, ActionMailer::Base.smtp_settings + end + + test "default file delivery settings (with Rails.root)" do + settings = { location: "#{Rails.root}/tmp/mails" } + assert_equal settings, ActionMailer::Base.file_settings + end + + test "default sendmail settings" do + settings = { + location: "/usr/sbin/sendmail", + arguments: "-i" + } + assert_equal settings, ActionMailer::Base.sendmail_settings + end +end + +class CustomDeliveryMethodsTest < ActiveSupport::TestCase + setup do + @old_delivery_method = ActionMailer::Base.delivery_method + ActionMailer::Base.add_delivery_method :custom, MyCustomDelivery + end + + teardown do + ActionMailer::Base.delivery_method = @old_delivery_method + new = ActionMailer::Base.delivery_methods.dup + new.delete(:custom) + ActionMailer::Base.delivery_methods = new + end + + test "allow to add custom delivery method" do + ActionMailer::Base.delivery_method = :custom + assert_equal :custom, ActionMailer::Base.delivery_method + end + + test "allow to customize custom settings" do + ActionMailer::Base.custom_settings = { foo: :bar } + assert_equal Hash[foo: :bar], ActionMailer::Base.custom_settings + end + + test "respond to custom settings" do + assert_respond_to ActionMailer::Base, :custom_settings + assert_respond_to ActionMailer::Base, :custom_settings= + end + + test "does not respond to unknown settings" do + assert_raise NoMethodError do + ActionMailer::Base.another_settings + end + end +end + +class MailDeliveryTest < ActiveSupport::TestCase + class DeliveryMailer < ActionMailer::Base + DEFAULT_HEADERS = { + to: "mikel@test.lindsaar.net", + from: "jose@test.plataformatec.com" + } + + def welcome(hash = {}) + mail(DEFAULT_HEADERS.merge(hash)) + end + end + + setup do + @old_delivery_method = DeliveryMailer.delivery_method + end + + teardown do + DeliveryMailer.delivery_method = @old_delivery_method + DeliveryMailer.deliveries.clear + end + + test "ActionMailer should be told when Mail gets delivered" do + DeliveryMailer.delivery_method = :test + assert_called(DeliveryMailer, :deliver_mail) do + DeliveryMailer.welcome.deliver_now + end + end + + test "delivery method can be customized per instance" do + stub_any_instance(Mail::SMTP, instance: Mail::SMTP.new({})) do |instance| + assert_called(instance, :deliver!) do + email = DeliveryMailer.welcome.deliver_now + assert_instance_of Mail::SMTP, email.delivery_method + email = DeliveryMailer.welcome(delivery_method: :test).deliver_now + assert_instance_of Mail::TestMailer, email.delivery_method + end + end + end + + test "delivery method can be customized in subclasses not changing the parent" do + DeliveryMailer.delivery_method = :test + assert_equal :smtp, ActionMailer::Base.delivery_method + email = DeliveryMailer.welcome.deliver_now + assert_instance_of Mail::TestMailer, email.delivery_method + end + + test "delivery method options default to class level options" do + default_options = { a: "b" } + ActionMailer::Base.add_delivery_method :optioned, MyOptionedDelivery, default_options + mail_instance = DeliveryMailer.welcome(delivery_method: :optioned) + assert_equal default_options, mail_instance.delivery_method.options + end + + test "delivery method options can be overridden per mail instance" do + default_options = { a: "b" } + ActionMailer::Base.add_delivery_method :optioned, MyOptionedDelivery, default_options + overridden_options = { a: "a" } + mail_instance = DeliveryMailer.welcome(delivery_method: :optioned, delivery_method_options: overridden_options) + assert_equal overridden_options, mail_instance.delivery_method.options + end + + test "default delivery options can be overridden per mail instance" do + settings = { + address: "localhost", + port: 25, + domain: "localhost.localdomain", + user_name: nil, + password: nil, + authentication: nil, + enable_starttls_auto: true + } + assert_equal settings, ActionMailer::Base.smtp_settings + overridden_options = { user_name: "overridden", password: "somethingobtuse" } + mail_instance = DeliveryMailer.welcome(delivery_method_options: overridden_options) + delivery_method_instance = mail_instance.delivery_method + assert_equal "overridden", delivery_method_instance.settings[:user_name] + assert_equal "somethingobtuse", delivery_method_instance.settings[:password] + assert_equal delivery_method_instance.settings.merge(overridden_options), delivery_method_instance.settings + + # make sure that overriding delivery method options per mail instance doesn't affect the Base setting + assert_equal settings, ActionMailer::Base.smtp_settings + end + + test "non registered delivery methods raises errors" do + DeliveryMailer.delivery_method = :unknown + error = assert_raise RuntimeError do + DeliveryMailer.welcome.deliver_now + end + assert_equal "Invalid delivery method :unknown", error.message + end + + test "undefined delivery methods raises errors" do + DeliveryMailer.delivery_method = nil + error = assert_raise RuntimeError do + DeliveryMailer.welcome.deliver_now + end + assert_equal "Delivery method cannot be nil", error.message + end + + test "does not perform deliveries if requested" do + old_perform_deliveries = DeliveryMailer.perform_deliveries + begin + DeliveryMailer.perform_deliveries = false + stub_any_instance(Mail::Message) do |instance| + assert_not_called(instance, :deliver!) do + DeliveryMailer.welcome.deliver_now + end + end + ensure + DeliveryMailer.perform_deliveries = old_perform_deliveries + end + end + + test "does not append the deliveries collection if told not to perform the delivery" do + old_perform_deliveries = DeliveryMailer.perform_deliveries + begin + DeliveryMailer.perform_deliveries = false + DeliveryMailer.welcome.deliver_now + assert_equal [], DeliveryMailer.deliveries + ensure + DeliveryMailer.perform_deliveries = old_perform_deliveries + end + end + + test "raise errors on bogus deliveries" do + DeliveryMailer.delivery_method = BogusDelivery + assert_raise RuntimeError do + DeliveryMailer.welcome.deliver_now + end + end + + test "does not increment the deliveries collection on error" do + DeliveryMailer.delivery_method = BogusDelivery + assert_raise RuntimeError do + DeliveryMailer.welcome.deliver_now + end + assert_equal [], DeliveryMailer.deliveries + end + + test "does not raise errors on bogus deliveries if set" do + old_raise_delivery_errors = DeliveryMailer.raise_delivery_errors + begin + DeliveryMailer.delivery_method = BogusDelivery + DeliveryMailer.raise_delivery_errors = false + assert_nothing_raised do + DeliveryMailer.welcome.deliver_now + end + ensure + DeliveryMailer.raise_delivery_errors = old_raise_delivery_errors + end + end + + test "does not increment the deliveries collection on bogus deliveries" do + old_raise_delivery_errors = DeliveryMailer.raise_delivery_errors + begin + DeliveryMailer.delivery_method = BogusDelivery + DeliveryMailer.raise_delivery_errors = false + DeliveryMailer.welcome.deliver_now + assert_equal [], DeliveryMailer.deliveries + ensure + DeliveryMailer.raise_delivery_errors = old_raise_delivery_errors + end + end +end diff --git a/actionmailer/test/fixtures/anonymous/welcome.erb b/actionmailer/test/fixtures/anonymous/welcome.erb new file mode 100644 index 0000000000..8361da62c4 --- /dev/null +++ b/actionmailer/test/fixtures/anonymous/welcome.erb @@ -0,0 +1 @@ +Anonymous mailer body diff --git a/actionmailer/test/fixtures/another.path/base_mailer/welcome.erb b/actionmailer/test/fixtures/another.path/base_mailer/welcome.erb new file mode 100644 index 0000000000..ef451298e2 --- /dev/null +++ b/actionmailer/test/fixtures/another.path/base_mailer/welcome.erb @@ -0,0 +1 @@ +Welcome from another path
\ No newline at end of file diff --git a/actionmailer/test/fixtures/asset_host_mailer/email_with_asset.html.erb b/actionmailer/test/fixtures/asset_host_mailer/email_with_asset.html.erb new file mode 100644 index 0000000000..b3f0438d03 --- /dev/null +++ b/actionmailer/test/fixtures/asset_host_mailer/email_with_asset.html.erb @@ -0,0 +1 @@ +<%= image_tag "somelogo.png" %>
\ No newline at end of file diff --git a/actionmailer/test/fixtures/asset_mailer/welcome.html.erb b/actionmailer/test/fixtures/asset_mailer/welcome.html.erb new file mode 100644 index 0000000000..90d26130d9 --- /dev/null +++ b/actionmailer/test/fixtures/asset_mailer/welcome.html.erb @@ -0,0 +1 @@ +<%= image_tag "dummy.png" %>
\ No newline at end of file diff --git a/actionmailer/test/fixtures/attachments/foo.jpg b/actionmailer/test/fixtures/attachments/foo.jpg Binary files differnew file mode 100644 index 0000000000..b976fe5e00 --- /dev/null +++ b/actionmailer/test/fixtures/attachments/foo.jpg diff --git a/actionmailer/test/fixtures/attachments/test.jpg b/actionmailer/test/fixtures/attachments/test.jpg Binary files differnew file mode 100644 index 0000000000..b976fe5e00 --- /dev/null +++ b/actionmailer/test/fixtures/attachments/test.jpg diff --git a/actionmailer/test/fixtures/auto_layout_mailer/hello.html.erb b/actionmailer/test/fixtures/auto_layout_mailer/hello.html.erb new file mode 100644 index 0000000000..54950788f7 --- /dev/null +++ b/actionmailer/test/fixtures/auto_layout_mailer/hello.html.erb @@ -0,0 +1 @@ +Inside
\ No newline at end of file diff --git a/actionmailer/test/fixtures/auto_layout_mailer/multipart.html.erb b/actionmailer/test/fixtures/auto_layout_mailer/multipart.html.erb new file mode 100644 index 0000000000..6d73f199c4 --- /dev/null +++ b/actionmailer/test/fixtures/auto_layout_mailer/multipart.html.erb @@ -0,0 +1 @@ +text/html multipart
\ No newline at end of file diff --git a/actionmailer/test/fixtures/auto_layout_mailer/multipart.text.erb b/actionmailer/test/fixtures/auto_layout_mailer/multipart.text.erb new file mode 100644 index 0000000000..f4b91e4031 --- /dev/null +++ b/actionmailer/test/fixtures/auto_layout_mailer/multipart.text.erb @@ -0,0 +1 @@ +text/plain multipart
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/attachment_with_content.erb b/actionmailer/test/fixtures/base_mailer/attachment_with_content.erb new file mode 100644 index 0000000000..deb9dbd03b --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/attachment_with_content.erb @@ -0,0 +1 @@ +Attachment with content
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/attachment_with_hash.html.erb b/actionmailer/test/fixtures/base_mailer/attachment_with_hash.html.erb new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/attachment_with_hash.html.erb diff --git a/actionmailer/test/fixtures/base_mailer/attachment_with_hash_default_encoding.html.erb b/actionmailer/test/fixtures/base_mailer/attachment_with_hash_default_encoding.html.erb new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/attachment_with_hash_default_encoding.html.erb diff --git a/actionmailer/test/fixtures/base_mailer/different_layout.html.erb b/actionmailer/test/fixtures/base_mailer/different_layout.html.erb new file mode 100644 index 0000000000..3225efc49a --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/different_layout.html.erb @@ -0,0 +1 @@ +HTML
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/different_layout.text.erb b/actionmailer/test/fixtures/base_mailer/different_layout.text.erb new file mode 100644 index 0000000000..b547f4a332 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/different_layout.text.erb @@ -0,0 +1 @@ +PLAIN
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/email_with_translations.html.erb b/actionmailer/test/fixtures/base_mailer/email_with_translations.html.erb new file mode 100644 index 0000000000..d676a6d2da --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/email_with_translations.html.erb @@ -0,0 +1 @@ +<%= t('.greet_user', name: 'lifo') %>
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/explicit_multipart_templates.html.erb b/actionmailer/test/fixtures/base_mailer/explicit_multipart_templates.html.erb new file mode 100644 index 0000000000..c0a61b6249 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/explicit_multipart_templates.html.erb @@ -0,0 +1 @@ +HTML Explicit Multipart Templates
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/explicit_multipart_templates.text.erb b/actionmailer/test/fixtures/base_mailer/explicit_multipart_templates.text.erb new file mode 100644 index 0000000000..507230b1de --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/explicit_multipart_templates.text.erb @@ -0,0 +1 @@ +TEXT Explicit Multipart Templates
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/explicit_multipart_with_one_template.erb b/actionmailer/test/fixtures/base_mailer/explicit_multipart_with_one_template.erb new file mode 100644 index 0000000000..8a69657b08 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/explicit_multipart_with_one_template.erb @@ -0,0 +1 @@ +<%= self.formats.inspect %>
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/html_only.html.erb b/actionmailer/test/fixtures/base_mailer/html_only.html.erb new file mode 100644 index 0000000000..9c99a008e7 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/html_only.html.erb @@ -0,0 +1 @@ +<h1>Testing</h1>
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/implicit_multipart.html.erb b/actionmailer/test/fixtures/base_mailer/implicit_multipart.html.erb new file mode 100644 index 0000000000..23745cd282 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/implicit_multipart.html.erb @@ -0,0 +1 @@ +HTML Implicit Multipart
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/implicit_multipart.text.erb b/actionmailer/test/fixtures/base_mailer/implicit_multipart.text.erb new file mode 100644 index 0000000000..d51437fc72 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/implicit_multipart.text.erb @@ -0,0 +1 @@ +TEXT Implicit Multipart
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/implicit_with_locale.de-AT.text.erb b/actionmailer/test/fixtures/base_mailer/implicit_with_locale.de-AT.text.erb new file mode 100644 index 0000000000..e97505fad9 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/implicit_with_locale.de-AT.text.erb @@ -0,0 +1 @@ +Implicit with locale DE-AT TEXT
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/implicit_with_locale.de.html.erb b/actionmailer/test/fixtures/base_mailer/implicit_with_locale.de.html.erb new file mode 100644 index 0000000000..0536b5d3e2 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/implicit_with_locale.de.html.erb @@ -0,0 +1 @@ +Implicit with locale DE HTML
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/implicit_with_locale.en.html.erb b/actionmailer/test/fixtures/base_mailer/implicit_with_locale.en.html.erb new file mode 100644 index 0000000000..34e39c8fdb --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/implicit_with_locale.en.html.erb @@ -0,0 +1 @@ +Implicit with locale EN HTML
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/implicit_with_locale.html.erb b/actionmailer/test/fixtures/base_mailer/implicit_with_locale.html.erb new file mode 100644 index 0000000000..5ce283f221 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/implicit_with_locale.html.erb @@ -0,0 +1 @@ +Implicit with locale HTML
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/implicit_with_locale.pl.text.erb b/actionmailer/test/fixtures/base_mailer/implicit_with_locale.pl.text.erb new file mode 100644 index 0000000000..c49cbae60a --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/implicit_with_locale.pl.text.erb @@ -0,0 +1 @@ +Implicit with locale PL TEXT
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/implicit_with_locale.text.erb b/actionmailer/test/fixtures/base_mailer/implicit_with_locale.text.erb new file mode 100644 index 0000000000..5a18ff62cd --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/implicit_with_locale.text.erb @@ -0,0 +1 @@ +Implicit with locale TEXT
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/inline_attachment.html.erb b/actionmailer/test/fixtures/base_mailer/inline_attachment.html.erb new file mode 100644 index 0000000000..e200878127 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/inline_attachment.html.erb @@ -0,0 +1,5 @@ +<h1>Inline Image</h1> + +<%= image_tag attachments['logo.png'].url %> + +<p>This is an image that is inline</p>
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/inline_attachment.text.erb b/actionmailer/test/fixtures/base_mailer/inline_attachment.text.erb new file mode 100644 index 0000000000..e161d244d2 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/inline_attachment.text.erb @@ -0,0 +1,4 @@ +Inline Image + +No image for you + diff --git a/actionmailer/test/fixtures/base_mailer/plain_text_only.text.erb b/actionmailer/test/fixtures/base_mailer/plain_text_only.text.erb new file mode 100644 index 0000000000..0a90125685 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/plain_text_only.text.erb @@ -0,0 +1 @@ +Testing
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/welcome.erb b/actionmailer/test/fixtures/base_mailer/welcome.erb new file mode 100644 index 0000000000..01f3f00c63 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/welcome.erb @@ -0,0 +1 @@ +Welcome
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_mailer/welcome_with_headers.html.erb b/actionmailer/test/fixtures/base_mailer/welcome_with_headers.html.erb new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/welcome_with_headers.html.erb diff --git a/actionmailer/test/fixtures/base_mailer/without_mail_call.erb b/actionmailer/test/fixtures/base_mailer/without_mail_call.erb new file mode 100644 index 0000000000..290379d5fb --- /dev/null +++ b/actionmailer/test/fixtures/base_mailer/without_mail_call.erb @@ -0,0 +1 @@ +<% raise 'the template should not be rendered' %>
\ No newline at end of file diff --git a/actionmailer/test/fixtures/base_test/after_action_mailer/welcome.html.erb b/actionmailer/test/fixtures/base_test/after_action_mailer/welcome.html.erb new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/actionmailer/test/fixtures/base_test/after_action_mailer/welcome.html.erb diff --git a/actionmailer/test/fixtures/base_test/before_action_mailer/welcome.html.erb b/actionmailer/test/fixtures/base_test/before_action_mailer/welcome.html.erb new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/actionmailer/test/fixtures/base_test/before_action_mailer/welcome.html.erb diff --git a/actionmailer/test/fixtures/base_test/default_inline_attachment_mailer/welcome.html.erb b/actionmailer/test/fixtures/base_test/default_inline_attachment_mailer/welcome.html.erb new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/actionmailer/test/fixtures/base_test/default_inline_attachment_mailer/welcome.html.erb diff --git a/actionmailer/test/fixtures/base_test/late_inline_attachment_mailer/on_render.erb b/actionmailer/test/fixtures/base_test/late_inline_attachment_mailer/on_render.erb new file mode 100644 index 0000000000..6decd3bb31 --- /dev/null +++ b/actionmailer/test/fixtures/base_test/late_inline_attachment_mailer/on_render.erb @@ -0,0 +1,7 @@ +<h1>Adding an inline image while rendering</h1> + +<% controller.attachments.inline["controller_attachments.jpg"] = 'via controller.attachments.inline' %> +<%= image_tag attachments['controller_attachments.jpg'].url %> + +<% attachments.inline["attachments.jpg"] = 'via attachments.inline' %> +<%= image_tag attachments['attachments.jpg'].url %> diff --git a/actionmailer/test/fixtures/caching_mailer/_partial.html.erb b/actionmailer/test/fixtures/caching_mailer/_partial.html.erb new file mode 100644 index 0000000000..8e965f52b4 --- /dev/null +++ b/actionmailer/test/fixtures/caching_mailer/_partial.html.erb @@ -0,0 +1,3 @@ +<% cache :caching do %> + Old fragment caching in a partial +<% end %> diff --git a/actionmailer/test/fixtures/caching_mailer/fragment_cache.html.erb b/actionmailer/test/fixtures/caching_mailer/fragment_cache.html.erb new file mode 100644 index 0000000000..90189627da --- /dev/null +++ b/actionmailer/test/fixtures/caching_mailer/fragment_cache.html.erb @@ -0,0 +1,3 @@ +<% cache :caching do %> +"Welcome" +<% end %> diff --git a/actionmailer/test/fixtures/caching_mailer/fragment_cache_in_partials.html.erb b/actionmailer/test/fixtures/caching_mailer/fragment_cache_in_partials.html.erb new file mode 100644 index 0000000000..2957d083e8 --- /dev/null +++ b/actionmailer/test/fixtures/caching_mailer/fragment_cache_in_partials.html.erb @@ -0,0 +1 @@ +<%= render "partial" %> diff --git a/actionmailer/test/fixtures/caching_mailer/fragment_caching_options.html.erb b/actionmailer/test/fixtures/caching_mailer/fragment_caching_options.html.erb new file mode 100644 index 0000000000..0541ac321b --- /dev/null +++ b/actionmailer/test/fixtures/caching_mailer/fragment_caching_options.html.erb @@ -0,0 +1,3 @@ +<%= cache :no_digest, skip_digest: true, expires_in: 0 do %> + No Digest +<% end %> diff --git a/actionmailer/test/fixtures/caching_mailer/multipart_cache.html.erb b/actionmailer/test/fixtures/caching_mailer/multipart_cache.html.erb new file mode 100644 index 0000000000..0d26baa2d7 --- /dev/null +++ b/actionmailer/test/fixtures/caching_mailer/multipart_cache.html.erb @@ -0,0 +1,3 @@ +<% cache :html_caching, skip_digest: true do %> + "Welcome html" +<% end %> diff --git a/actionmailer/test/fixtures/caching_mailer/multipart_cache.text.erb b/actionmailer/test/fixtures/caching_mailer/multipart_cache.text.erb new file mode 100644 index 0000000000..ef97326e03 --- /dev/null +++ b/actionmailer/test/fixtures/caching_mailer/multipart_cache.text.erb @@ -0,0 +1,3 @@ +<% cache :text_caching, skip_digest: true do %> + "Welcome text" +<% end %> diff --git a/actionmailer/test/fixtures/caching_mailer/skip_fragment_cache_digesting.html.erb b/actionmailer/test/fixtures/caching_mailer/skip_fragment_cache_digesting.html.erb new file mode 100644 index 0000000000..0d52429a81 --- /dev/null +++ b/actionmailer/test/fixtures/caching_mailer/skip_fragment_cache_digesting.html.erb @@ -0,0 +1,3 @@ +<%= cache :no_digest, skip_digest: true do %> + No Digest +<% end %> diff --git a/actionmailer/test/fixtures/explicit_layout_mailer/logout.html.erb b/actionmailer/test/fixtures/explicit_layout_mailer/logout.html.erb new file mode 100644 index 0000000000..0533a3b2fe --- /dev/null +++ b/actionmailer/test/fixtures/explicit_layout_mailer/logout.html.erb @@ -0,0 +1 @@ +You logged out
\ No newline at end of file diff --git a/actionmailer/test/fixtures/explicit_layout_mailer/signup.html.erb b/actionmailer/test/fixtures/explicit_layout_mailer/signup.html.erb new file mode 100644 index 0000000000..4789e888c6 --- /dev/null +++ b/actionmailer/test/fixtures/explicit_layout_mailer/signup.html.erb @@ -0,0 +1 @@ +We do not spam
\ No newline at end of file diff --git a/actionmailer/test/fixtures/i18n_test_mailer/mail_with_i18n_subject.erb b/actionmailer/test/fixtures/i18n_test_mailer/mail_with_i18n_subject.erb new file mode 100644 index 0000000000..f5340283f1 --- /dev/null +++ b/actionmailer/test/fixtures/i18n_test_mailer/mail_with_i18n_subject.erb @@ -0,0 +1,4 @@ +Hello there, + +Mr. <%= @recipient %>. Be greeted, new member! + diff --git a/actionmailer/test/fixtures/layouts/auto_layout_mailer.html.erb b/actionmailer/test/fixtures/layouts/auto_layout_mailer.html.erb new file mode 100644 index 0000000000..932271450c --- /dev/null +++ b/actionmailer/test/fixtures/layouts/auto_layout_mailer.html.erb @@ -0,0 +1 @@ +Hello from layout <%= yield %>
\ No newline at end of file diff --git a/actionmailer/test/fixtures/layouts/auto_layout_mailer.text.erb b/actionmailer/test/fixtures/layouts/auto_layout_mailer.text.erb new file mode 100644 index 0000000000..111576b672 --- /dev/null +++ b/actionmailer/test/fixtures/layouts/auto_layout_mailer.text.erb @@ -0,0 +1 @@ +text/plain layout - <%= yield %>
\ No newline at end of file diff --git a/actionmailer/test/fixtures/layouts/different_layout.html.erb b/actionmailer/test/fixtures/layouts/different_layout.html.erb new file mode 100644 index 0000000000..99eb026ae1 --- /dev/null +++ b/actionmailer/test/fixtures/layouts/different_layout.html.erb @@ -0,0 +1 @@ +HTML -- <%= yield %>
\ No newline at end of file diff --git a/actionmailer/test/fixtures/layouts/different_layout.text.erb b/actionmailer/test/fixtures/layouts/different_layout.text.erb new file mode 100644 index 0000000000..b93467b7ae --- /dev/null +++ b/actionmailer/test/fixtures/layouts/different_layout.text.erb @@ -0,0 +1 @@ +PLAIN -- <%= yield %>
\ No newline at end of file diff --git a/actionmailer/test/fixtures/layouts/spam.html.erb b/actionmailer/test/fixtures/layouts/spam.html.erb new file mode 100644 index 0000000000..619d6b16b4 --- /dev/null +++ b/actionmailer/test/fixtures/layouts/spam.html.erb @@ -0,0 +1 @@ +Spammer layout <%= yield %>
\ No newline at end of file diff --git a/actionmailer/test/fixtures/mail_delivery_test/delivery_mailer/welcome.html.erb b/actionmailer/test/fixtures/mail_delivery_test/delivery_mailer/welcome.html.erb new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/actionmailer/test/fixtures/mail_delivery_test/delivery_mailer/welcome.html.erb diff --git a/actionmailer/test/fixtures/nested_layout_mailer/signup.html.erb b/actionmailer/test/fixtures/nested_layout_mailer/signup.html.erb new file mode 100644 index 0000000000..4789e888c6 --- /dev/null +++ b/actionmailer/test/fixtures/nested_layout_mailer/signup.html.erb @@ -0,0 +1 @@ +We do not spam
\ No newline at end of file diff --git a/actionmailer/test/fixtures/proc_mailer/welcome.html.erb b/actionmailer/test/fixtures/proc_mailer/welcome.html.erb new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/actionmailer/test/fixtures/proc_mailer/welcome.html.erb diff --git a/actionmailer/test/fixtures/raw_email b/actionmailer/test/fixtures/raw_email new file mode 100644 index 0000000000..43f7a59cee --- /dev/null +++ b/actionmailer/test/fixtures/raw_email @@ -0,0 +1,14 @@ +From jamis_buck@byu.edu Mon May 2 16:07:05 2005 +Mime-Version: 1.0 (Apple Message framework v622) +Content-Transfer-Encoding: base64 +Message-Id: <d3b8cf8e49f04480850c28713a1f473e@37signals.com> +Content-Type: text/plain; + charset=EUC-KR; + format=flowed +To: willard15georgina@jamis.backpackit.com +From: Jamis Buck <jamis@37signals.com> +Subject: =?EUC-KR?Q?NOTE:_=C7=D1=B1=B9=B8=BB=B7=CE_=C7=CF=B4=C2_=B0=CD?= +Date: Mon, 2 May 2005 16:07:05 -0600 + +tOu6zrrQwMcguLbC+bChwfa3ziwgv+y4rrTCIMfPs6q01MC7ILnPvcC0z7TZLg0KDQrBpiDAzLin +wLogSmFtaXPA1LTPtNku diff --git a/actionmailer/test/fixtures/templates/signed_up.erb b/actionmailer/test/fixtures/templates/signed_up.erb new file mode 100644 index 0000000000..7afe1f651c --- /dev/null +++ b/actionmailer/test/fixtures/templates/signed_up.erb @@ -0,0 +1,3 @@ +Hello there, + +Mr. <%= @recipient %>
\ No newline at end of file diff --git a/actionmailer/test/fixtures/test_helper_mailer/welcome b/actionmailer/test/fixtures/test_helper_mailer/welcome new file mode 100644 index 0000000000..61ce70d578 --- /dev/null +++ b/actionmailer/test/fixtures/test_helper_mailer/welcome @@ -0,0 +1 @@ +Welcome!
\ No newline at end of file diff --git a/actionmailer/test/fixtures/url_test_mailer/exercise_url_for.erb b/actionmailer/test/fixtures/url_test_mailer/exercise_url_for.erb new file mode 100644 index 0000000000..0322c1191e --- /dev/null +++ b/actionmailer/test/fixtures/url_test_mailer/exercise_url_for.erb @@ -0,0 +1 @@ +<%= url_for(@options) %> <%= @url %> diff --git a/actionmailer/test/fixtures/url_test_mailer/signed_up_with_url.erb b/actionmailer/test/fixtures/url_test_mailer/signed_up_with_url.erb new file mode 100644 index 0000000000..6e7875cff5 --- /dev/null +++ b/actionmailer/test/fixtures/url_test_mailer/signed_up_with_url.erb @@ -0,0 +1,5 @@ +Hello there, + +Mr. <%= @recipient %>. Please see our greeting at <%= @welcome_url %> <%= welcome_url %> + +<%= image_tag "somelogo.png" %>
\ No newline at end of file diff --git a/actionmailer/test/i18n_with_controller_test.rb b/actionmailer/test/i18n_with_controller_test.rb new file mode 100644 index 0000000000..6e75cff347 --- /dev/null +++ b/actionmailer/test/i18n_with_controller_test.rb @@ -0,0 +1,77 @@ +# frozen_string_literal: true + +require "abstract_unit" +require "action_view" +require "action_controller" + +class I18nTestMailer < ActionMailer::Base + configure do |c| + c.assets_dir = "" + end + + def mail_with_i18n_subject(recipient) + @recipient = recipient + I18n.locale = :de + mail(to: recipient, subject: I18n.t(:email_subject), + from: "system@loudthinking.com", date: Time.local(2004, 12, 12)) + end +end + +class TestController < ActionController::Base + def send_mail + email = I18nTestMailer.mail_with_i18n_subject("test@localhost").deliver_now + render plain: "Mail sent - Subject: #{email.subject}" + end +end + +class ActionMailerI18nWithControllerTest < ActionDispatch::IntegrationTest + Routes = ActionDispatch::Routing::RouteSet.new + Routes.draw do + ActiveSupport::Deprecation.silence do + get ":controller(/:action(/:id))" + end + end + + class RoutedRackApp + attr_reader :routes + + def initialize(routes, &blk) + @routes = routes + @stack = ActionDispatch::MiddlewareStack.new(&blk).build(@routes) + end + + def call(env) + @stack.call(env) + end + end + + APP = RoutedRackApp.new(Routes) + + def app + APP + end + + teardown do + I18n.locale = I18n.default_locale + end + + def test_send_mail + stub_any_instance(Mail::SMTP, instance: Mail::SMTP.new({})) do |instance| + assert_called(instance, :deliver!) do + with_translation "de", email_subject: "[Anmeldung] Willkommen" do + get "/test/send_mail" + assert_equal "Mail sent - Subject: [Anmeldung] Willkommen", @response.body + end + end + end + end + + private + + def with_translation(locale, data) + I18n.backend.store_translations(locale, data) + yield + ensure + I18n.backend.reload! + end +end diff --git a/actionmailer/test/legacy_delivery_job_test.rb b/actionmailer/test/legacy_delivery_job_test.rb new file mode 100644 index 0000000000..112c842beb --- /dev/null +++ b/actionmailer/test/legacy_delivery_job_test.rb @@ -0,0 +1,86 @@ +# frozen_string_literal: true + +require "abstract_unit" +require "active_job" +require "mailers/params_mailer" +require "mailers/delayed_mailer" + +class LegacyDeliveryJobTest < ActiveSupport::TestCase + include ActiveJob::TestHelper + + class LegacyDeliveryJob < ActionMailer::DeliveryJob + end + + class LegacyParmeterizedDeliveryJob < ActionMailer::Parameterized::DeliveryJob + end + + setup do + @previous_logger = ActiveJob::Base.logger + ActiveJob::Base.logger = Logger.new(nil) + + @previous_delivery_method = ActionMailer::Base.delivery_method + ActionMailer::Base.delivery_method = :test + + @previous_deliver_later_queue_name = ActionMailer::Base.deliver_later_queue_name + ActionMailer::Base.deliver_later_queue_name = :test_queue + end + + teardown do + ActiveJob::Base.logger = @previous_logger + ParamsMailer.deliveries.clear + + ActionMailer::Base.delivery_method = @previous_delivery_method + ActionMailer::Base.deliver_later_queue_name = @previous_deliver_later_queue_name + end + + test "should send parameterized mail correctly" do + mail = ParamsMailer.with(inviter: "david@basecamp.com", invitee: "jason@basecamp.com").invitation + args = [ + "ParamsMailer", + "invitation", + "deliver_now", + { inviter: "david@basecamp.com", invitee: "jason@basecamp.com" }, + ] + + with_delivery_job(LegacyParmeterizedDeliveryJob) do + assert_deprecated do + assert_performed_with(job: LegacyParmeterizedDeliveryJob, args: args) do + mail.deliver_later + end + end + end + end + + test "should send mail correctly" do + mail = DelayedMailer.test_message(1, 2, 3) + args = [ + "DelayedMailer", + "test_message", + "deliver_now", + 1, + 2, + 3, + ] + + with_delivery_job(LegacyDeliveryJob) do + assert_deprecated do + assert_performed_with(job: LegacyDeliveryJob, args: args) do + mail.deliver_later + end + end + end + end + + private + + def with_delivery_job(job) + old_params_delivery_job = ParamsMailer.delivery_job + old_regular_delivery_job = DelayedMailer.delivery_job + ParamsMailer.delivery_job = job + DelayedMailer.delivery_job = job + yield + ensure + ParamsMailer.delivery_job = old_params_delivery_job + DelayedMailer.delivery_job = old_regular_delivery_job + end +end diff --git a/actionmailer/test/log_subscriber_test.rb b/actionmailer/test/log_subscriber_test.rb new file mode 100644 index 0000000000..7686fd10c9 --- /dev/null +++ b/actionmailer/test/log_subscriber_test.rb @@ -0,0 +1,63 @@ +# frozen_string_literal: true + +require "abstract_unit" +require "mailers/base_mailer" +require "active_support/log_subscriber/test_helper" +require "action_mailer/log_subscriber" + +class AMLogSubscriberTest < ActionMailer::TestCase + include ActiveSupport::LogSubscriber::TestHelper + + def setup + super + ActionMailer::LogSubscriber.attach_to :action_mailer + end + + class TestMailer < ActionMailer::Base + def receive(mail) + # Do nothing + end + end + + def set_logger(logger) + ActionMailer::Base.logger = logger + end + + def test_deliver_is_notified + BaseMailer.welcome.deliver_now + wait + + assert_equal(1, @logger.logged(:info).size) + assert_match(/Sent mail to system@test\.lindsaar\.net/, @logger.logged(:info).first) + + assert_equal(2, @logger.logged(:debug).size) + assert_match(/BaseMailer#welcome: processed outbound mail in [\d.]+ms/, @logger.logged(:debug).first) + assert_match(/Welcome/, @logger.logged(:debug).second) + ensure + BaseMailer.deliveries.clear + end + + def test_deliver_message_when_perform_deliveries_is_false + BaseMailer.welcome_without_deliveries.deliver_now + wait + + assert_equal(1, @logger.logged(:info).size) + assert_match("Skipped sending mail to system@test.lindsaar.net as `perform_deliveries` is false", @logger.logged(:info).first) + + assert_equal(2, @logger.logged(:debug).size) + assert_match(/BaseMailer#welcome_without_deliveries: processed outbound mail in [\d.]+ms/, @logger.logged(:debug).first) + assert_match("Welcome", @logger.logged(:debug).second) + ensure + BaseMailer.deliveries.clear + end + + def test_receive_is_notified + fixture = File.read(File.expand_path("fixtures/raw_email", __dir__)) + TestMailer.receive(fixture) + wait + assert_equal(1, @logger.logged(:info).size) + assert_match(/Received mail/, @logger.logged(:info).first) + assert_equal(1, @logger.logged(:debug).size) + assert_match(/Jamis/, @logger.logged(:debug).first) + end +end diff --git a/actionmailer/test/mail_helper_test.rb b/actionmailer/test/mail_helper_test.rb new file mode 100644 index 0000000000..51d6ccb10f --- /dev/null +++ b/actionmailer/test/mail_helper_test.rb @@ -0,0 +1,125 @@ +# frozen_string_literal: true + +require "abstract_unit" + +class HelperMailer < ActionMailer::Base + def use_mail_helper + @text = "But soft! What light through yonder window breaks? It is the east, " \ + "and Juliet is the sun. Arise, fair sun, and kill the envious moon, " \ + "which is sick and pale with grief that thou, her maid, art far more " \ + "fair than she. Be not her maid, for she is envious! Her vestal " \ + "livery is but sick and green, and none but fools do wear it. Cast " \ + "it off!" + + mail_with_defaults do |format| + format.html { render(inline: "<%= block_format @text %>") } + end + end + + def use_format_paragraph + @text = "But soft! What light through yonder window breaks?" + + mail_with_defaults do |format| + format.html { render(inline: "<%= format_paragraph @text, 15, 1 %>") } + end + end + + def use_format_paragraph_with_long_first_word + @text = "Antidisestablishmentarianism is very long." + + mail_with_defaults do |format| + format.html { render(inline: "<%= format_paragraph @text, 10, 1 %>") } + end + end + + def use_mailer + mail_with_defaults do |format| + format.html { render(inline: "<%= mailer.message.subject %>") } + end + end + + def use_message + mail_with_defaults do |format| + format.html { render(inline: "<%= message.subject %>") } + end + end + + def use_block_format + @text = <<-TEXT +This is the +first paragraph. + +The second + paragraph. + +* item1 * item2 + * item3 + TEXT + + mail_with_defaults do |format| + format.html { render(inline: "<%= block_format @text %>") } + end + end + + def use_cache + mail_with_defaults do |format| + format.html { render(inline: "<% cache(:foo) do %>Greetings from a cache helper block<% end %>") } + end + end + + private + + def mail_with_defaults(&block) + mail(to: "test@localhost", from: "tester@example.com", + subject: "using helpers", &block) + end +end + +class MailerHelperTest < ActionMailer::TestCase + def test_use_mail_helper + mail = HelperMailer.use_mail_helper + assert_match %r{ But soft!}, mail.body.encoded + assert_match %r{east, and\r\n Juliet}, mail.body.encoded + end + + def test_use_mailer + mail = HelperMailer.use_mailer + assert_match "using helpers", mail.body.encoded + end + + def test_use_message + mail = HelperMailer.use_message + assert_match "using helpers", mail.body.encoded + end + + def test_use_format_paragraph + mail = HelperMailer.use_format_paragraph + assert_match " But soft! What\r\n light through\r\n yonder window\r\n breaks?", mail.body.encoded + end + + def test_use_format_paragraph_with_long_first_word + mail = HelperMailer.use_format_paragraph_with_long_first_word + assert_equal " Antidisestablishmentarianism\r\n is very\r\n long.", mail.body.encoded + end + + def test_use_block_format + mail = HelperMailer.use_block_format + expected = <<-TEXT + This is the first paragraph. + + The second paragraph. + + * item1 + * item2 + * item3 + TEXT + assert_equal expected.gsub("\n", "\r\n"), mail.body.encoded + end + + def test_use_cache + assert_nothing_raised do + mail = HelperMailer.use_cache + assert_equal "Greetings from a cache helper block", mail.body.encoded + end + end +end diff --git a/actionmailer/test/mail_layout_test.rb b/actionmailer/test/mail_layout_test.rb new file mode 100644 index 0000000000..16d77ed61d --- /dev/null +++ b/actionmailer/test/mail_layout_test.rb @@ -0,0 +1,97 @@ +# frozen_string_literal: true + +require "abstract_unit" + +class AutoLayoutMailer < ActionMailer::Base + default to: "test@localhost", + subject: "You have a mail", + from: "tester@example.com" + + def hello + mail() + end + + def spam + @world = "Earth" + mail(body: render(inline: "Hello, <%= @world %>", layout: "spam")) + end + + def nolayout + @world = "Earth" + mail(body: render(inline: "Hello, <%= @world %>", layout: false)) + end + + def multipart(type = nil) + mail(content_type: type) do |format| + format.text { render } + format.html { render } + end + end +end + +class ExplicitLayoutMailer < ActionMailer::Base + layout "spam", except: [:logout] + + default to: "test@localhost", + subject: "You have a mail", + from: "tester@example.com" + + def signup + mail() + end + + def logout + mail() + end +end + +class LayoutMailerTest < ActiveSupport::TestCase + def test_should_pickup_default_layout + mail = AutoLayoutMailer.hello + assert_equal "Hello from layout Inside", mail.body.to_s.strip + end + + def test_should_pickup_multipart_layout + mail = AutoLayoutMailer.multipart + assert_equal "multipart/alternative", mail.mime_type + assert_equal 2, mail.parts.size + + assert_equal "text/plain", mail.parts.first.mime_type + assert_equal "text/plain layout - text/plain multipart", mail.parts.first.body.to_s + + assert_equal "text/html", mail.parts.last.mime_type + assert_equal "Hello from layout text/html multipart", mail.parts.last.body.to_s + end + + def test_should_pickup_multipartmixed_layout + mail = AutoLayoutMailer.multipart("multipart/mixed") + assert_equal "multipart/mixed", mail.mime_type + assert_equal 2, mail.parts.size + + assert_equal "text/plain", mail.parts.first.mime_type + assert_equal "text/plain layout - text/plain multipart", mail.parts.first.body.to_s + + assert_equal "text/html", mail.parts.last.mime_type + assert_equal "Hello from layout text/html multipart", mail.parts.last.body.to_s + end + + def test_should_pickup_layout_given_to_render + mail = AutoLayoutMailer.spam + assert_equal "Spammer layout Hello, Earth", mail.body.to_s.strip + end + + def test_should_respect_layout_false + mail = AutoLayoutMailer.nolayout + assert_equal "Hello, Earth", mail.body.to_s.strip + end + + def test_explicit_class_layout + mail = ExplicitLayoutMailer.signup + assert_equal "Spammer layout We do not spam", mail.body.to_s.strip + end + + def test_explicit_layout_exceptions + mail = ExplicitLayoutMailer.logout + assert_equal "You logged out", mail.body.to_s.strip + end +end diff --git a/actionmailer/test/mailers/asset_mailer.rb b/actionmailer/test/mailers/asset_mailer.rb new file mode 100644 index 0000000000..7a9aba2629 --- /dev/null +++ b/actionmailer/test/mailers/asset_mailer.rb @@ -0,0 +1,9 @@ +# frozen_string_literal: true + +class AssetMailer < ActionMailer::Base + self.mailer_name = "asset_mailer" + + def welcome + mail + end +end diff --git a/actionmailer/test/mailers/base_mailer.rb b/actionmailer/test/mailers/base_mailer.rb new file mode 100644 index 0000000000..c1bb48cc96 --- /dev/null +++ b/actionmailer/test/mailers/base_mailer.rb @@ -0,0 +1,150 @@ +# frozen_string_literal: true + +class BaseMailer < ActionMailer::Base + self.mailer_name = "base_mailer" + + default to: "system@test.lindsaar.net", + from: "jose@test.plataformatec.com", + reply_to: "mikel@test.lindsaar.net" + + def welcome(hash = {}) + headers["X-SPAM"] = "Not SPAM" + mail({ subject: "The first email on new API!" }.merge!(hash)) + end + + def welcome_with_headers(hash = {}) + headers hash + mail + end + + def welcome_from_another_path(path) + mail(template_name: "welcome", template_path: path) + end + + def welcome_without_deliveries + mail(template_name: "welcome") + mail.perform_deliveries = false + end + + def html_only(hash = {}) + mail(hash) + end + + def plain_text_only(hash = {}) + mail(hash) + end + + def inline_attachment + attachments.inline["logo.png"] = "\312\213\254\232" + mail + end + + def attachment_with_content(hash = {}) + attachments["invoice.pdf"] = "This is test File content" + mail(hash) + end + + def attachment_with_hash + attachments["invoice.jpg"] = { data: ::Base64.encode64("\312\213\254\232)b"), + mime_type: "image/x-jpg", + transfer_encoding: "base64" } + mail + end + + def attachment_with_hash_default_encoding + attachments["invoice.jpg"] = { data: "\312\213\254\232)b", + mime_type: "image/x-jpg" } + mail + end + + def implicit_multipart(hash = {}) + attachments["invoice.pdf"] = "This is test File content" if hash.delete(:attachments) + mail(hash) + end + + def implicit_with_locale(hash = {}) + mail(hash) + end + + def explicit_multipart(hash = {}) + attachments["invoice.pdf"] = "This is test File content" if hash.delete(:attachments) + mail(hash) do |format| + format.text { render plain: "TEXT Explicit Multipart" } + format.html { render plain: "HTML Explicit Multipart" } + end + end + + def explicit_multipart_templates(hash = {}) + mail(hash) do |format| + format.html + format.text + end + end + + def explicit_multipart_with_any(hash = {}) + mail(hash) do |format| + format.any(:text, :html) { render plain: "Format with any!" } + end + end + + def explicit_without_specifying_format_with_any(hash = {}) + mail(hash) do |format| + format.any + end + end + + def explicit_multipart_with_options(include_html = false) + mail do |format| + format.text(content_transfer_encoding: "base64") { render "welcome" } + format.html { render "welcome" } if include_html + end + end + + def explicit_multipart_with_one_template(hash = {}) + mail(hash) do |format| + format.html + format.text + end + end + + def implicit_different_template(template_name = "") + mail(template_name: template_name) + end + + def implicit_different_template_with_block(template_name = "") + mail(template_name: template_name) do |format| + format.text + format.html + end + end + + def explicit_different_template(template_name = "") + mail do |format| + format.text { render template: "#{mailer_name}/#{template_name}" } + format.html { render template: "#{mailer_name}/#{template_name}" } + end + end + + def different_layout(layout_name = "") + mail do |format| + format.text { render layout: layout_name } + format.html { render layout: layout_name } + end + end + + def email_with_translations + mail body: render("email_with_translations", formats: [:html]) + end + + def without_mail_call + end + + def with_nil_as_return_value + mail(template_name: "welcome") + nil + end + + def with_subject_interpolations + mail(subject: default_i18n_subject(rapper_or_impersonator: "Slim Shady"), body: "") + end +end diff --git a/actionmailer/test/mailers/caching_mailer.rb b/actionmailer/test/mailers/caching_mailer.rb new file mode 100644 index 0000000000..02f0c6c103 --- /dev/null +++ b/actionmailer/test/mailers/caching_mailer.rb @@ -0,0 +1,25 @@ +# frozen_string_literal: true + +class CachingMailer < ActionMailer::Base + self.mailer_name = "caching_mailer" + + def fragment_cache + mail(subject: "welcome", template_name: "fragment_cache") + end + + def fragment_cache_in_partials + mail(subject: "welcome", template_name: "fragment_cache_in_partials") + end + + def skip_fragment_cache_digesting + mail(subject: "welcome", template_name: "skip_fragment_cache_digesting") + end + + def fragment_caching_options + mail(subject: "welcome", template_name: "fragment_caching_options") + end + + def multipart_cache + mail(subject: "welcome", template_name: "multipart_cache") + end +end diff --git a/actionmailer/test/mailers/delayed_mailer.rb b/actionmailer/test/mailers/delayed_mailer.rb new file mode 100644 index 0000000000..b0f5ecc2fb --- /dev/null +++ b/actionmailer/test/mailers/delayed_mailer.rb @@ -0,0 +1,28 @@ +# frozen_string_literal: true + +require "active_job/arguments" + +class DelayedMailerError < StandardError; end + +class DelayedMailer < ActionMailer::Base + cattr_accessor :last_error + cattr_accessor :last_rescue_from_instance + + rescue_from DelayedMailerError do |error| + @@last_error = error + @@last_rescue_from_instance = self + end + + rescue_from ActiveJob::DeserializationError do |error| + @@last_error = error + @@last_rescue_from_instance = self + end + + def test_message(*) + mail(from: "test-sender@test.com", to: "test-receiver@test.com", subject: "Test Subject", body: "Test Body") + end + + def test_raise(klass_name) + raise klass_name.constantize, "boom" + end +end diff --git a/actionmailer/test/mailers/params_mailer.rb b/actionmailer/test/mailers/params_mailer.rb new file mode 100644 index 0000000000..84aa336311 --- /dev/null +++ b/actionmailer/test/mailers/params_mailer.rb @@ -0,0 +1,13 @@ +# frozen_string_literal: true + +class ParamsMailer < ActionMailer::Base + before_action { @inviter, @invitee = params[:inviter], params[:invitee] } + + default to: Proc.new { @invitee }, from: -> { @inviter } + + def invitation + mail(subject: "Welcome to the project!") do |format| + format.text { render plain: "So says #{@inviter}" } + end + end +end diff --git a/actionmailer/test/mailers/proc_mailer.rb b/actionmailer/test/mailers/proc_mailer.rb new file mode 100644 index 0000000000..76e730bb79 --- /dev/null +++ b/actionmailer/test/mailers/proc_mailer.rb @@ -0,0 +1,25 @@ +# frozen_string_literal: true + +class ProcMailer < ActionMailer::Base + default to: "system@test.lindsaar.net", + "X-Proc-Method" => Proc.new { Time.now.to_i.to_s }, + subject: Proc.new { give_a_greeting }, + "x-has-to-proc" => :symbol, + "X-Lambda-Arity-0" => ->() { "0" }, + "X-Lambda-Arity-1-arg" => ->(arg) { arg.computed_value }, + "X-Lambda-Arity-1-self" => ->(_) { self.computed_value } + + def welcome + mail + end + + def computed_value + "complex_value" + end + + private + + def give_a_greeting + "Thanks for signing up this afternoon" + end +end diff --git a/actionmailer/test/message_delivery_test.rb b/actionmailer/test/message_delivery_test.rb new file mode 100644 index 0000000000..46260f6414 --- /dev/null +++ b/actionmailer/test/message_delivery_test.rb @@ -0,0 +1,167 @@ +# frozen_string_literal: true + +require "abstract_unit" +require "active_job" +require "mailers/delayed_mailer" + +class MessageDeliveryTest < ActiveSupport::TestCase + include ActiveJob::TestHelper + + setup do + @previous_logger = ActiveJob::Base.logger + @previous_delivery_method = ActionMailer::Base.delivery_method + @previous_deliver_later_queue_name = ActionMailer::Base.deliver_later_queue_name + ActionMailer::Base.deliver_later_queue_name = :test_queue + ActionMailer::Base.delivery_method = :test + ActiveJob::Base.logger = Logger.new(nil) + ActiveJob::Base.queue_adapter.perform_enqueued_at_jobs = true + ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true + + DelayedMailer.last_error = nil + DelayedMailer.last_rescue_from_instance = nil + + @mail = DelayedMailer.test_message(1, 2, 3) + end + + teardown do + ActionMailer::Base.deliveries.clear + + ActiveJob::Base.logger = @previous_logger + ActionMailer::Base.delivery_method = @previous_delivery_method + ActionMailer::Base.deliver_later_queue_name = @previous_deliver_later_queue_name + + DelayedMailer.last_error = nil + DelayedMailer.last_rescue_from_instance = nil + end + + test "should have a message" do + assert @mail.message + end + + test "its message should be a Mail::Message" do + assert_equal Mail::Message, @mail.message.class + end + + test "should respond to .deliver_later" do + assert_respond_to @mail, :deliver_later + end + + test "should respond to .deliver_later!" do + assert_respond_to @mail, :deliver_later! + end + + test "should respond to .deliver_now" do + assert_respond_to @mail, :deliver_now + end + + test "should respond to .deliver_now!" do + assert_respond_to @mail, :deliver_now! + end + + def test_should_enqueue_and_run_correctly_in_activejob + @mail.deliver_later! + assert_equal 1, ActionMailer::Base.deliveries.size + end + + test "should enqueue the email with :deliver_now delivery method" do + assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", args: [1, 2, 3]]) do + @mail.deliver_later + end + end + + test "should enqueue the email with :deliver_now! delivery method" do + assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now!", args: [1, 2, 3]]) do + @mail.deliver_later! + end + end + + test "should enqueue a delivery with a delay" do + travel_to Time.new(2004, 11, 24, 01, 04, 44) do + assert_performed_with(job: ActionMailer::MailDeliveryJob, at: Time.current + 10.minutes, args: ["DelayedMailer", "test_message", "deliver_now", args: [1, 2, 3]]) do + @mail.deliver_later wait: 10.minutes + end + end + end + + test "should enqueue a delivery at a specific time" do + later_time = Time.current + 1.hour + assert_performed_with(job: ActionMailer::MailDeliveryJob, at: later_time, args: ["DelayedMailer", "test_message", "deliver_now", args: [1, 2, 3]]) do + @mail.deliver_later wait_until: later_time + end + end + + test "should enqueue the job on the correct queue" do + assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", args: [1, 2, 3]], queue: "test_queue") do + @mail.deliver_later + end + end + + test "should enqueue the job with the correct delivery job" do + old_delivery_job = DelayedMailer.delivery_job + DelayedMailer.delivery_job = DummyJob + + assert_performed_with(job: DummyJob, args: ["DelayedMailer", "test_message", "deliver_now", args: [1, 2, 3]]) do + @mail.deliver_later + end + + DelayedMailer.delivery_job = old_delivery_job + end + + class DummyJob < ActionMailer::MailDeliveryJob; end + + test "can override the queue when enqueuing mail" do + assert_performed_with(job: ActionMailer::MailDeliveryJob, args: ["DelayedMailer", "test_message", "deliver_now", args: [1, 2, 3]], queue: "another_queue") do + @mail.deliver_later(queue: :another_queue) + end + end + + test "deliver_later after accessing the message is disallowed" do + @mail.message # Load the message, which calls the mailer method. + + assert_raise RuntimeError do + @mail.deliver_later + end + end + + test "job delegates error handling to mailer" do + # Superclass not rescued by mailer's rescue_from RuntimeError + message = DelayedMailer.test_raise("StandardError") + assert_raise(StandardError) { message.deliver_later } + assert_nil DelayedMailer.last_error + assert_nil DelayedMailer.last_rescue_from_instance + + # Rescued by mailer's rescue_from RuntimeError + message = DelayedMailer.test_raise("DelayedMailerError") + assert_nothing_raised { message.deliver_later } + assert_equal "boom", DelayedMailer.last_error.message + assert_kind_of DelayedMailer, DelayedMailer.last_rescue_from_instance + end + + class DeserializationErrorFixture + include GlobalID::Identification + + def self.find(id) + raise "boom, missing find" + end + + attr_reader :id + def initialize(id = 1) + @id = id + end + + def to_global_id(options = {}) + super app: "foo" + end + end + + test "job delegates deserialization errors to mailer class" do + # Inject an argument that can't be deserialized. + message = DelayedMailer.test_message(DeserializationErrorFixture.new) + + # DeserializationError is raised, rescued, and delegated to the handler + # on the mailer class. + assert_nothing_raised { message.deliver_later } + assert_equal DelayedMailer, DelayedMailer.last_rescue_from_instance + assert_equal "Error while trying to deserialize arguments: boom, missing find", DelayedMailer.last_error.message + end +end diff --git a/actionmailer/test/parameterized_test.rb b/actionmailer/test/parameterized_test.rb new file mode 100644 index 0000000000..7dd6156744 --- /dev/null +++ b/actionmailer/test/parameterized_test.rb @@ -0,0 +1,92 @@ +# frozen_string_literal: true + +require "abstract_unit" +require "active_job" +require "mailers/params_mailer" + +class ParameterizedTest < ActiveSupport::TestCase + include ActiveJob::TestHelper + + class DummyDeliveryJob < ActionMailer::MailDeliveryJob + end + + setup do + @previous_logger = ActiveJob::Base.logger + ActiveJob::Base.logger = Logger.new(nil) + + @previous_delivery_method = ActionMailer::Base.delivery_method + ActionMailer::Base.delivery_method = :test + + @previous_deliver_later_queue_name = ActionMailer::Base.deliver_later_queue_name + ActionMailer::Base.deliver_later_queue_name = :test_queue + + @mail = ParamsMailer.with(inviter: "david@basecamp.com", invitee: "jason@basecamp.com").invitation + end + + teardown do + ActiveJob::Base.logger = @previous_logger + ParamsMailer.deliveries.clear + + ActionMailer::Base.delivery_method = @previous_delivery_method + ActionMailer::Base.deliver_later_queue_name = @previous_deliver_later_queue_name + end + + test "parameterized headers" do + assert_equal(["jason@basecamp.com"], @mail.to) + assert_equal(["david@basecamp.com"], @mail.from) + assert_equal("So says david@basecamp.com", @mail.body.encoded) + end + + test "enqueue the email with params" do + args = [ + "ParamsMailer", + "invitation", + "deliver_now", + params: { inviter: "david@basecamp.com", invitee: "jason@basecamp.com" }, + args: [], + ] + assert_performed_with(job: ActionMailer::MailDeliveryJob, args: args) do + @mail.deliver_later + end + end + + test "respond_to?" do + mailer = ParamsMailer.with(inviter: "david@basecamp.com", invitee: "jason@basecamp.com") + + assert_respond_to mailer, :invitation + assert_not_respond_to mailer, :anything + + invitation = mailer.method(:invitation) + assert_equal Method, invitation.class + + assert_raises(NameError) do + invitation = mailer.method(:anything) + end + end + + test "should enqueue a parameterized request with the correct delivery job" do + args = [ + "ParamsMailer", + "invitation", + "deliver_now", + params: { inviter: "david@basecamp.com", invitee: "jason@basecamp.com" }, + args: [], + ] + + with_delivery_job DummyDeliveryJob do + assert_performed_with(job: DummyDeliveryJob, args: args) do + @mail.deliver_later + end + end + end + + private + + def with_delivery_job(job) + old_delivery_job = ParamsMailer.delivery_job + ParamsMailer.delivery_job = job + yield + ensure + ParamsMailer.delivery_job = old_delivery_job + end +end diff --git a/actionmailer/test/test_case_test.rb b/actionmailer/test/test_case_test.rb new file mode 100644 index 0000000000..7b9647d295 --- /dev/null +++ b/actionmailer/test/test_case_test.rb @@ -0,0 +1,68 @@ +# frozen_string_literal: true + +require "abstract_unit" + +class TestTestMailer < ActionMailer::Base +end + +class ClearTestDeliveriesMixinTest < ActiveSupport::TestCase + include ActionMailer::TestCase::ClearTestDeliveries + + def before_setup + ActionMailer::Base.delivery_method, @original_delivery_method = :test, ActionMailer::Base.delivery_method + ActionMailer::Base.deliveries << "better clear me, setup" + super + end + + def after_teardown + super + assert_equal [], ActionMailer::Base.deliveries + ActionMailer::Base.delivery_method = @original_delivery_method + end + + def test_deliveries_are_cleared_on_setup_and_teardown + assert_equal [], ActionMailer::Base.deliveries + ActionMailer::Base.deliveries << "better clear me, teardown" + end +end + +class MailerDeliveriesClearingTest < ActionMailer::TestCase + def before_setup + ActionMailer::Base.deliveries << "better clear me, setup" + super + end + + def after_teardown + super + assert_equal [], ActionMailer::Base.deliveries + end + + def test_deliveries_are_cleared_on_setup_and_teardown + assert_equal [], ActionMailer::Base.deliveries + ActionMailer::Base.deliveries << "better clear me, teardown" + end +end + +class CrazyNameMailerTest < ActionMailer::TestCase + tests TestTestMailer + + def test_set_mailer_class_manual + assert_equal TestTestMailer, self.class.mailer_class + end +end + +class CrazySymbolNameMailerTest < ActionMailer::TestCase + tests :test_test_mailer + + def test_set_mailer_class_manual_using_symbol + assert_equal TestTestMailer, self.class.mailer_class + end +end + +class CrazyStringNameMailerTest < ActionMailer::TestCase + tests "test_test_mailer" + + def test_set_mailer_class_manual_using_string + assert_equal TestTestMailer, self.class.mailer_class + end +end diff --git a/actionmailer/test/test_helper_test.rb b/actionmailer/test/test_helper_test.rb new file mode 100644 index 0000000000..60e2389aa8 --- /dev/null +++ b/actionmailer/test/test_helper_test.rb @@ -0,0 +1,361 @@ +# frozen_string_literal: true + +require "abstract_unit" +require "active_support/testing/stream" + +class TestHelperMailer < ActionMailer::Base + def test + @world = "Earth" + mail body: render(inline: "Hello, <%= @world %>"), + to: "test@example.com", + from: "tester@example.com" + end + + def test_args(recipient, name) + mail body: render(inline: "Hello, #{name}"), + to: recipient, + from: "tester@example.com" + end + + def test_parameter_args + mail body: render(inline: "All is #{params[:all]}"), + to: "test@example.com", + from: "tester@example.com" + end +end + +class CustomDeliveryJob < ActionMailer::MailDeliveryJob +end + +class CustomDeliveryMailer < TestHelperMailer + self.delivery_job = CustomDeliveryJob +end + +class TestHelperMailerTest < ActionMailer::TestCase + include ActiveSupport::Testing::Stream + + def test_setup_sets_right_action_mailer_options + assert_equal :test, ActionMailer::Base.delivery_method + assert ActionMailer::Base.perform_deliveries + assert_equal [], ActionMailer::Base.deliveries + end + + def test_setup_creates_the_expected_mailer + assert_kind_of Mail::Message, @expected + assert_equal "1.0", @expected.mime_version + assert_equal "text/plain", @expected.mime_type + end + + def test_mailer_class_is_correctly_inferred + assert_equal TestHelperMailer, self.class.mailer_class + end + + def test_determine_default_mailer_raises_correct_error + assert_raise(ActionMailer::NonInferrableMailerError) do + self.class.determine_default_mailer("NotAMailerTest") + end + end + + def test_charset_is_utf_8 + assert_equal "UTF-8", charset + end + + def test_encode + assert_equal "This is あ string", Mail::Encodings.q_value_decode(encode("This is あ string")) + end + + def test_read_fixture + assert_equal ["Welcome!"], read_fixture("welcome") + end + + def test_assert_emails + assert_nothing_raised do + assert_emails 1 do + TestHelperMailer.test.deliver_now + end + end + end + + def test_assert_emails_with_custom_delivery_job + assert_nothing_raised do + assert_emails(1) do + silence_stream($stdout) do + CustomDeliveryMailer.test.deliver_later + end + end + end + end + + def test_assert_emails_with_custom_parameterized_delivery_job + assert_nothing_raised do + assert_emails(1) do + silence_stream($stdout) do + CustomDeliveryMailer.with(foo: "bar").test_parameter_args.deliver_later + end + end + end + end + + def test_assert_emails_with_enqueued_emails + assert_nothing_raised do + assert_emails 1 do + silence_stream($stdout) do + TestHelperMailer.test.deliver_later + end + end + end + end + + def test_repeated_assert_emails_calls + assert_nothing_raised do + assert_emails 1 do + TestHelperMailer.test.deliver_now + end + end + + assert_nothing_raised do + assert_emails 2 do + TestHelperMailer.test.deliver_now + TestHelperMailer.test.deliver_now + end + end + end + + def test_assert_emails_with_no_block + assert_nothing_raised do + TestHelperMailer.test.deliver_now + assert_emails 1 + end + + assert_nothing_raised do + TestHelperMailer.test.deliver_now + TestHelperMailer.test.deliver_now + assert_emails 3 + end + end + + def test_assert_no_emails + assert_nothing_raised do + assert_no_emails do + TestHelperMailer.test + end + end + end + + def test_assert_no_emails_with_enqueued_emails + error = assert_raise ActiveSupport::TestCase::Assertion do + assert_no_emails do + silence_stream($stdout) do + TestHelperMailer.test.deliver_later + end + end + end + + assert_match(/0 .* but 1/, error.message) + end + + def test_assert_emails_too_few_sent + error = assert_raise ActiveSupport::TestCase::Assertion do + assert_emails 2 do + TestHelperMailer.test.deliver_now + end + end + + assert_match(/2 .* but 1/, error.message) + end + + def test_assert_emails_too_many_sent + error = assert_raise ActiveSupport::TestCase::Assertion do + assert_emails 1 do + TestHelperMailer.test.deliver_now + TestHelperMailer.test.deliver_now + end + end + + assert_match(/1 .* but 2/, error.message) + end + + def test_assert_emails_message + TestHelperMailer.test.deliver_now + error = assert_raise ActiveSupport::TestCase::Assertion do + assert_emails 2 do + TestHelperMailer.test.deliver_now + end + end + assert_match "Expected: 2", error.message + assert_match "Actual: 1", error.message + end + + def test_assert_no_emails_failure + error = assert_raise ActiveSupport::TestCase::Assertion do + assert_no_emails do + TestHelperMailer.test.deliver_now + end + end + + assert_match(/0 .* but 1/, error.message) + end + + def test_assert_enqueued_emails + assert_nothing_raised do + assert_enqueued_emails 1 do + silence_stream($stdout) do + TestHelperMailer.test.deliver_later + end + end + end + end + + def test_assert_enqueued_parameterized_emails + assert_nothing_raised do + assert_enqueued_emails 1 do + silence_stream($stdout) do + TestHelperMailer.with(a: 1).test.deliver_later + end + end + end + end + + def test_assert_enqueued_emails_too_few_sent + error = assert_raise ActiveSupport::TestCase::Assertion do + assert_enqueued_emails 2 do + silence_stream($stdout) do + TestHelperMailer.test.deliver_later + end + end + end + + assert_match(/2 .* but 1/, error.message) + end + + def test_assert_enqueued_emails_with_custom_delivery_job + assert_nothing_raised do + assert_enqueued_emails(1) do + silence_stream($stdout) do + CustomDeliveryMailer.test.deliver_later + end + end + end + end + + def test_assert_enqueued_emails_too_many_sent + error = assert_raise ActiveSupport::TestCase::Assertion do + assert_enqueued_emails 1 do + silence_stream($stdout) do + TestHelperMailer.test.deliver_later + TestHelperMailer.test.deliver_later + end + end + end + + assert_match(/1 .* but 2/, error.message) + end + + def test_assert_no_enqueued_emails + assert_nothing_raised do + assert_no_enqueued_emails do + TestHelperMailer.test.deliver_now + end + end + end + + def test_assert_no_enqueued_parameterized_emails + assert_nothing_raised do + assert_no_enqueued_emails do + TestHelperMailer.with(a: 1).test.deliver_now + end + end + end + + def test_assert_no_enqueued_emails_failure + error = assert_raise ActiveSupport::TestCase::Assertion do + assert_no_enqueued_emails do + silence_stream($stdout) do + TestHelperMailer.test.deliver_later + end + end + end + + assert_match(/0 .* but 1/, error.message) + end + + def test_assert_enqueued_email_with + assert_nothing_raised do + assert_enqueued_email_with TestHelperMailer, :test do + silence_stream($stdout) do + TestHelperMailer.test.deliver_later + end + end + end + end + + def test_assert_enqueued_email_with_when_mailer_has_custom_delivery_job + assert_nothing_raised do + assert_enqueued_email_with CustomDeliveryMailer, :test do + silence_stream($stdout) do + CustomDeliveryMailer.test.deliver_later + end + end + end + end + + def test_assert_enqueued_email_with_with_no_block + assert_nothing_raised do + silence_stream($stdout) do + TestHelperMailer.test.deliver_later + assert_enqueued_email_with TestHelperMailer, :test + end + end + end + + def test_assert_enqueued_email_with_with_args + assert_nothing_raised do + assert_enqueued_email_with TestHelperMailer, :test_args, args: ["some_email", "some_name"] do + silence_stream($stdout) do + TestHelperMailer.test_args("some_email", "some_name").deliver_later + end + end + end + end + + def test_assert_enqueued_email_with_with_no_block_with_args + assert_nothing_raised do + silence_stream($stdout) do + TestHelperMailer.test_args("some_email", "some_name").deliver_later + assert_enqueued_email_with TestHelperMailer, :test_args, args: ["some_email", "some_name"] + end + end + end + + def test_assert_enqueued_email_with_with_parameterized_args + assert_nothing_raised do + assert_enqueued_email_with TestHelperMailer, :test_parameter_args, args: { all: "good" } do + silence_stream($stdout) do + TestHelperMailer.with(all: "good").test_parameter_args.deliver_later + end + end + end + end + + def test_assert_enqueued_email_with_with_no_block_with_parameterized_args + assert_nothing_raised do + silence_stream($stdout) do + TestHelperMailer.with(all: "good").test_parameter_args.deliver_later + assert_enqueued_email_with TestHelperMailer, :test_parameter_args, args: { all: "good" } + end + end + end +end + +class AnotherTestHelperMailerTest < ActionMailer::TestCase + tests TestHelperMailer + + def setup + @test_var = "a value" + end + + def test_setup_shouldnt_conflict_with_mailer_setup + assert_kind_of Mail::Message, @expected + assert_equal "a value", @test_var + end +end diff --git a/actionmailer/test/url_test.rb b/actionmailer/test/url_test.rb new file mode 100644 index 0000000000..a926663a9f --- /dev/null +++ b/actionmailer/test/url_test.rb @@ -0,0 +1,134 @@ +# frozen_string_literal: true + +require "abstract_unit" +require "action_controller" + +class WelcomeController < ActionController::Base +end + +AppRoutes = ActionDispatch::Routing::RouteSet.new + +AppRoutes.draw do + get "/welcome" => "foo#bar", as: "welcome" + get "/dummy_model" => "foo#baz", as: "dummy_model" + get "/welcome/greeting", to: "welcome#greeting" + get "/a/b(/:id)", to: "a#b" +end + +class UrlTestMailer < ActionMailer::Base + include AppRoutes.url_helpers + + default_url_options[:host] = "www.basecamphq.com" + + configure do |c| + c.assets_dir = "" # To get the tests to pass + end + + def signed_up_with_url(recipient) + @recipient = recipient + @welcome_url = url_for host: "example.com", controller: "welcome", action: "greeting" + mail(to: recipient, subject: "[Signed up] Welcome #{recipient}", + from: "system@loudthinking.com", date: Time.local(2004, 12, 12)) + end + + def exercise_url_for(options) + @options = options + @url = url_for(@options) + mail(from: "from@example.com", to: "to@example.com", subject: "subject") + end +end + +class ActionMailerUrlTest < ActionMailer::TestCase + class DummyModel + def self.model_name + OpenStruct.new(route_key: "dummy_model") + end + + def persisted? + false + end + + def model_name + self.class.model_name + end + + def to_model + self + end + end + + def encode(text, charset = "UTF-8") + quoted_printable(text, charset) + end + + def new_mail(charset = "UTF-8") + mail = Mail.new + mail.mime_version = "1.0" + if charset + mail.content_type ["text", "plain", { "charset" => charset }] + end + mail + end + + def assert_url_for(expected, options, relative = false) + expected = "http://www.basecamphq.com#{expected}" if expected.start_with?("/") && !relative + urls = UrlTestMailer.exercise_url_for(options).body.to_s.chomp.split + + assert_equal expected, urls.first + assert_equal expected, urls.second + end + + def setup + @recipient = "test@localhost" + end + + def test_url_for + UrlTestMailer.delivery_method = :test + + # string + assert_url_for "http://foo/", "http://foo/" + + # symbol + assert_url_for "/welcome", :welcome + + # hash + assert_url_for "/a/b/c", controller: "a", action: "b", id: "c" + assert_url_for "/a/b/c", { controller: "a", action: "b", id: "c", only_path: true }, true + + # model + assert_url_for "/dummy_model", DummyModel.new + + # class + assert_url_for "/dummy_model", DummyModel + + # array + assert_url_for "/dummy_model", [DummyModel] + end + + def test_signed_up_with_url + UrlTestMailer.delivery_method = :test + + expected = new_mail + expected.to = @recipient + expected.subject = "[Signed up] Welcome #{@recipient}" + expected.body = "Hello there,\n\nMr. #{@recipient}. Please see our greeting at http://example.com/welcome/greeting http://www.basecamphq.com/welcome\n\n<img src=\"/images/somelogo.png\" />" + expected.from = "system@loudthinking.com" + expected.date = Time.local(2004, 12, 12) + expected.content_type = "text/html" + + created = nil + assert_nothing_raised { created = UrlTestMailer.signed_up_with_url(@recipient) } + assert_not_nil created + + expected.message_id = "<123@456>" + created.message_id = "<123@456>" + assert_dom_equal expected.encoded, created.encoded + + assert_nothing_raised { UrlTestMailer.signed_up_with_url(@recipient).deliver_now } + assert_not_nil ActionMailer::Base.deliveries.first + delivered = ActionMailer::Base.deliveries.first + + delivered.message_id = "<123@456>" + assert_dom_equal expected.encoded, delivered.encoded + end +end |
