mandrill_mailer 0.6.1 → 1.0.0

data/lib/mandrill_mailer/offline.rb

@@ -27,25 +27,29 @@ module MandrillMailer
 
   class TemplateMailer
     def deliver
-      MandrillMailer.deliveries << MandrillMailer::Mock.new({
+      MandrillMailer::Mock.new({
         :template_name    => template_name,
         :template_content => template_content,
         :message          => message,
         :async            => async,
         :ip_pool          => ip_pool,
         :send_at          => send_at
-      })
+      }).tap do |mock|
+         MandrillMailer.deliveries << mock
+      end
     end
   end
+
   class MessageMailer
     def deliver
-
-      MandrillMailer.deliveries << MandrillMailer::Mock.new({
+      MandrillMailer::Mock.new({
         :message          => message,
         :async            => async,
         :ip_pool          => ip_pool,
         :send_at          => send_at
-      })
+      }).tap do |mock|
+         MandrillMailer.deliveries << mock
+      end
     end
-  end  
+  end
 end

data/lib/mandrill_mailer/template_mailer.rb

@@ -100,8 +100,8 @@
 #   message HTML - only for HTML documents less than 256KB in size
 
 # :important - whether or not this message is important, and should be delivered ahead of non-important messages
-require 'base64'
 require 'mandrill_mailer/core_mailer'
+require 'mandrill_mailer/arg_formatter'
 
 module MandrillMailer
   class TemplateMailer < MandrillMailer::CoreMailer
@@ -114,107 +114,19 @@ module MandrillMailer
 
     # Public: Triggers the stored Mandrill params to be sent to the Mandrill api
     def deliver
-      mandrill = Mandrill::API.new(api_key)
-      mandrill.messages.send_template(template_name, template_content, message, async, ip_pool, send_at)
+      mandrill_api.messages.send_template(template_name, template_content, message, async, ip_pool, send_at)
     end
 
-    # Public: Build the hash needed to send to the mandrill api
-    #
-    # args - The Hash options used to refine the selection:
-    #             :template - Template name in Mandrill
-    #             :subject - Subject of the email
-    #             :to - Email to send the mandrill email to
-    #             :vars - Global merge vars used in the email for dynamic data
-    #             :recipient_vars - Merge vars used in the email for recipient-specific dynamic data
-    #             :bcc - bcc email for the mandrill email
-    #             :tags - Tags for the email
-    #             :google_analytics_domains - Google analytics domains
-    #             :google_analytics_campaign - Google analytics campaign
-    #             :inline_css - whether or not to automatically inline all CSS styles provided in the message HTML
-    #             :important - whether or not this message is important
-    #             :async - whether or not this message should be sent asynchronously
-    #             :ip_pool - name of the dedicated IP pool that should be used to send the message
-    #             :send_at - when this message should be sent
-    #
-    # Examples
-    #
-    #   mandrill_mail template: 'Group Invite',
-    #               subject: I18n.t('invitation_mailer.invite.subject'),
-    #               to: invitation.email,
-    #               vars: {
-    #                 'OWNER_NAME' => invitation.owner_name,
-    #                 'INVITATION_URL' => new_invitation_url(email: invitation.email, secret: invitation.secret)
-    #               }
-    #
-    # Returns the the mandrill mailer class (this is so you can chain #deliver like a normal mailer)
-    def mandrill_mail(args)
-
-      # Mandrill requires template content to be there
-      args[:template_content] = {"blank" => ""} if args[:template_content].blank?
-
-      # format the :to param to what Mandrill expects if a string or array is passed
-      args[:to] = format_to_params(args[:to])
-
-      # Set the template name
-      self.template_name = args.delete(:template)
+    # Handle template mailer specifics before formating the given args
+    def mandrill_mail_handler(args)
+      # Mandrill requires template content to be there, set default value
+      args[:template_content] =  {"blank" => ""} if args[:template_content].blank?
 
       # Set the template content
