send_grid_mailer 0.5.0 → 2.0.0

data/spec/dummy/spec/mailers/test_mailer_spec.rb

@@ -1,423 +1,654 @@
 require "rails_helper"
 
 describe TestMailer do
-  before do
-    allow(TestMailer).to receive(:delivery_method).and_return(:sendgrid)
-    allow_any_instance_of(SendGridMailer::Deliverer).to receive(:api_key).and_return("XXX")
+  let(:error_code) { "404" }
+  let(:success_code) { "200" }
+
+  def expect_sg_api_errors(errors)
+    error_messages = errors.map { |err| err['message'] }.join('. ')
+    message = "Sendgrid API error. Code: #{error_code}. Errors: #{error_messages}"
+    expect { deliver }.to raise_error(SendGridMailer::ApiError, message) do |e|
+      expect(e.error_code).to eq(error_code.to_i)
+      expect(e.errors).to eq(errors)
+    end
+  end
+
+  def expect_valid_sg_api_send_mail_request(request_body)
+    expect_sg_api_send_mail_request(success_code, request_body)
+    deliver
+  end
+
+  def expect_invalid_sg_api_send_mail_request(request_body, errors)
+    result = { errors: errors }.to_json
+    expect_sg_api_send_mail_request(error_code, request_body, result)
+    expect_sg_api_errors(errors)
   end
 
-  def expect_valid_mail_sent(request_body)
-    result = double(status_code: "202")
+  def expect_sg_api_send_mail_request(status_code, request_body, result = nil)
+    result = double(status_code: status_code, body: result)
     client2 = double(post: result)
     client1 = double(_: client2)
     expect_any_instance_of(SendGrid::Client).to receive(:_).with(:mail).and_return(client1)
     expect(client2).to receive(:post).with(request_body: request_body).and_return(result)
-    deliver
   end
 
-  context "setting body" do
-    let(:deliver) { described_class.body_email.deliver_now! }
+  def expect_valid_sg_api_get_template_request(response)
+    expect_sg_api_get_template_request(success_code, response)
+    deliver
+  end
 
-    it "sends mail with valid body" do
-      request_body = {
-        "from" =>
-          {
-            "email" => "default-sender@platan.us"
-          },
-        "personalizations" => [
-          {
-            "subject" => "Body email"
-          }
-        ],
-        "content" => [
-          {
-            "type" => "text/plain",
-            "value" => "Body"
-          }
-        ]
-      }
+  def expect_invalid_sg_api_get_template_request(errors)
+    result = { errors: errors }.to_json
+    expect_sg_api_get_template_request(error_code, result)
+    expect_sg_api_errors(errors)
+  end
 
-      expect_valid_mail_sent(request_body)
-    end
+  def expect_sg_api_get_template_request(status_code, result = nil)
+    result = double(status_code: status_code, body: result)
+    client2 = double(post: result)
+    client1 = double(_: client2)
+    expect_any_instance_of(SendGrid::Client).to receive(:_).with(:templates).and_return(client1)
+    expect(client2).to receive(:get).and_return(result)
   end
 
-  context "setting body from params" do
-    let(:deliver) { described_class.body_params_email.deliver_now! }
+  context "when setting delivery_method to :sendgrid" do
+    before { allow(TestMailer).to receive(:delivery_method).and_return(:sendgrid) }
 
