roadie-rails 1.0.0.pre1

data/spec/integration_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+require 'tempfile'
+require 'mail'
+
+describe "Integrations" do
+  def parse_html_in_email(mail)
+    Nokogiri::HTML.parse mail.html_part.body.decoded
+  end
+
+  [
+    RailsApp.new("Rails 3.0.x", 'rails_30', runner: :script, asset_pipeline: false),
+    ## We do not yet support live-compilation through asset pipeline
+    RailsApp.new("Rails 3.1.x", 'rails_31', runner: :script, asset_pipeline: true),
+    RailsApp.new("Rails 3.2.x", 'rails_32', runner: :script, asset_pipeline: true),
+    RailsApp.new("Rails 4.0.x", 'rails_40', runner: :bin, asset_pipeline: true),
+    RailsApp.new("Rails 4.0.x (without asset pipeline)", 'rails_40_no_pipeline', runner: :bin, asset_pipeline: false),
+    RailsApp.new("Rails 4.1.x", 'rails_41', runner: :bin, asset_pipeline: true),
+  ].each do |app|
+    describe "with #{app}" do
+      before { app.reset }
+
+      it "inlines styles for multipart emails" do
+        email = app.read_email(:normal_email)
+
+        expect(email.to).to eq(['example@example.org'])
+        expect(email.from).to eq(['john@example.com'])
+        expect(email).to have(2).parts
+
+        expect(email.text_part.body.decoded).not_to match(/<.*>/)
+
+        html = email.html_part.body.decoded
+        expect(html).to include '<!DOCTYPE'
+        expect(html).to include '<head'
+
+        document = parse_html_in_email(email)
+        expect(document).to have_selector('body h1')
+
+        if app.using_asset_pipeline?
+          expected_image_url = 'https://example.app.org/assets/rails.png'
+        else
+          expected_image_url = 'https://example.app.org/images/rails.png'
+        end
+        expect(document).to have_styling('background' => "url(#{expected_image_url})").at_selector('.image')
+
+        # If we deliver mails we can catch weird problems with headers being invalid
+        email.delivery_method :test
+        email.deliver
+      end
+
+      it "automatically inlines styles with automatic mailer" do
+        email = app.read_delivered_email(:normal_email)
+
+        expect(email.to).to eq(['example@example.org'])
+        expect(email.from).to eq(['john@example.com'])
+        expect(email).to have(2).parts
+
+        expect(email.text_part.body.decoded).not_to match(/<.*>/)
+
+        html = email.html_part.body.decoded
+        expect(html).to include '<!DOCTYPE'
+        expect(html).to include '<head'
+
+        document = parse_html_in_email(email)
+        expect(document).to have_selector('body h1')
+
+        if app.using_asset_pipeline?
+          expected_image_url = 'https://example.app.org/assets/rails.png'
+        else
+          expected_image_url = 'https://example.app.org/images/rails.png'
+        end
+        expect(document).to have_styling('background' => "url(#{expected_image_url})").at_selector('.image')
+
+        # If we deliver mails we can catch weird problems with headers being invalid
+        email.delivery_method :test
+        email.deliver
+      end
+
+      if app.using_asset_pipeline?
+        it "has a AssetPipelineProvider together with a FilesystemProvider" do
+          expect(app.read_providers).to eq(%w[Roadie::FilesystemProvider Roadie::Rails::AssetPipelineProvider])
+        end
+      else
+        it "only has a FilesystemProvider" do
+          expect(app.read_providers).to eq(["Roadie::FilesystemProvider"])
+        end
+      end
+    end
+  end
+
+  describe "with precompiled assets" do
+    let(:app) {
+      RailsApp.new("Rails 4.0.x (precompiled)", 'rails_40_precompiled', runner: :bin, asset_pipeline: false)
+    }
+
+    before { app.reset }
+
+    let(:document) do
+      parse_html_in_email app.read_email(:normal_email)
+    end
+
+    # It still has an AssetPipelineProvider in case some asset isn't
+    # precompiled, or the user want to combine. As long as the user is using
+    # the correct asset helpers a precompiled asset will be picked up by the
+    # FilesystemProvider.
+    it "has a AssetPipelineProvider together with a FilesystemProvider" do
+      expect(app.read_providers).to eq(%w[Roadie::FilesystemProvider Roadie::Rails::AssetPipelineProvider])
+    end
+
+    it "inlines the precompiled stylesheet" do
+      # Precompiled version has green color; the file in app/assets have red
+      expect(document).to have_styling('background-color' => 'green').at_selector('body')
+    end
+
+    it "inlines images with digests" do
+      image_url = "https://example.app.org/assets/rails-231a680f23887d9dd70710ea5efd3c62.png"
+      expect(document).to have_styling('background' => "url(#{image_url})").at_selector('.image')
+    end
+  end
+end