-      self.template_content = mandrill_args(args.delete(:template_content))
-      self.async = args.delete(:async)
-      self.ip_pool = args.delete(:ip_pool)
-
-      if args.has_key?(:send_at)
-        self.send_at = args.delete(:send_at).getutc.strftime('%Y-%m-%d %H:%M:%S')
-      end
-
-      # Construct message hash
-      self.message = {
-        "subject" => args[:subject],
-        "from_email" => args[:from] || self.class.defaults[:from],
-        "from_name" => args[:from_name] || self.class.defaults[:from_name] || self.class.defaults[:from],
-        "to" => args[:to],
-        "headers" => args[:headers],
-        "important" => args[:important],
-        "track_opens" => args.fetch(:track_opens, true),
-        "track_clicks" => args.fetch(:track_clicks, true),
-        "auto_text" => true,
-        "inline_css" => args[:inline_css],
-        "url_strip_qs" => args.fetch(:url_strip_qs, true),
-        "preserve_recipients" => args[:preserve_recipients],
-        "bcc_address" => args[:bcc],
-        "merge_language" => args[:merge_language],
-        "global_merge_vars" => mandrill_args(args[:vars]),
-        "merge_vars" => mandrill_rcpt_args(args[:recipient_vars]),
-        "tags" => args[:tags],
-        "subaccount" => args[:subaccount],
-        "google_analytics_domains" => args[:google_analytics_domains],
-        "google_analytics_campaign" => args[:google_analytics_campaign],
-        "metadata" => args[:metadata],
-        "attachments" => mandrill_attachment_args(args[:attachments]),
-        "images" => mandrill_images_args(args[:images])
-      }
-      unless MandrillMailer.config.interceptor_params.nil?
-        unless MandrillMailer.config.interceptor_params.is_a?(Hash)
-          raise InvalidInterceptorParams.new "The interceptor_params config must be a Hash"
-        end
-        self.message.merge!(MandrillMailer.config.interceptor_params.stringify_keys)
-      end
-
-      # return self so we can chain deliver after the method call, like a normal mailer.
-      return self
-    end
+      self.template_content = MandrillMailer::ArgFormatter.mandrill_args(args.delete(:template_content))
 
-    # Public: Data hash (deprecated)
-    def data
-      {
-        "key" => api_key,
-        "template_name" => template_name,
-        "template_content" => template_content,
-        "message" => message,
-        "async" => async,
-        "ip_pool" => ip_pool,
-        "send_at" => send_at
-      }
+      # Set the template name
+      self.template_name = args.delete(:template)
     end
   end
 end

data/lib/mandrill_mailer/version.rb

@@ -1,3 +1,3 @@
 module MandrillMailer
-  VERSION = "0.6.1"
+  VERSION = "1.0.0"
 end

data/spec/arg_formatter_spec.rb