-    it "sends mail with valid body" do
-      request_body = {
-        "from" =>
-          {
-            "email" => "default-sender@platan.us"
-          },
-        "personalizations" => [
-          {
-            "subject" => "Body params email"
-          }
-        ],
-        "content" => [
-          {
-            "type" => "text/html",
-            "value" => "<h1>Body Params</h1>"
+    context "with valid API key" do
+      before { allow_any_instance_of(SendGridMailer::Deliverer).to receive(:api_key).and_return("X") }
+
+      context "with unsuccessful response" do
+        let(:deliver) { described_class.body_email.deliver_now! }
+
+        it "doesn't send mail" do
+          request_body = {
+            "from" =>
+              {
+                "email" => "default-sender@platan.us"
+              },
+            "personalizations" => [
+              {
+                "subject" => "Body email"
+              }
+            ],
+            "content" => [
+              {
+                "type" => "text/plain",
+                "value" => "Body"
+              }
+            ]
           }
-        ]
-      }
 
-      expect_valid_mail_sent(request_body)
-    end
-  end
+          errors = [
+            {
+              'field' => 'from.email',
+              'message' => 'The from email does not...'
+            },
+            {
+              'field' => 'personalizations.0.to',
+              'message' => 'The to array is required...'
+            }
+          ]
+
+          expect_invalid_sg_api_send_mail_request(request_body, errors)
+        end
+      end
 
-  context "setting body from rails template" do
-    let(:deliver) { described_class.rails_tpl_email.deliver_now! }
+      context "when setting body" do
+        let(:deliver) { described_class.body_email.deliver_now! }
 
-    it "sends mail with valid body" do
-      request_body = {
-        "from" =>
-          {
-            "email" => "default-sender@platan.us"
-          },
-        "personalizations" => [
-          {
-            "subject" => "Rails tpl email"
-          }
-        ],
-        "content" => [
-          {
-            "type" => "text/html",
-            "value" => "<html>\n  <body>\n    Rails Template!\n\n  </body>\n</html>\n"
+        it "sends mail with valid body" do
+          request_body = {
+            "from" =>
+              {
+                "email" => "default-sender@platan.us"
+              },
+            "personalizations" => [
+              {
+                "subject" => "Body email"
+              }
+            ],
+            "content" => [
+              {
+                "type" => "text/plain",
+                "value" => "Body"
+              }
+            ]
           }
-        ]
-      }
 
-      expect_valid_mail_sent(request_body)
-    end
-  end
+          expect_valid_sg_api_send_mail_request(request_body)
+        end
+      end
 
-  context "overriding default from" do
-    let(:request_body) do
-      {
-        "from" =>
-          {
-            "email" => "override@platan.us"
-          },
-        "personalizations" => [
-          {
-            "subject" => subject
-          }
-        ],
-        "content" => [
-          {
-            "type" => "text/plain",
-            "value" => "X"
-          }
-        ]
-      }
-    end
+      context "when setting body from params" do
+        let(:deliver) { described_class.body_params_email.deliver_now! }
 
-    context "using params" do
-      let(:deliver) { described_class.from_params_email.deliver_now! }
-      let(:subject) { "From params email" }
+        it "sends mail with valid body" do
+          request_body = {
+            "from" =>
+              {
+                "email" => "default-sender@platan.us"
+              },
+            "personalizations" => [
+              {
+                "subject" => "Body params email"
+              }
+            ],
+            "content" => [
+              {
+                "type" => "text/html",
+                "value" => "<h1>Body Params</h1>"
+              }
+            ]
+          }
 
-      it "sends mail with valid sender" do
-        expect_valid_mail_sent(request_body)
+          expect_valid_sg_api_send_mail_request(request_body)
+        end
       end
-    end
 
-    context "using methods" do
-      let(:deliver) { described_class.from_email.deliver_now! }
-      let(:subject) { "From email" }
+      context "when setting body from rails template" do
+        let(:deliver) { described_class.rails_tpl_email.deliver_now! }
 
-      it "sends mail with valid sender" do
-        expect_valid_mail_sent(request_body)
+        it "sends mail with valid body" do
+          request_body = {
+            "from" =>
+              {
+                "email" => "default-sender@platan.us"
+              },
+            "personalizations" => [
+              {
+                "subject" => "Rails tpl email"
+              }
+            ],
+            "content" => [
+              {
+                "type" => "text/html",
+                "value" => "<html>\n  <body>\n    Rails Template!\n\n  </body>\n</html>\n"
+              }
+            ]
+          }
+
+          expect_valid_sg_api_send_mail_request(request_body)
+        end
       end
-    end
-  end
 
-  context "setting recipients" do
-    let(:request_body) do
-      {
-        "from" =>
+      context "when overriding default from" do
+        let(:request_body) do
           {
-            "email" => "default-sender@platan.us"
-          },
-        "personalizations" => [
-          {
-            "to" => [
+            "from" =>
               {
-                "email" => "r1@platan.us"
+                "email" => "override@platan.us"
               },
+            "personalizations" => [
               {
-                "email" => "r2@platan.us"
+                "subject" => subject
               }
             ],
-            "cc" => [
+            "content" => [
               {
-                "email" => "r4@platan.us"
+                "type" => "text/plain",
+                "value" => "X"
               }
-            ],
-            "bcc" => [
+            ]
+          }
+        end
+
+        context "when using params" do
+          let(:deliver) { described_class.from_params_email.deliver_now! }
+          let(:subject) { "From params email" }
+
+          it "sends mail with valid sender" do
+            expect_valid_sg_api_send_mail_request(request_body)
+          end
+        end
+
+        context "when using methods" do
+          let(:deliver) { described_class.from_email.deliver_now! }
+          let(:subject) { "From email" }
+
+          it "sends mail with valid sender" do
+            expect_valid_sg_api_send_mail_request(request_body)
+          end
+        end
+      end
+
+      context "with setting recipients" do
+        let(:request_body) do
+          {
+            "from" =>
+              {
+                "email" => "default-sender@platan.us"
+              },
+            "personalizations" => [
               {
-                "email" => "r5@platan.us"
+                "to" => [
+                  {
+                    "email" => "r1@platan.us"
+                  },
+                  {
+                    "email" => "r2@platan.us"
+                  }
+                ],
+                "cc" => [
+                  {
+                    "email" => "r4@platan.us"
+                  }
+                ],
+                "bcc" => [
+                  {
+                    "email" => "r5@platan.us"
+                  }
+                ],
+                "subject" => subject
               }
             ],
-            "subject" => subject
-          }
-        ],
-        "content" => [
-          {
-            "type" => "text/plain",
-            "value" => "X"
+            "content" => [
+              {
+                "type" => "text/plain",
+                "value" => "X"
+              }
+            ]
           }
-        ]
-      }
-    end
+        end
 
-    context "using params" do
-      let(:deliver) { described_class.recipients_params_email.deliver_now! }
-      let(:subject) { "Recipients params email" }
+        context "when using params" do
+          let(:deliver) { described_class.recipients_params_email.deliver_now! }
+          let(:subject) { "Recipients params email" }
 
-      it "sends mail with valid recipients" do
-        expect_valid_mail_sent(request_body)
-      end
-    end
+          it "sends mail with valid recipients" do
+            expect_valid_sg_api_send_mail_request(request_body)
+          end
+        end
 
-    context "using methods" do
-      let(:deliver) { described_class.recipients_email.deliver_now! }
-      let(:subject) { "Recipients email" }
+        context "when using methods" do
+          let(:deliver) { described_class.recipients_email.deliver_now! }
+          let(:subject) { "Recipients email" }
 
-      it "sends mail with valid recipients" do
-        expect_valid_mail_sent(request_body)
+          it "sends mail with valid recipients" do
+            expect_valid_sg_api_send_mail_request(request_body)
+          end
+        end
       end
-    end
-  end
 
-  context "setting template id" do
-    let(:request_body) do
-      {
-        "from" =>
-          {
-            "email" => "default-sender@platan.us"
-          },
-        "personalizations" => [
+      context "when setting template id" do
+        let(:request_body) do
           {
-            "subject" => subject
+            "from" =>
+              {
+                "email" => "default-sender@platan.us"
+              },
+            "personalizations" => [
+              {
+                "subject" => subject
+              }
+            ],
+            "template_id" => "XXX"
           }
-        ],
-        "template_id" => "XXX"
-      }
-    end
+        end
 
-    context "using params" do
-      let(:deliver) { described_class.template_id_params_email.deliver_now! }
-      let(:subject) { "Template id params email" }
+        context "when using params" do
+          let(:deliver) { described_class.template_id_params_email.deliver_now! }
+          let(:subject) { "Template id params email" }
 
-      it "sends mail with valid template" do
-        expect_valid_mail_sent(request_body)
-      end
-    end
+          it "sends mail with valid template" do
+            expect_valid_sg_api_send_mail_request(request_body)
+          end
+        end
 
-    context "using methods" do
-      let(:deliver) { described_class.template_id_email.deliver_now! }
-      let(:subject) { "Template id email" }
+        context "when using methods" do
+          let(:deliver) { described_class.template_id_email.deliver_now! }
+          let(:subject) { "Template id email" }
 
-      it "sends mail with valid template id" do
-        expect_valid_mail_sent(request_body)
+          it "sends mail with valid template id" do
+            expect_valid_sg_api_send_mail_request(request_body)
+          end
+        end
       end
-    end
-  end
 
-  context "setting subject" do
-    let(:request_body) do
-      {
-        "from" =>
+      context "when setting subject" do
+        let(:request_body) do
           {
-            "email" => "default-sender@platan.us"
-          },
-        "personalizations" => [
-          {
-            "subject" => "My Subject"
-          }
-        ],
-        "content" => [
-          {
-            "type" => "text/plain",
-            "value" => "X"
+            "from" =>
+              {
+                "email" => "default-sender@platan.us"
+              },
+            "personalizations" => [
+              {
+                "subject" => "My Subject"
+              }
+            ],
+            "content" => [
+              {
+                "type" => "text/plain",
+                "value" => "X"
+              }
+            ]
           }
-        ]
-      }
-    end
+        end
 
-    context "using params" do
-      let(:deliver) { described_class.subject_params_email.deliver_now! }
+        context "when using params" do
+          let(:deliver) { described_class.subject_params_email.deliver_now! }
 
-      it "sends mail with valid subject" do
-        expect_valid_mail_sent(request_body)
-      end
-    end
+          it "sends mail with valid subject" do
+            expect_valid_sg_api_send_mail_request(request_body)
+          end
+        end
 
-    context "using methods" do
-      let(:deliver) { described_class.subject_email.deliver_now! }
+        context "when using methods" do
+          let(:deliver) { described_class.subject_email.deliver_now! }
 
-      it "sends mail with valid subject" do
-        expect_valid_mail_sent(request_body)
+          it "sends mail with valid subject" do
+            expect_valid_sg_api_send_mail_request(request_body)
+          end
+        end
       end
-    end
-  end
 
-  context "setting headers" do
-    let(:request_body) do
-      {
-        "from" =>
+      context "when setting headers" do
+        let(:request_body) do
           {
-            "email" => "default-sender@platan.us"
-          },
-        "personalizations" => [
-          {
-            "subject" => subject,
-            "headers" =>
+            "from" =>
+              {
+                "email" => "default-sender@platan.us"
+              },
+            "personalizations" => [
               {
-                "HEADER-1" => "VALUE-1",
-                "HEADER-2" => "VALUE-2"
+                "subject" => subject,
+                "headers" =>
+                  {
+                    "HEADER-1" => "VALUE-1",
+                    "HEADER-2" => "VALUE-2"
+                  }
               }
+            ],
+            "content" => [
+              {
+                "type" => "text/plain",
+                "value" => "X"
+              }
+            ]
           }
-        ],
-        "content" => [
-          {
-            "type" => "text/plain",
-            "value" => "X"
-          }
-        ]
-      }
-    end
+        end
 
-    context "using params" do
-      let(:deliver) { described_class.headers_params_email.deliver_now! }
-      let(:subject) { "Headers params email" }
+        context "when using params" do
+          let(:deliver) { described_class.headers_params_email.deliver_now! }
+          let(:subject) { "Headers params email" }
 
-      it "sends mail with valid headers" do
-        expect_valid_mail_sent(request_body)
-      end
-    end
+          it "sends mail with valid headers" do
+            expect_valid_sg_api_send_mail_request(request_body)
+          end
+        end
 
-    context "using methods" do
-      let(:deliver) { described_class.headers_email.deliver_now! }
-      let(:subject) { "Headers email" }
+        context "when using methods" do
+          let(:deliver) { described_class.headers_email.deliver_now! }
+          let(:subject) { "Headers email" }
 
-      it "sends mail with valid headers" do
-        expect_valid_mail_sent(request_body)
+          it "sends mail with valid headers" do
+            expect_valid_sg_api_send_mail_request(request_body)
+          end
+        end
       end
-    end
-  end
 
-  context "adding attachments" do
-    let(:deliver) { described_class.add_attachments_email.deliver_now! }
+      context "when adding attachments" do
+        let(:deliver) { described_class.add_attachments_email.deliver_now! }
 
-    it "sends mail with valid body" do
-      expect_any_instance_of(SendGrid::Attachment).to receive(:content).and_return("X")
-      expect_any_instance_of(SendGrid::Attachment).to receive(:content_id).and_return("A")
+        it "sends mail with valid body" do
+          expect_any_instance_of(SendGrid::Attachment).to receive(:content).and_return("X")
+          expect_any_instance_of(SendGrid::Attachment).to receive(:content_id).and_return("A")
 
-      request_body = {
-        "from" =>
-          {
-            "email" => "default-sender@platan.us"
-          },
-        "personalizations" => [
-          {
-            "subject" => "Add attachments email"
-          }
-        ],
-        "content" => [
-          {
-            "type" => "text/plain",
-            "value" => "X"
-          }
-        ],
-        "attachments" => [
-          {
-            "content" => "X",
-            "type" => "image/png",
-            "filename" => "nana.png",
-            "disposition" => "attachment",
-            "content_id" => "A"
+          request_body = {
+            "from" =>
+              {
+                "email" => "default-sender@platan.us"
+              },
+            "personalizations" => [
+              {
+                "subject" => "Add attachments email"
+              }
+            ],
+            "content" => [
+              {
+                "type" => "text/plain",
+                "value" => "X"
+              }
+            ],
+            "attachments" => [
+              {
+                "content" => "X",
+                "type" => "image/png",
+                "filename" => "nana.png",
+                "disposition" => "attachment",
+                "content_id" => "A"
+              }
+            ]
           }
-        ]
-      }
 
-      expect_valid_mail_sent(request_body)
-    end
-  end
+          expect_valid_sg_api_send_mail_request(request_body)
+        end
+      end
 
-  context "adding substitutions" do
-    let(:deliver) { described_class.substitutions_email.deliver_now! }
+      context "when adding substitutions" do
+        let(:deliver) { described_class.substitutions_email.deliver_now! }
 
-    it "sends mail with valid body" do
-      request_body = {
-        "from" =>
-          {
-            "email" => "default-sender@platan.us"
-          },
-        "personalizations" => [
-          {
-            "subject" => "Substitutions email",
-            "substitutions" =>
+        it "sends mail with valid body" do
+          request_body = {
+            "from" =>
+              {
+                "email" => "default-sender@platan.us"
+              },
+            "personalizations" => [
               {
-                "%key1%" => "value1",
-                "%key2%" => "value2"
+                "subject" => "Substitutions email",
+                "substitutions" =>
+                  {
+                    "%key1%" => "value1",
+                    "%key2%" => "value2"
+                  }
               }
+            ],
+            "content" => [
+              {
+                "type" => "text/plain",
+                "value" => "X"
+              }
+            ]
           }
-        ],
-        "content" => [
+
+          expect_valid_sg_api_send_mail_request(request_body)
+        end
+      end
+
+      context "when working with recipient interceptor" do
+        let(:interceptor) { double(:interceptor, class: "RecipientInterceptor") }
+        let(:deliver) { described_class.recipients_email.deliver_now! }
+        let(:request_body) do
           {
-            "type" => "text/plain",
-            "value" => "X"
+            "from" =>
+              {
+                "email" => "default-sender@platan.us"
+              },
+            "personalizations" => [
+              {
+                "to" => [
+                  { "email" => "interceptor1@platan.us" },
+                  { "email" => "interceptor2@platan.us" }
+                ],
+                "subject" => "[STAGING] Recipients email",
+                "headers" =>
+                  {
+                    "X-Intercepted-To" => "r1@platan.us, r2@platan.us",
+                    "X-Intercepted-Cc" => "r4@platan.us",
+                    "X-Intercepted-Bcc" => "r5@platan.us"
+                  }
+              }
+            ],
+            "content" => [
+              {
+                "type" => "text/plain",
+                "value" => "X"
+              }
+            ]
           }
-        ]
-      }
-
-      expect_valid_mail_sent(request_body)
+        end
+
+        before do
+          allow(interceptor).to receive(:instance_variable_get)
+            .with(:@recipients).and_return(["interceptor1@platan.us", "interceptor2@platan.us"])
+          allow(interceptor).to receive(:instance_variable_get)
+            .with(:@subject_prefix).and_return("[STAGING]")
+          allow(Mail).to receive(:class_variable_get)
+            .with(:@@delivery_interceptors).and_return([interceptor])
+        end
+
+        it "sends mail with valid recipients" do
+          expect_valid_sg_api_send_mail_request(request_body)
+        end
+      end
     end
-  end
 
-  def get_templates(status_code, response = nil)
-    result = double(status_code: status_code, body: response)
-    client = double(get: result)
-    expect_any_instance_of(SendGrid::Client).to receive(:_).with(:templates).and_return(client)
-  end
+    context "with invalid API key" do
+      let(:deliver) { described_class.body_email.deliver_now! }
 
-  context "setting template name" do
-    let(:deliver) { described_class.template_name_email.deliver_now! }
+      before do
+        allow_any_instance_of(SendGridMailer::Deliverer).to receive(:api_key).and_return(nil)
+      end
 
-    it "sends mail with valid template id" do
-      response = { templates: [{ id: "123", name: "my template name" }] }.to_json
-      get_templates("200", response)
+      it { expect { deliver }.to raise_error(SendGridMailer::InvalidApiKey) }
+    end
+  end
 
-      request_body = {
-        "from" =>
-          {
-            "email" => "default-sender@platan.us"
-          },
-        "personalizations" => [
-          {
-            "subject" => "Template name email"
-          }
-        ],
-        "template_id" => "123"
-      }
+  context "when setting delivery_method to :sendgrid_dev" do
+    before { allow(TestMailer).to receive(:delivery_method).and_return(:sendgrid_dev) }
 
-      expect_valid_mail_sent(request_body)
-    end
+    context "with valid API key" do
+      before do
+        allow_any_instance_of(SendGridMailer::DevDeliverer).to receive(:api_key).and_return("X")
+      end
 
-    it "raises error when templates endpoint is down" do
-      get_templates("500")
-      expect { deliver }.to raise_error(SendGridMailer::Exception,
-        "Error trying to get templates. Status Code: 500")
-    end
+      context "with unsuccessful response" do
+        let(:sub) { 'value' }
+        let(:deliver) { described_class.template_with_substitutions_email(sub).deliver_now! }
+
+        it "raises sendgrid mailer error" do
+          errors = [
+            {
+              'field' => 'from.email',
+              'message' => 'The from email does not...'
+            },
+            {
+              'field' => 'personalizations.0.to',
+              'message' => 'The to array is required...'
+            }
+          ]
+          expect_invalid_sg_api_get_template_request(errors)
+        end
+      end
 
-    it "raises error when template name does not match with server response" do
-      response = { templates: [{ id: "123", name: "other template" }] }.to_json
-      get_templates("200", response)
-      expect { deliver }.to raise_error(SendGridMailer::Exception,
-        "No template with name my template name")
+      context "with succesful response" do
+        let(:lo) { double(deliver!: nil) }
+
+        before { allow(LetterOpener::DeliveryMethod).to receive(:new).and_return(lo) }
+
+        context 'when there are no versions but there is a rails template' do
+          let(:response) { {}.to_json }
+          let(:deliver) { described_class.rails_tpl_email.deliver_now! }
+          let(:content) do
+            "<html>\r\n  <body>\r\n    Rails Template!\r\n\r\n  </body>\r\n</html>\r\n"
+          end
+          let(:request_body) do
+            {
+              "from" =>
+                {
+                  "email" => "default-sender@platan.us"
+                },
+              "personalizations" => [
+                {
+                  "subject" => "Rails tpl email"
+                }
+              ],
+              "content" => [
+                {
+                  "type" => "text/html",
+                  "value" => content
+                }
+              ]
+            }
+          end
+
+          it "calls letter_opener with template content as html_part" do
+            expect_valid_sg_api_get_template_request(response)
+            expect(lo).to have_received(:deliver!) do |arg|
+              expect(arg.html_part.to_s).to include(content)
+            end
+          end
+        end
+
+        context 'when there are template versions' do
+          context "when using substitutions" do
+            let(:sub) { 'value' }
+            let(:deliver) { described_class.template_with_substitutions_email(sub).deliver_now! }
+            let(:response) do
+              {
+                versions: [
+                  {
+                    active: 1,
+                    html_content: active_template
+                  },
+                  {
+                    active: 0,
+                    html_content: ''
+                  }
+                ]
+              }.to_json
+            end
+
+            def active_template(sub = "%key%")
+              "<h1>Active version</h1>"\
+              "<span>This should be replaced: #{sub}</span>"\
+              "<span>This should not be replaced: %key2%</span>"
+            end
+
+            it "gets templates from sendgrid api, applies substitutions to active one and "\
+               "uses LetterOpener to deliver it" do
+              expect_valid_sg_api_get_template_request(response)
+              expect(lo).to have_received(:deliver!) do |arg|
+                expect(arg.html_part.to_s).to include(active_template(sub))
+              end
+            end
+          end
+
+          context "when using dynamic templates" do
+            let(:data) { 'value' }
+            let(:deliver) { described_class.dynamic_template_email(data).deliver_now! }
+            let(:response) do
+              {
+                versions: [
+                  {
+                    active: 1,
+                    html_content: active_dynamic_template
+                  },
+                  {
+                    active: 0,
+                    html_content: ''
+                  }
+                ]
+              }.to_json
+            end
+
+            def active_dynamic_template(data = "{{key}}")
+              "<h1>Active dynamic version</h1>"\
+              "<span>This should be replaced: #{data}</span>"
+            end
+
+            it "gets templates from sendgrid api, applies dynamic data to active one and "\
+               "uses LetterOpener to deliver it" do
+              expect_valid_sg_api_get_template_request(response)
+              expect(lo).to have_received(:deliver!) do |arg|
+                expect(arg.html_part.to_s).to include(active_dynamic_template(data))
+              end
+            end
+          end
+        end
+      end
     end
   end
 end