data/spec/lib/roadie/rails/asset_pipeline_provider_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'roadie/rspec'
+
+module Roadie
+  module Rails
+    describe AssetPipelineProvider do
+      let(:pipeline) { FakePipeline.new }
+
+      it_behaves_like "roadie asset provider", valid_name: "existing.css", invalid_name: "bad.css" do
+        subject { AssetPipelineProvider.new(pipeline) }
+        before do
+          pipeline.add_asset "existing.css", "existing.css", ""
+        end
+      end
+
+      describe "finding stylesheets" do
+        it "searches the asset pipeline" do
+          pipeline.add_asset "good.css", "/path/to/good.css.scss", "body { color: red; }"
+          provider = AssetPipelineProvider.new(pipeline)
+
+          stylesheet = provider.find_stylesheet("good.css")
+          expect(stylesheet.name).to eq("/path/to/good.css.scss (live compiled)")
+          expect(stylesheet.to_s).to eq("body{color:red}")
+        end
+
+        it "ignores query string and asset prefix" do
+          pipeline.add_asset "good.css", "good.css.scss", ""
+          provider = AssetPipelineProvider.new(pipeline)
+          expect(provider.find_stylesheet("/assets/good.css?body=1")).not_to be_nil
+        end
+      end
+
+      class FakePipeline
+        # Interface
+        def [](name)
+          @files.find { |file| file.matching_name == name }
+        end
+
+        # Test helpers
+        def initialize() @files = [] end
+        def add_asset(matching_name, path, content) @files << AssetFile.new(matching_name, path, content) end
+        private
+        AssetFile = Struct.new(:matching_name, :pathname, :to_s)
+      end
+    end
+  end
+end

data/spec/lib/roadie/rails/automatic_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'mail'
+
+module Roadie
+  module Rails
+    describe Automatic do
+      base_mailer = Class.new do
+        def initialize(email = nil)
+          @email = email
+        end
+
+        def mail(options = {})
+          @email
+        end
+      end
+
+      some_mailer = Class.new(base_mailer) do
+        include Automatic
+      end
+
+      describe "#roadie_options" do
+        it "returns Rails' roadie config" do
+          allow(::Rails).to receive_message_chain(:application, :config, :roadie).and_return "roadie config"
+          expect(some_mailer.new.roadie_options).to eq("roadie config")
+        end
+      end
+
+      describe "#mail" do
+        let(:email) { Mail.new(to: "foo@example.com", from: "me@example.com") }
+        let(:roadie_options) { Options.new(url_options: {host: "somehost.com"}) }
+        let(:instance) { some_mailer.new(email) }
+
+        before { allow(instance).to receive(:roadie_options).and_return roadie_options }
+
+        it "extends the email with InlineOnDelivery and assigns roadie options" do
+          email = instance.mail
+          expect(email).to be_kind_of(InlineOnDelivery)
+          expect(email.roadie_options).not_to be_nil
+          expect(email.roadie_options.url_options).to eq roadie_options.url_options
+        end
+      end
+    end
+  end
+end