@@ -0,0 +1,236 @@
+require "spec_helper"
+require 'base64'
+
+describe MandrillMailer::ArgFormatter do
+  subject(:formatter) { described_class }
+  let(:api_args) do
+    {
+      type: "some/type",
+      name: 'test',
+      content: "testing some test test file"
+    }
+  end
+
+  let(:file_args) do
+    {
+      mimetype: "some/type",
+      filename: 'test',
+      file: "testing some test test file"
+    }
+  end
+
+
+  describe 'attachment_args' do
+    context "args are blank" do
+      it "returns nil" do
+        expect(formatter.attachment_args(nil)).to be_nil
+      end
+    end
+
+    context "with file syntax" do
+      it "formats the correct attachment data" do
+        expect(formatter.attachment_args([file_args])).to eq([{
+          'type' => "some/type",
+          'name' => 'test',
+          'content' => Base64.encode64("testing some test test file")
+        }])
+      end
+    end
+
+    context "with api syntax" do
+      it "formats the correct attachment data" do
+        expect(formatter.attachment_args([api_args])).to eq([{
+          'type' => "some/type",
+          'name' => 'test',
+          'content' => Base64.encode64("testing some test test file")
+        }])
+      end
+    end
+  end
+
+  describe ".images_args" do
+    context "args are blank" do
+      it "returns nil" do
+        expect(formatter.images_args(nil)).to be_nil
+      end
+    end
+
+    context "with file syntax" do
+      it "formats the correct attachment data" do
+        expect(formatter.images_args([file_args])).to eq([{
+          'type' => "some/type",
+          'name' => 'test',
+          'content' => Base64.encode64("testing some test test file")
+        }])
+      end
+    end
+
+    context "with api syntax" do
+      it "formats the correct attachment data" do
+        expect(formatter.images_args([api_args])).to eq([{
+          'type' => "some/type",
+          'name' => 'test',
+          'content' => Base64.encode64("testing some test test file")
+        }])
+      end
+    end
+  end
+
+  describe ".mandrill_args" do
+    context "args are blank" do
+      it "returns an empty array" do
+        expect(formatter.mandrill_args(nil)).to eq []
+      end
+    end
+
+    context "args are not blank" do
+      let(:arg_name) { 'USER_NAME' }
+      let(:arg_value) { 'bob' }
+
+      it 'should convert the args to the correct format' do
+        results = formatter.mandrill_args({arg_name => arg_value})
+        expect(results).to eq [{'name' => arg_name, 'content' => arg_value}]
+      end
+    end
+  end
+
+  describe ".merge_vars" do
+    context "args are blank" do
+      it "returns an empty array" do
+        expect(formatter.merge_vars(nil)).to eq []
+      end
+    end
+  end
+
+  describe ".rcpt_metadata" do
+    context "args are blank" do
+      it "returns an empty array" do
+        expect(formatter.rcpt_metadata(nil)).to eq []
+      end
+    end
+
+    context "args are not blank" do
+      let(:rcpt) { 'email@email.com' }
+      let(:arg_name) { 'USER_NAME' }
+      let(:arg_value) { 'bob' }
+
+      it 'should convert the args to the merge_vars format' do
+        results = formatter.merge_vars([{rcpt => {arg_name => arg_value}}])
+        expect(results).to eq [{'rcpt' => rcpt, 'vars' => [{'name' => arg_name, 'content' => arg_value}]}]
+      end
+    end
+  end
+
+  describe ".boolean" do
+    it "typecasts values to a boolean" do
+      expect(formatter.boolean(1)).to eq true
+      expect(formatter.boolean('1')).to eq true
+      expect(formatter.boolean(nil)).to eq false
+      expect(formatter.boolean(false)).to eq false
+      expect(formatter.boolean(true)).to eq true
+    end
+  end
+
+  describe ".params" do
+    let(:email) { 'bob@email.com' }
+    let(:name) { 'bob' }
+
+    context "item is not an array" do
+      it "returns an array" do
+        results = formatter.params("yay test")
+        expect(results).to be_kind_of Array
+      end
+
+      context 'with a single email string' do
+        it 'should format args to a format mandrill likes' do
+          results = formatter.params(email)
+          expect(results).to eq [{"email" => email, "name" => email}]
+        end
+      end
+
+      context 'with a single email/name Hash' do
+        it 'should format args to a format mandrill likes' do
+          results = formatter.params({"email" => email, "name" => name})
+          expect(results).to eq [{"email" => email, "name" => name}]
+        end
+      end
+    end
+
+
+    context "item is an array" do
+      it "returns an array" do
+        results = formatter.params(["yay test", "item2"])
+        expect(results).to be_kind_of Array
+      end
+
+      context 'with a single email string array' do
+        it 'should format args to a format mandrill likes' do
+          results = formatter.params([email])
+          expect(results).to eq [{"email" => email, "name" => email}]
+        end
+      end
+
+      context 'with a single email/name hash Array' do
+        it 'should format args to a format mandrill likes' do
+          results = formatter.params([{"email" => email, "name" => name}])
+          expect(results).to eq [{"email" => email, "name" => name}]
+        end
+      end
+    end
+  end
+
+  describe ".params_item" do
+    context "when item is a hash" do
+      it "returns the item" do
+        sample_hash = {"email" => "test@email.com", "name" => "test"}
+        expect(formatter.params_item(sample_hash)).to eq sample_hash
+      end
+    end
+
+    context "when item is not a hash" do
+      it "returns the correctly formatted hash" do
+        sample_email = "test@email.com"
+        expect(formatter.params_item(sample_email)).to eq({"email" => sample_email, "name" => sample_email})
+      end
+    end
+  end
+
+  describe ".format_messages_api_message_data" do
+    it "includes all api values" do
+      result = formatter.format_messages_api_message_data({})
+      api_values = ["html", "text", "subject", "from_email", "from_name", "to",
+                    "headers", "important", "track_opens", "track_clicks", "auto_text",
+                    "auto_html", "inline_css", "url_strip_qs", "preserve_recipients",
+                    "view_content_link", "bcc_address", "tracking_domain", "signing_domain",
+                    "return_path_domain", "merge", "merge_language", "global_merge_vars",
+                    "merge_vars", "tags", "subaccount", "google_analytics_domains",
+                    "google_analytics_campaign", "metadata", "recipient_metadata",
+                    "attachments", "images"]
+
+
+      api_values.each do |val|
+        expect(result.keys.include?(val)).to eq true
+      end
+    end
+
+    context "merge_language exists" do
+      context "merge_language is an accepted merge language" do
+        it "does not raise an error" do
+          expect { formatter.format_messages_api_message_data({merge_language: "handlebars"}) }.not_to raise_error
+        end
+      end
+
+      context "merge_language is not an accepted merge language" do
+        it "raises an error" do
+          expect { formatter.format_messages_api_message_data({merge_language: "not_valid"}) }.to raise_error(MandrillMailer::CoreMailer::InvalidMergeLanguageError)
+        end
+      end
+    end
+
+    context "merge_language does not exist" do
+      it "does not raise an error" do
+        expect { formatter.format_messages_api_message_data({}) }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/core_mailer_spec.rb

