sparkpost 0.1.2 → 0.1.4

data/spec/lib/sparkpost/template_spec.rb

@@ -0,0 +1,276 @@
+require 'spec_helper'
+
+RSpec.describe SparkPost::Template do
+  describe '#initialize' do
+    context 'when api key and host are passed'
+    let(:template) do
+      SparkPost::Template.new('123', 'http://sparkpost.com')
+    end
+
+    it { expect(template.instance_variables).to include(:@api_key) }
+    it { expect(template.instance_variables).to include(:@api_host) }
+    it { expect(template.instance_variable_get(:@api_key)).to eq('123') }
+    it do
+      expect(template.instance_variable_get(:@api_host))
+        .to eq('http://sparkpost.com')
+    end
+
+    context 'when api key or host not passed' do
+      it 'raises when api key and host not passed' do
+        expect { SparkPost::Template.new }
+          .to raise_error(ArgumentError)
+      end
+      it 'raises when host not passed' do
+        expect { SparkPost::Template.new(123) }
+          .to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#endpoint' do
+    let(:template) do
+      SparkPost::Template.new('123456', 'https://api.sparkpost.com')
+    end
+    let(:url) { 'https://api.sparkpost.com/api/v1/templates' }
+
+    it 'returns correct endpoint' do
+      expect(template.endpoint).to eq(url)
+    end
+
+    it 'returns correct endpoint on subsequent calls' do
+      template.endpoint
+
+      expect(template.endpoint).to eq(url)
+    end
+  end
+
+  describe '#create' do
+    let(:template) do
+      SparkPost::Template.new('123456', 'https://api.sparkpost.com')
+    end
+    let(:url) { 'https://api.sparkpost.com/api/v1/templates' }
+
+    it 'calls request with correct data' do
+      prepared_data = {
+        content: {
+          from: {
+            email: 'me@me.com',
+            name: 'Sparky'
+          },
+          subject: 'test subject',
+          text: 'Hello Sparky',
+          html: '<h1>Hello Sparky</h1>'
+        },
+        options: {
+          transactional: true
+        },
+        id: 'sample-template',
+        name: 'Sample Template'
+      }
+
+      allow(template).to receive(:request) do |req_url, req_api_key, req_data, req_verb|
+        expect(req_verb).to eq('POST')
+        expect(req_api_key).to eq('123456')
+        expect(req_url).to eq(url)
+        expect(req_data).to eq(prepared_data)
+      end
+
+      template.create(
+        'sample-template',
+        nil,
+        'test subject',
+        '<h1>Hello Sparky</h1>',
+        text: 'Hello Sparky',
+        is_transactional: true,
+        name: 'Sample Template',
+        from_name: 'Sparky',
+        from_email: 'me@me.com'
+      )
+    end
+  end
+
+  describe '#update' do
+    context 'draft update' do
+      let(:template) do
+        SparkPost::Template.new('123456', 'https://api.sparkpost.com')
+      end
+      let(:url) { 'https://api.sparkpost.com/api/v1/templates/sample-template' }
+
+      it 'calls request with correct data' do
+        prepared_data = {
+          content: {
+            from: 'me@me.com',
+            subject: 'test subject',
+            text: 'Hello Sparky',
+            html: '<h1>Hello Sparky</h1>'
+          },
+          options: {
+            transactional: true
+          }
+        }
+
+        allow(template).to receive(:request) do |req_url, req_api_key, req_data, req_verb|
+          expect(req_verb).to eq('PUT')
+          expect(req_api_key).to eq('123456')
+          expect(req_url).to eq(url)
+          expect(req_data).to eq(prepared_data)
+        end
+
+        template.update(
+          'sample-template',
+          'me@me.com',
+          'test subject',
+          '<h1>Hello Sparky</h1>',
+          text: 'Hello Sparky',
+          is_transactional: true
+        )
+      end
+    end
+
+    context 'published update' do
+      let(:template) do
+        SparkPost::Template.new('123456', 'https://api.sparkpost.com')
+      end
+      let(:url) { 'https://api.sparkpost.com/api/v1/templates/sample-template?update_published=true' }
+
+      it 'calls request with correct data' do
+        prepared_data = {
+          content: {
+            from: 'me@me.com',
+            subject: 'test subject',
+            text: 'Hello Sparky',
+            html: '<h1>Hello Sparky</h1>'
+          },
+          options: {
+            transactional: true
+          }
+        }
+
+        allow(template).to receive(:request) do |req_url, req_api_key, req_data, req_verb|
+          expect(req_verb).to eq('PUT')
+          expect(req_api_key).to eq('123456')
+          expect(req_url).to eq(url)
+          expect(req_data).to eq(prepared_data)
+        end
+
+        template.update(
+          'sample-template',
+          'me@me.com',
+          'test subject',
+          '<h1>Hello Sparky</h1>',
+          text: 'Hello Sparky',
+          is_transactional: true,
+          update_published: true
+        )
+      end
+    end
+  end
+
+  describe '#delete' do
+    let(:template) do
+      SparkPost::Template.new('123456', 'https://api.sparkpost.com')
+    end
+    let(:url) { 'https://api.sparkpost.com/api/v1/templates/sample-template' }
+
+    it 'calls request with correct data' do
+      allow(template).to receive(:request) do |req_url, req_api_key, _req_data, req_verb|
+        expect(req_verb).to eq('DELETE')
+        expect(req_api_key).to eq('123456')
+        expect(req_url).to eq(url)
+      end
+
+      template.delete('sample-template')
+    end
+  end
+
+  describe '#get' do
+    let(:template) do
+      SparkPost::Template.new('123456', 'https://api.sparkpost.com')
+    end
+
+    let(:template_id) { 'my-email-template' }
+
+    context 'when retrieve published template' do
+      let(:url) { "https://api.sparkpost.com/api/v1/templates/#{template_id}" }
+
+      it 'calls request with correct data' do
+        allow(template).to receive(:request) do |req_url, req_api_key, _req_data, req_verb|
+          expect(req_verb).to eq('GET')
+          expect(req_api_key).to eq('123456')
+          expect(req_url).to eq(url)
+        end
+
+        template.get(template_id)
+      end
+    end
+
+    context 'when retrieve draft template' do
+      let(:url) { "https://api.sparkpost.com/api/v1/templates/#{template_id}?draft=true" }
+
+      it 'calls request with correct data' do
+        allow(template).to receive(:request) do |req_url, req_api_key, _req_data, req_verb|
+          expect(req_verb).to eq('GET')
+          expect(req_api_key).to eq('123456')
+          expect(req_url).to eq(url)
+        end
+
+        template.get(template_id, true)
+      end
+    end
+  end
+
+  describe '#list' do
+    let(:template) do
+      SparkPost::Template.new('123456', 'https://api.sparkpost.com')
+    end
+    let(:url) { 'https://api.sparkpost.com/api/v1/templates' }
+
+    it 'calls request with correct data' do
+      allow(template).to receive(:request) do |req_url, req_api_key, _req_data, req_verb|
+        expect(req_verb).to eq('GET')
+        expect(req_api_key).to eq('123456')
+        expect(req_url).to eq(url)
+      end
+
+      template.list
+    end
+  end
+
+  describe '#preview' do
+    let(:template) do
+      SparkPost::Template.new('123456', 'https://api.sparkpost.com')
+    end
+
+    let(:template_id) { 'my-email-template' }
+
+    context 'when retrieve published template' do
+      let(:url) { "https://api.sparkpost.com/api/v1/templates/#{template_id}/preview" }
+
+      it 'calls request with correct data' do
+        allow(template).to receive(:request) do |req_url, req_api_key, req_data, req_verb|
+          expect(req_verb).to eq('POST')
+          expect(req_api_key).to eq('123456')
+          expect(req_data).to eq(substitution_data: {})
+          expect(req_url).to eq(url)
+        end
+
+        template.preview(template_id, {})
+      end
+    end
+
+    context 'when retrieve draft template' do
+      let(:url) { "https://api.sparkpost.com/api/v1/templates/#{template_id}/preview?draft=true" }
+
+      it 'calls request with correct data' do
+        allow(template).to receive(:request) do |req_url, req_api_key, req_data, req_verb|
+          expect(req_verb).to eq('POST')
+          expect(req_api_key).to eq('123456')
+          expect(req_data).to eq(substitution_data: {})
+          expect(req_url).to eq(url)
+        end
+
+        template.preview(template_id, {}, true)
+      end
+    end
+  end
+end