data/spec/lib/roadie/rails/document_builder_spec.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+module Roadie
+  module Rails
+    describe DocumentBuilder do
+      it "builds documents with the given HTML" do
+        document = DocumentBuilder.build("foo", Options.new)
+        expect(document.html).to eq("foo")
+      end
+
+      it "applies the options to the document" do
+        options = Options.new
+        expect(options).to receive(:apply_to).with(instance_of Document).and_call_original
+
+        DocumentBuilder.build("", options)
+      end
+    end
+  end
+end

data/spec/lib/roadie/rails/mail_inliner_spec.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+require 'spec_helper'
+require 'mail'
+
+module Roadie
+  module Rails
+    describe MailInliner do
+      let(:email) { Mail.new }
+      let(:options) { Options.new }
+      subject(:inliner) { MailInliner.new(email, options) }
+
+      it "takes an email and options" do
+        inliner = MailInliner.new(email, options)
+        expect(inliner.email).to eq(email)
+        expect(inliner.options).to eq(options)
+      end
+
+      context "with an plaintext email" do
+        let(:email) do
+          Mail.new do
+            body "Hello world"
+          end
+        end
+
+        it "returns the email without doing anything" do
+          expect(inliner.execute).to eq(email)
+          expect(email.html_part).to be_nil
+          expect(email.body.decoded).to eq("Hello world")
+        end
+      end
+
+      context "with an multipart email" do
+        let(:html) { "<h1>Hello world!</h1>" }
+        let(:email) do
+          html_string = html
+          Mail.new do
+            text_part { body "Hello world" }
+            html_part { body html_string }
+          end
+        end
+
+        it "returns the email" do
+          expect(inliner.execute).to eq(email)
+        end
+
+        it "adjusts the html part using Roadie" do
+          document = double "A document", transform: "transformed HTML"
+          expect(DocumentBuilder).to receive(:build).with(html, instance_of(Options)).and_return document
+
+          inliner.execute
+
+          expect(email.html_part.body.decoded).to eq("transformed HTML")
+        end
+      end
+    end
+  end
+end

data/spec/lib/roadie/rails/mailer_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'mail'
+
+module Roadie
+  module Rails
+    describe Mailer do
+      some_mailer = Class.new do
+        include Mailer
+
+        def initialize(email = nil)
+          @email = email
+        end
+
+        def mail(options = {})
+          @email
+        end
+      end
+
+      describe "#roadie_options" do
+        it "returns Rails' roadie config" do
+          allow(::Rails).to receive_message_chain(:application, :config, :roadie).and_return "roadie config"
+          expect(some_mailer.new.roadie_options).to eq("roadie config")
+        end
+      end
+
+      describe "#roadie_mail" do
+        let(:email) { Mail.new }
+        let(:instance) { some_mailer.new(email) }
+
+        before { allow(instance).to receive(:roadie_options).and_return(Options.new) }
+
+        before do
+          inliner = double "Mail inliner"
+          allow(inliner).to receive(:execute) { |email| email }
+          allow(MailInliner).to receive(:new).and_return(inliner)
+        end
+
+        it "calls the original mail method with all options and the block" do
+          expect(instance).to receive(:mail) do |options, &block|
+            expect(options).to eq({some: "option"})
+            expect(block).not_to be_nil
+            email
+          end
+
+          instance.roadie_mail(some: "option") { }
+        end
+
+        it "inlines the email" do
+          inliner = double "Inliner"
+          expect(MailInliner).to receive(:new).with(email, instance_of(Options)).and_return inliner
+          expect(inliner).to receive(:execute).and_return "inlined email"
+          expect(instance.roadie_mail).to eq("inlined email")
+        end
+      end
+    end
+  end
+end

data/spec/lib/roadie/rails/options_spec.rb