@@ -4,63 +4,319 @@ require 'base64'
 describe MandrillMailer::CoreMailer do
   subject(:core_mailer) { described_class }
 
-  let(:file_args) do
+  let(:image_path) { '/assets/image.jpg' }
+  let(:default_host) { 'localhost:3000' }
+  let(:mailer) { described_class.new }
+  let(:api_key) { '1237861278' }
+
+  let(:from_email) { 'from@email.com' }
+  let(:to_email) { 'bob@email.com' }
+  let(:to_name) { 'bob' }
+  let(:bcc) { "bcc@email.com" }
+  let(:var_name) { 'USER_NAME' }
+  let(:var_content) { 'bobert' }
+  let(:var_rcpt_name) { 'USER_INFO' }
+  let(:var_rcpt_content) { 'boboblacksheep' }
+
+  let(:attachment_file) { File.read(File.expand_path('spec/support/test_image.png')) }
+  let(:attachment_filename) { 'test_image.png' }
+  let(:attachment_mimetype) { 'image/png' }
+  let(:image_file) { File.read(File.expand_path('spec/support/test_image.png')) }
+  let(:image_filename) { 'test_image.png' }
+  let(:image_mimetype) { 'image/png' }
+  let(:send_at) { Time.utc(2020, 1, 1, 8, 0) }
+  let(:bcc) { "bcc@email.com" }
+
+  let(:async) { double(:async) }
+  let(:ip_pool) { double(:ip_pool) }
+
+  let(:args) do
     {
-      mimetype: "some/type",
-      filename: 'test',
-      file: "testing some test test file"
+      from: from_email,
+      subject: "super secret",
+      to: {'email' => to_email, 'name' => to_name},
+      preserve_recipients: false,
+      vars: {
+        var_name => var_content
+      },
+      recipient_vars: [
+        { to_email => { var_rcpt_name => var_rcpt_content } }
+      ],
+      headers: {"Reply-To" => "support@email.com"},
+      bcc: bcc,
+      tags: ['tag1'],
+      subaccount: "subaccount1",
+      google_analytics_domains: ["http://site.com"],
+      google_analytics_campaign: '1237423474',
+      attachments: [{file: attachment_file, filename: attachment_filename, mimetype: attachment_mimetype}],
+      images: [{file: image_file, filename: image_filename, mimetype: image_mimetype}],
+      inline_css: true,
+      important: true,
+      send_at: send_at,
+      async: async,
+      ip_pool: ip_pool,
+      track_opens: false,
+      track_clicks: false,
+      url_strip_qs: false
     }
   end
 
-  let(:api_args) do
+  let(:sample_message) do
     {
-      type: "some/type",
-      name: 'test',
-      content: "testing some test test file"
+      "from_email" => from_email,
+      "to" => [{'email' => to_email, 'name' => to_name}],
+      "bcc_address" => bcc,
     }
   end
 