data/spec/lib/sparkpost/transmission_spec.rb

@@ -1,67 +1,292 @@
 require 'spec_helper'
 
 RSpec.describe SparkPost::Transmission do
-  describe '#initialize' do 
+  describe '#initialize' do
     context 'when api key and host are passed'
-    let(:transmission) { SparkPost::Transmission.new('123', 'http://sparkpost.com') }
+    let(:transmission) do
+      SparkPost::Transmission.new('123', 'http://sparkpost.com')
+    end
 
     it { expect(transmission.instance_variables).to include(:@api_key) }
     it { expect(transmission.instance_variables).to include(:@api_host) }
     it { expect(transmission.instance_variable_get(:@api_key)).to eq('123') }
-    it { expect(transmission.instance_variable_get(:@api_host)).to eq('http://sparkpost.com') }
+    it do
+      expect(transmission.instance_variable_get(:@api_host))
+        .to eq('http://sparkpost.com')
+    end
 
-    context 'when api key or host not passed' do 
-        it {expect {SparkPost::Transmission.new }.to raise_error(ArgumentError) }
-        it {expect {SparkPost::Transmission.new(123) }.to raise_error(ArgumentError) }
+    context 'when api key or host not passed' do
+      it 'raises when api key and host not passed' do
+        expect { SparkPost::Transmission.new }
+          .to raise_error(ArgumentError)
+      end
+      it 'raises when host not passed' do
+        expect { SparkPost::Transmission.new(123) }
+          .to raise_error(ArgumentError)
+      end
     end
   end
 