@@ -0,0 +1,136 @@
+# encoding: UTF-8
+require 'spec_helper'
+require 'ostruct'
+
+module Roadie
+  module Rails
+    describe Options do
+      it "raises errors when constructed with unknown options" do
+        expect {
+          Options.new(unknown_option: "maybe a misspelling?")
+        }.to raise_error(ArgumentError, /unknown_option/)
+      end
+
+      shared_examples_for "attribute" do |name|
+        describe name do
+          it "defaults to nil" do
+            expect(Options.new.send(name)).to be_nil
+          end
+
+          it "can be set in the constructor" do
+            expect(Options.new(name => valid_value).send(name)).to eq(valid_value)
+          end
+
+          it "can be changed using setter" do
+            options = Options.new
+            options.send :"#{name}=", valid_value
+            expect(options.send(name)).to eq(valid_value)
+          end
+
+          it "can be applied to documents" do
+            fake_document = OpenStruct.new
+            options = Options.new(name => valid_value)
+            options.apply_to(fake_document)
+            expect(fake_document.send(name)).to eq(valid_value)
+          end
+
+          describe "merging" do
+            it "replaces values" do
+              options = Options.new(name => valid_value)
+              expect(options.merge(name => other_valid_value).send(name)).to eq(other_valid_value)
+            end
+
+            it "does not mutate instance" do
+              options = Options.new(name => valid_value)
+              options.merge(name => other_valid_value)
+              expect(options.send(name)).to eq(valid_value)
+            end
+          end
+
+          describe "destructive merging" do
+            it "replaces values" do
+              options = Options.new(name => valid_value)
+              expect(options.merge(name => other_valid_value).send(name)).to eq(other_valid_value)
+            end
+          end
+
+          describe "combining" do
+            it "combines the old and the new value" do
+              options = Options.new(name => valid_value)
+              combined = options.combine(name => other_valid_value)
+              expect_combinated_value combined.send(name)
+            end
+
+            it "does not mutate instance" do
+              options = Options.new(name => valid_value)
+              options.combine(name => other_valid_value)
+              expect(options.send(name)).to eq(valid_value)
+            end
+          end
+
+          describe "destructive combining" do
+            it "combines the old and the new value in the instance" do
+              options = Options.new(name => valid_value)
+              options.combine!(name => other_valid_value)
+              expect_combinated_value options.send(name)
+            end
+          end
+        end
+      end
+
+      it_behaves_like "attribute", :url_options do
+        let(:valid_value) { {host: "foo.com", port: 3000} }
+        let(:other_valid_value) { {host: "bar.com", scheme: "https"} }
+
+        def expect_combinated_value(value)
+          expect(value).to eq({host: "bar.com", port: 3000, scheme: "https"})
+        end
+      end
+
+      it_behaves_like "attribute", :before_transformation do
+        let(:valid_value) { Proc.new { } }
+        let(:other_valid_value) { Proc.new { } }
+
+        def expect_combinated_value(value)
+          expect(valid_value).to receive(:call).ordered.and_return 1
+          expect(other_valid_value).to receive(:call).ordered.and_return 2
+
+          expect(value.call).to eq(2)
+        end
+      end
+
+      it_behaves_like "attribute", :after_transformation do
+        let(:valid_value) { Proc.new { } }
+        let(:other_valid_value) { Proc.new { } }
+
+        def expect_combinated_value(value)
+          expect(valid_value).to receive(:call).ordered.and_return 1
+          expect(other_valid_value).to receive(:call).ordered.and_return 2
+          expect(value.call).to eq(2)
+        end
+      end
+
+      it_behaves_like "attribute", :asset_providers do
+        let(:provider1) { double "Asset provider 1" }
+        let(:provider2) { double "Asset provider 2" }
+
+        let(:valid_value) { ProviderList.new([provider1]) }
+        let(:other_valid_value) { ProviderList.new([provider2]) }
+
+        def expect_combinated_value(value)
+          expect(value).to be_instance_of(ProviderList)
+          expect(value.to_a).to eq([provider1, provider2])
+        end
+      end
+
+      describe "asset_providers" do
+        it "automatically wraps values in a ProviderList" do
+          provider = double "Asset provider"
+          options = Options.new(asset_providers: [provider])
+          expect(options.asset_providers).to be_instance_of(ProviderList)
+          expect(options.asset_providers.to_a).to eq([provider])
+        end
+      end
+    end
+  end
+end