+  before do
+    MandrillMailer.config.api_key = api_key
+    MandrillMailer.config.default_url_options = { host: default_host }
+    allow(MandrillMailer.config).to receive(:image_path).and_return(image_path)
+  end
+
+  describe "#mandrill_mail" do
+    it "applies interceptors to the message" do
+      expect(mailer).to receive(:apply_interceptors!)
+      mailer.mandrill_mail(args)
+    end
+
+    it "calls the mandrill_mail_handler" do
+      expect(mailer).to receive(:mandrill_mail_handler)
+      mailer.mandrill_mail(args)
+    end
+
+    it "sets the mailer message attribute" do
+      expect { mailer.mandrill_mail(args) }.to change { mailer.message }.from(nil)
+    end
+
+    it "extracts api_options" do
+      expect(mailer).to receive(:extract_api_options!).with(args)
+      mailer.mandrill_mail(args)
+    end
+
+    describe "vars attribute" do
+      it "returns the vars" do
+        mailer.mandrill_mail(args)
+        expect(mailer.message["global_merge_vars"].first.values).to include(var_name)
+        expect(mailer.message["global_merge_vars"].first.values).to include(var_content)
+      end
+
+      context "when no vars are set" do
+        before do
+          args.delete(:vars)
+        end
+
+        it "doesn't explode" do
+          expect { mailer.mandrill_mail(args) }.not_to raise_error
+        end
+      end
+    end
+  end
+
+  describe 'url helpers in mailer' do
+    subject { mailer.send(:course_url) }
+
+    context 'Rails is defined (Rails app)' do
+      let(:url) { '/courses/1' }
+      let(:host) { 'codeschool.com' }
+      let(:router) { Rails.application.routes.url_helpers }
+
+      before do
+        # use load since we are loading multiple times
+        mailer.send(:load, 'fake_rails/fake_rails.rb')
+        MandrillMailer.config.default_url_options[:host] = host
+        Rails.application.routes.draw do |builder|
+          builder.course_url "#{url}"
+        end
+      end
+
+      # Unrequire the fake rails class so it doesn't pollute the rest of the tests
+      after do
+        Rails.unload!
+      end
+
+      it 'should return the correct route' do
+        expect(subject).to eq router.course_url(host: host)
+      end
+
+      context 'route helper with an argument' do
+        it 'should return the correct route' do
+          expect(subject).to eq router.course_url({id: 1, title: 'zombies'}, host: host)
+        end
+      end
+    end
+
+    context 'Rails is not defined' do
+      it 'should raise an exception' do
+        expect{subject}.to raise_error
+      end
+    end
+  end
+
+  describe '#image_path' do
+    subject { mailer.image_path('logo.png') }
+
+    context 'Rails exists' do
+      let(:image) { 'image.png' }
+      let(:host) { 'codeschool.com' }
+      let(:router) { Rails.application.routes.url_helpers }
+
+      before do
+        # use load instead of require since we have to reload for every test
+        mailer.send(:load, 'fake_rails/fake_rails.rb')
+        MandrillMailer.config.default_url_options[:host] = host
+      end
+
+      # Essentially un-requiring the fake rails class so it doesn't pollute
+      # the rest of the tests
+      after do
+        Rails.unload!
+      end
+
+      it 'should return the image url' do
+        #mailer.send(:image_path, image).should eq ActionController::Base.asset_path(image)
+        expect(mailer.send(:image_path, image)).to eq(ActionController::Base.asset_path(image))
+      end
+    end
+
+    context 'Rails does not exist' do
+      it 'should raise exception' do
+        expect{ subject }.to raise_error
+      end
+    end
+  end
+
+  describe 'defaults' do
+    it 'should not share between different subclasses' do
+      klassA = Class.new(core_mailer) do
+        default from_name: 'ClassA'
+      end
+      klassB = Class.new(core_mailer) do
+        default from_name: 'ClassB'
+      end
+
+      expect(klassA.defaults[:from_name]).to eq 'ClassA'
+      expect(klassB.defaults[:from_name]).to eq 'ClassB'
+    end
 
-  describe 'protected#mandrill_attachment_args' do
-    context "with file syntax" do
-      it "formats the correct attachment data" do
-        expect(core_mailer.new.send(:mandrill_attachment_args, [file_args])).to eq([{
-          'type' => "some/type",
-          'name' => 'test',
-          'content' => Base64.encode64("testing some test test file")
-        }])
+    it 'should use defaults from the parent class' do
+      klassA = Class.new(core_mailer) do
+        default from_name: 'ClassA'
       end