-  describe '#send_message' do 
-    let(:transmission) { SparkPost::Transmission.new('123456', 'https://api.sparkpost.com')}
+  describe '#endpoint' do
+    let(:transmission) do
+      SparkPost::Transmission.new('123456', 'https://api.sparkpost.com')
+    end
     let(:url) { 'https://api.sparkpost.com/api/v1/transmissions' }
-    before do 
-        allow(transmission).to receive(:request).and_return({})
+
+    it 'returns correct endpoint' do
+      expect(transmission.endpoint).to eq(url)
     end
 
-    it 'requests correct endpoint' do 
-        allow(transmission).to receive(:request) do |_url|
-            expect(_url).to eq(url)
-        end
+    it 'returns correct endpoint on subsequent calls' do
+      transmission.endpoint
+
+      expect(transmission.endpoint).to eq(url)
+    end
+  end
 
-        transmission.send_message('to@example.com', 'from@example.com', 'test subject', '<h1>Hello World</h1>')
+  describe '#send_payload' do
+    let(:transmission) do
+      SparkPost::Transmission.new('123456', 'https://api.sparkpost.com')
+    end
+    let(:url) { 'https://api.sparkpost.com/api/v1/transmissions' }
+    let(:data) do
+      {
+        recipients: [
+          {
+            address: {
+              email: 'to@me.com', name: 'Me', header_to: 'no@reply.com'
+            }
+          }
+        ],
+        content: {
+          from: { email: 'me@me.com', name: 'Me' },
+          subject: 'test subject',
+          text: 'Hello Sparky',
+          html: '<h1>Hello Sparky</h1>'
+        }
+      }
     end
 
-    it 'requests with correct parameters' do 
-        allow(transmission).to receive(:request) do |_url, api_key, data| 
-            expect(data[:recipients].length).to eq(1)
-            expect(data[:recipients][0][:address]).to eq({email: 'to@example.com'})
-            expect(data[:content][:from]).to eq('from@example.com')
-            expect(data[:content][:subject]).to eq('test subject')
-            expect(data[:content][:html]).to eq('<h1>Hello World</h1>')
-        end
-        transmission.send_message('to@example.com', 'from@example.com', 'test subject', '<h1>Hello World</h1>')
+    it 'calls request with correct data' do
+      allow(transmission).to receive(:request) do |req_url, req_api_key, req_data|
+        expect(req_api_key).to eq('123456')
+        expect(req_url).to eq(url)
+        expect(req_data).to eq(data)
+      end
+
+      transmission.send_payload(data)
     end
 