+      klassB = Class.new(klassA) do
+      end
+
+      expect(klassB.defaults[:from_name]).to eq 'ClassA'
     end
 
-    context "with api syntax" do
-      it "formats the correct attachment data" do
-        expect(core_mailer.new.send(:mandrill_attachment_args, [api_args])).to eq([{
-          'type' => "some/type",
-          'name' => 'test',
-          'content' => Base64.encode64("testing some test test file")
-        }])
+    it 'should allow overriding defaults from the parent' do
+      klassA = Class.new(core_mailer) do
+        default from_name: 'ClassA'
+      end
+      klassB = Class.new(klassA) do
+        default from_name: 'ClassB'
       end
+
+      expect(klassB.defaults[:from_name]).to eq 'ClassB'
     end
   end
 
-  describe '#mandrill_images_args' do
-    context "with file syntax" do
-      it "formats the correct attachment data" do
-        expect(core_mailer.new.send(:mandrill_attachment_args, [file_args])).to eq([{
-          'type' => "some/type",
-          'name' => 'test',
-          'content' => Base64.encode64("testing some test test file")
-        }])
+  describe "accessor helpers" do
+    before do
+      allow(mailer).to receive(:message).and_return(sample_message)
+    end
+
+    describe "#from" do
+      it "returns the from email" do
+        expect(mailer.from).to eq from_email
       end
     end
 
-    context "with api syntax" do
-      it "formats the correct attachment data" do
-        expect(core_mailer.new.send(:mandrill_attachment_args, [api_args])).to eq([{
-          'type' => "some/type",
-          'name' => 'test',
-          'content' => Base64.encode64("testing some test test file")
-        }])
+    describe "#to" do
+      it "returns the to email data" do
+        expect(mailer.to).to eq sample_message['to']
+      end
+    end
+
+    describe '#to=' do
+      it "updates the to email data" do
+        sample_email = "something@email.com"
+        mailer.to = sample_email
+        expect(mailer.to).to eq [{"email" => sample_email, "name" => sample_email}]
+      end
+    end
+
+    describe "#bcc" do
+      it "returns the bcc email/s" do
+        expect(mailer.bcc).to eq bcc
+      end
+    end
+  end
+
+  describe '#respond_to' do
+    it 'can respond to a symbol' do
+      klassA = Class.new(core_mailer) do
+        def test_method
+
+        end
+      end
+
+      expect(klassA).to respond_to('test_method')
+    end
+    it 'can respond to a string' do
+      klassA = Class.new(core_mailer) do
+        def test_method
+
+        end
+      end
+
+      expect(klassA).to respond_to('test_method')
+    end
+  end
+
+  describe "protected#extract_api_options!" do
+    it "sets the required api options associated with the messages api" do
+      results = mailer.send(:extract_api_options!, args)
+      expect(mailer.send_at).to eq('2020-01-01 08:00:00')
+      expect(mailer.ip_pool).to eq ip_pool
+      expect(mailer.async).to eq async
+    end
+  end
+
+  describe "protected#apply_interceptors!" do
+    # Clear the interceptor after these tests so we don't get errors elsewhere
+    after do
+      MandrillMailer.config.interceptor = nil
+    end
+
+    context "when interceptor config is a proc" do
+      let(:original_email) { "blah@email.com" }
+      let(:interceptor_email) { "intercept@email.com" }
+
+      before do
+        MandrillMailer.config.interceptor = Proc.new {|obj|
+          obj[:to] = interceptor_email
+        }
+      end
+
+      it "Applies interceptors to object" do
+        obj = {to: original_email}
+        expect { mailer.send(:apply_interceptors!, obj)}.to change {obj[:to]}.from(original_email).to(interceptor_email)
+      end
+
+      it "does not raise error" do
+        expect { mailer.send(:apply_interceptors!, {}) }.not_to raise_error
+      end
+    end
+
+    context "when interceptor config is not a proc" do
+      before do
+        MandrillMailer.config.interceptor = "not a proc"
+      end
+
+      it "raises an error" do
+        expect { mailer.send(:apply_interceptors!, {}) }.to raise_error MandrillMailer::CoreMailer::InvalidInterceptorParams
       end
     end
   end