-    it 'handles array of recipients correctly' do 
-        allow(transmission).to receive(:request) do |_url, api_key, data| 
-            expect(data[:recipients].length).to eq(1)
-            expect(data[:recipients][0][:address]).to eq({email: 'to@example.com'})
-        end
-        transmission.send_message(['to@example.com'], 'from@example.com', 'test subject', '<h1>Hello World</h1>')
+    it 'passes through delivery exception' do
+      allow(transmission).to receive(:request).and_raise(
+        SparkPost::DeliveryException.new('Some delivery error'))
+
+      bad_data = data.merge(recipients: [])
+
+      expect do
+        transmission.send_payload(bad_data)
+      end.to raise_error(SparkPost::DeliveryException).with_message(
+        /Some delivery error/)
     end
 
-    it { expect {transmission.send_message(['to@example.com'], 'from@example.com', 'test subject')}.to raise_error(ArgumentError).with_message(/Content missing/) }
-    it { expect {transmission.send_message(['to@example.com'], 'from@example.com', 'test subject', nil, {text_message: 'hello world'})}.to_not raise_error }
+    it 'passes responses' do
+      allow(transmission).to receive(:request).and_return(success: 1)
+      expect(transmission.send_payload(data)).to eq(success: 1)
+    end
+  end
 
-    it 'passes through delivery exception' do 
-        allow(transmission).to receive(:request).and_raise(SparkPost::DeliveryException.new('Some delivery error'))
+  describe '#send_message' do
+    let(:transmission) do
+      SparkPost::Transmission.new('123456', 'https://api.sparkpost.com')
+    end
+    let(:url) { 'https://api.sparkpost.com/api/v1/transmissions' }
+    before do
+      allow(transmission).to receive(:request).and_return({})
+    end
+
+    it 'calls send_payload with prepared data' do
+      prepared_data = {
+        recipients: [
+          {
+            address: {
+              email: 'to@me.com'
+            }
+          }
+        ],
+        content: {
+          from: 'me@me.com',
+          subject: 'test subject',
+          text: 'hello sparky',
+          html: '<h1>Hello Sparky</h1>'
+        },
+        options: {}
+      }
+
+      expect(transmission).to receive(:send_payload).with(prepared_data)
+      transmission.send_message(
+        'to@me.com',
+        'me@me.com',
+        'test subject',
+        '<h1>Hello Sparky</h1>',
+        text_message: 'hello sparky'
+      )
+    end
+
+    it 'requests correct endpoint' do
+      allow(transmission).to receive(:request) do |request_url|
+        expect(request_url).to eq(url)
+      end
+
+      transmission.send_message(
+        'to@example.com',
+        'from@example.com',
+        'test subject',
+        '<h1>Hello World</h1>')
+    end
+
+    it 'calls prepare_attachments' do
+      allow(transmission).to receive(:request)
+
+      allow(transmission).to receive(:prepare_recipients) do |recipients|
+        expect(recipients).to eq('to@example.com')
+      end
+
+      transmission.send_message(
+        'to@example.com',
+        'from@example.com',
+        'test subject',
+        '<h1>Hello World</h1>')
+    end
+
+    it 'requests with correct parameters' do
+      allow(transmission).to receive(:request) do |_url, _api_key, data|
+        expect(data[:recipients].length).to eq(1)
+        expect(data[:recipients][0][:address]).to eq(email: 'to@example.com')
+        expect(data[:content][:from]).to eq('from@example.com')
+        expect(data[:content][:subject]).to eq('test subject')
+        expect(data[:content][:html]).to eq('<h1>Hello World</h1>')
+      end
+      transmission.send_message(
+        'to@example.com',
+        'from@example.com',
+        'test subject',
+        '<h1>Hello World</h1>')
+    end
+
+    it 'raises erorr when no content passed' do
+      expect do
+        transmission.send_message(
+          ['to@example.com'],
+          'from@example.com',
+          'test subject')
+      end.to raise_error(ArgumentError).with_message(/Content missing/)
+    end
+
+    it 'it does not raise error when text_message passed' do
+      expect do
+        transmission.send_message(
+          ['to@example.com'],
+          'from@example.com',
+          'test subject',
+          nil,
+          text_message: 'hello world')
+      end.to_not raise_error
+    end
+
+    it 'passes through delivery exception' do
+      allow(transmission).to receive(:request).and_raise(
+        SparkPost::DeliveryException.new('Some delivery error'))
+
+      expect do
+        transmission.send_message(
+          'to@example.com',
+          'from@example.com',
+          'test subject',
+          '<h1>Hello World</h1>')
+      end.to raise_error(SparkPost::DeliveryException).with_message(
+        /Some delivery error/)
+    end
+
+    it 'passes responses' do
+      allow(transmission).to receive(:request).and_return(success: 1)
+      expect(transmission.send_message(
+        'to@example.com',
+        'from@example.com',
+        'test subject',
+        '<h1>Hello World</h1>')).to eq(success: 1)
+    end
+
+    it 'sends attachments' do
+      attachment = {
+        name: 'attachment.txt',
+        type: 'text/plain',
+        data: Base64.encode64('Hello World')
+      }
+      options = {
+        attachments: [attachment]
+      }
+
+      allow(transmission).to receive(:request) do |_url, _api_key, data|
+        expect(data[:content][:attachments]).to be_kind_of(Array)
+        expect(data[:content][:attachments].length).to eq(1)
+        expect(data[:content][:attachments][0]).to eq(attachment)
+      end
+      transmission.send_message(
+        ['to@example.com'],
+        'from@example.com',
+        'test subject',
+        '<h1>Hello World</h1>',
+        options)
+    end
+  end
+
+  describe '#prepare_recipients' do
+    let(:transmission) do
+      SparkPost::Transmission.new('123456', 'https://api.sparkpost.com')
+    end
+
+    it 'returns an array' do
+      expect(transmission.prepare_recipients('to@domain.com')).to be_kind_of(Array)
+    end
+
+    it 'handles a recipient hash with email, name and header_to correctly' do
+      prepared_recipients = transmission.prepare_recipients(
+        email: 'to@me.com', name: 'Me', header_to: 'no@reply.com'
+      )
+
+      expect(prepared_recipients.length).to eq(1)
+      expect(prepared_recipients[0]).to eq(address: { email: 'to@me.com', name: 'Me', header_to: 'no@reply.com' })
+    end
+
+    it 'handles array of recipient hashes correctly' do
+      prepared_recipients = transmission.prepare_recipients(
+        [{ email: 'to@me.com', name: 'Me', header_to: 'no@reply.com' }]
+      )
+      expect(prepared_recipients.length).to eq(1)
+      expect(prepared_recipients[0]).to eq(address: { email: 'to@me.com', name: 'Me', header_to: 'no@reply.com' })
+    end
+
+    it 'handles array of recipients correctly' do
+      expect(
+        transmission.prepare_recipients(['to@example.com'])
+      ).to eq([{ address: { email: 'to@example.com' } }])
+    end
 
-        expect { transmission.send_message('to@example.com', 'from@example.com', 'test subject', '<h1>Hello World</h1>')}.to raise_error(SparkPost::DeliveryException).with_message(/Some delivery error/)
+    it 'raises for invalid recipient hash' do
+      expect do
+        transmission.prepare_recipients(name: 'Me', header_to: 'no@reply.com')
+      end.to raise_error(ArgumentError, /email missing/)
     end
 
-    it 'passes responses' do 
-        allow(transmission).to receive(:request).and_return({success: 1})
-        expect(transmission.send_message('to@example.com', 'from@example.com', 'test subject', '<h1>Hello World</h1>')).to eq({success: 1})
+    it 'throws for an array of invalid recipient hashes' do
+      expect do
+        transmission.prepare_recipients(
+          [
+            { to: 'to@me.com', name: 'Me', header_to: 'no@reply.com' },
+            { name: 'You', header_to: 'no@reply.com' }
+          ]
+        )
+      end.to raise_error(ArgumentError, /email missing/)
     end
   end
 end