sparkpost 0.1.2 → 0.1.4

data/lib/sparkpost/transmission.rb

@@ -1,6 +1,5 @@
 require 'net/http'
 require 'uri'
-require 'http'
 require_relative '../core_extensions/object'
 require_relative 'request'
 require_relative 'exceptions'
@@ -12,49 +11,66 @@ module SparkPost
     def initialize(api_key, api_host)
       @api_key = api_key
       @api_host = api_host
+      @base_endpoint = "#{@api_host}/api/v1/transmissions"
     end
 
-    def endpoint
-      @api_host.concat('/api/v1/transmissions')
+    def send_payload(data = {})
+      # TODO: consider refactoring this into send_message in v2
+      request(endpoint, @api_key, data)
     end
 
     def send_message(to, from, subject, html_message = nil, **options)
-      #todo add validations for to, from
-      unless to.is_a?(Array)
-        to = [to]
-      end
+      # TODO: add validations for to, from
+      html_message = content_from(options, :html) || html_message
+      text_message = content_from(options, :text) || options[:text_message]
 
-      if html_message.blank? && options[:text_message].blank?
-        fail ArgumentError, 'Content missing. Either provide html_message or text_message in options parameter'
+      if html_message.blank? && text_message.blank?
+        raise ArgumentError, 'Content missing. Either provide html_message or
+         text_message in options parameter'
       end
 
-      options.merge!(
-          {
-              recipients: prepare_recipients(to),
-              content: {
-                  from: from,
-                  subject: subject,
-                  text: options['text_message'],
-                  html: html_message
-              },
-              options: {}
-          }
-      )
-
-      request(endpoint, @api_key, options)
+      options_from_args = {
+        recipients: prepare_recipients(to),
+        content: {
+          from: from,
+          subject: subject,
+          text: options.delete(:text_message),
+          html: html_message
+        },
+        options: {}
+      }
+
+      options.merge!(options_from_args) { |_k, opts, _args| opts }
+      add_attachments(options)
+
+      send_payload(options)
     end
 
-    private
     def prepare_recipients(recipients)
-      recipients.map do |recipient|
-        {
-            address: {
-                email: recipient
-            }
-        }
+      recipients = [recipients] unless recipients.is_a?(Array)
+      recipients.map { |recipient| prepare_recipient(recipient) }
+    end
+
+    private
+
+    def add_attachments(options)
+      if options[:attachments].present?
+        options[:content][:attachments] = options.delete(:attachments)
+      end
+    end
+
+    def prepare_recipient(recipient)
+      if recipient.is_a?(Hash)
+        raise ArgumentError,
+              "email missing - '#{recipient.inspect}'" unless recipient[:email]
+        { address: recipient }
+      else
+        { address: { email: recipient } }
       end
     end
 
+    def content_from(options, key)
+      (options || {}).fetch(:content, {}).fetch(key, nil)
+    end
   end
 end
-

data/lib/sparkpost/version.rb

@@ -1,3 +1,3 @@
 module SparkPost
-    VERSION = '0.1.2'.freeze
+  VERSION = '0.1.4'.freeze
 end

data/sparkpost.gemspec

@@ -4,25 +4,26 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require './lib/sparkpost/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "sparkpost"
+  spec.name          = 'sparkpost'
   spec.version       = SparkPost::VERSION
-  spec.authors       = ["SparkPost", "Aimee Knight", "Mohammad Hossain"]
-  spec.email         = "developers@sparkpost.com"
-  spec.summary       = "SparkPost Ruby API client"
-  spec.homepage      = "https://github.com/SparkPost/ruby-sparkpost"
-  spec.license       = "Apache-2.0"
+  spec.authors       = ['SparkPost', 'Aimee Knight', 'Mohammad Hossain']
+  spec.email         = 'developers@sparkpost.com'
+  spec.summary       = 'SparkPost Ruby API client'
+  spec.homepage      = 'https://github.com/SparkPost/ruby-sparkpost'
+  spec.license       = 'Apache-2.0'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
   spec.add_dependency 'http', '0.9.8'
 
-  spec.add_development_dependency "bundler", "~> 1.5"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 3.3.0"
-  spec.add_development_dependency "simplecov", "~> 0.11.1"
-  spec.add_development_dependency "webmock", "~> 1.22.3"
-  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake', '<11'
+  spec.add_development_dependency 'rspec', '~> 3.3.0'
+  spec.add_development_dependency 'simplecov', '~> 0.11.1'
+  spec.add_development_dependency 'webmock', '~> 1.22.3'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'rubocop', '~> 0.37.2'
 end

data/spec/lib/sparkpost/client_spec.rb

@@ -1,39 +1,58 @@
 require 'spec_helper'
 
 RSpec.describe SparkPost::Transmission do
-  describe '#initialize' do 
+  describe '#initialize' do
     context 'when api key and host are passed'
     let(:client) { SparkPost::Client.new('123', 'http://sparkpost.com') }
 
     it { expect(client.instance_variables).to include(:@api_key) }
     it { expect(client.instance_variables).to include(:@api_host) }
     it { expect(client.instance_variable_get(:@api_key)).to eq('123') }
-    it { expect(client.instance_variable_get(:@api_host)).to eq('http://sparkpost.com') }
+    it do
+      expect(client.instance_variable_get(:@api_host))
+        .to eq('http://sparkpost.com')
+    end
 
-    context 'when api key not passed' do 
-        before do 
-             ENV['SPARKPOST_API_KEY'] = nil
-        end
-        it { expect {SparkPost::Client.new }.to raise_error(ArgumentError) }
+    context 'when api key not passed' do
+      before do
+        ENV['SPARKPOST_API_KEY'] = nil
+      end
+      it { expect { SparkPost::Client.new }.to raise_error(ArgumentError) }
     end
 
-    context 'when api host not passed' do 
-        before do 
-             ENV['SPARKPOST_API_HOST'] = nil
-        end
-        it { expect(SparkPost::Client.new('abc').instance_variable_get(:@api_host)).to eq('https://api.sparkpost.com') }
-        it { expect { SparkPost::Client.new('abc', nil) }.to raise_error(ArgumentError) }
+    context 'when api host not passed' do
+      before do
+        ENV['SPARKPOST_API_HOST'] = nil
+      end
+      it do
+        client = SparkPost::Client.new('abc')
+        expect(client.instance_variable_get(:@api_host))
+          .to eq('https://api.sparkpost.com')
+      end
+      it do
+        expect { SparkPost::Client.new('abc', nil) }
+          .to raise_error(ArgumentError)
+      end
     end
   end
 
-  describe '#transmission' do 
+  describe '#transmission' do
     let(:client) { SparkPost::Client.new('123', 'http://sparkpost.com') }
 
     it { expect(client.transmission).to be_kind_of(SparkPost::Transmission) }
 
-    it 'returns same instances on subsequent call' do 
-       expect(client.transmission).to eq(client.transmission) 
+    it 'returns same instances on subsequent call' do
+      expect(client.transmission).to eq(client.transmission)
     end
+  end
+
+  describe '#template' do
+    let(:client) { SparkPost::Client.new('123', 'http://sparkpost.com') }
+
+    it { expect(client.template).to be_kind_of(SparkPost::Template) }
 
+    it 'returns same instances on subsequent call' do
+      expect(client.template).to eq(client.template)
+    end
   end
-end
+end

data/spec/lib/sparkpost/core_extensions/object_spec.rb

@@ -1,22 +1,21 @@
 require 'spec_helper'
 
+describe 'Object' do
+  describe '#blank?' do
+    it { expect(''.blank?).to be(true) }
+    it { expect(nil.blank?).to be(true) }
+    it { expect(true.blank?).to be(false) }
+    it { expect({}.blank?).to be(true) }
+    it { expect({}.blank?).to be(true) }
+    it { expect([].blank?).to be(true) }
+  end
 
-describe 'Object' do 
-    describe '#blank?' do 
-        it { expect(''.blank?).to be(true)}
-        it { expect(nil.blank?).to be(true)}
-        it { expect(true.blank?).to be(false)}
-        it { expect(Hash.new.blank?).to be(true)}
-        it { expect({}.blank?).to be(true)}
-        it { expect([].blank?).to be(true)}
-    end
-
-    describe '#present?' do 
-        it { expect(''.present?).to be(false)}
-        it { expect(nil.present?).to be(false)}
-        it { expect(true.present?).to be(true)}
-        it { expect(Hash.new.present?).to be(false)}
-        it { expect({}.present?).to be(false)}
-        it { expect([].present?).to be(false)}
-    end
-end
+  describe '#present?' do
+    it { expect(''.present?).to be(false) }
+    it { expect(nil.present?).to be(false) }
+    it { expect(true.present?).to be(true) }
+    it { expect({}.present?).to be(false) }
+    it { expect({}.present?).to be(false) }
+    it { expect([].present?).to be(false) }
+  end
+end

data/spec/lib/sparkpost/helpers_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+RSpec.describe SparkPost::Helpers do
+  let(:helpers) { SparkPost::Helpers }
+
+  describe '#copy_value' do
+    context 'when source is empty' do
+      let(:src_hash) { {} }
+      let(:dst_hash) { { dkey: 'val' } }
+
+      copied_hash = { dkey: 'val' }
+
+      it 'does not copy values' do
+        helpers.copy_value(src_hash, :skey, dst_hash, :dkey)
+        expect(dst_hash).to eq(copied_hash)
+      end
+    end
+
+    context 'when source is not empty' do
+      let(:src_hash) { { skey: 'val' } }
+      let(:dst_hash) { {} }
+
+      copied_hash = { dkey: 'val' }
+
+      it 'copies values' do
+        helpers.copy_value(src_hash, :skey, dst_hash, :dkey)
+        expect(dst_hash).to eq(copied_hash)
+      end
+    end
+  end
+
+  describe '#deep_merge' do
+    context 'when source_hash and other_hash have different keys' do
+      let(:source_hash) { { key1: 'val1', key2: 'val2' } }
+      let(:other_hash) { { key3: 'val3', key4: 'val4' } }
+
+      merged_hash = {
+        key1: 'val1',
+        key2: 'val2',
+        key3: 'val3',
+        key4: 'val4'
+      }
+
+      it 'merges source_hash and other_hash' do
+        expect(helpers.deep_merge(source_hash, other_hash)).to eq(merged_hash)
+      end
+    end
+
+    context 'when other_hash has nil value' do
+      let(:source_hash) { { key1: 'val1', key2: 'val2' } }
+      let(:other_hash) { { key1: nil } }
+
+      merged_hash = {
+        key1: 'val1',
+        key2: 'val2'
+      }
+
+      it 'merges source_hash and other_hash' do
+        expect(helpers.deep_merge(source_hash, other_hash)).to eq(merged_hash)
+      end
+    end
+
+    context 'when source_hash has nil value' do
+      let(:source_hash) { { key1: nil } }
+      let(:other_hash) { { key1: 'val1', key2: 'val2' } }
+
+      merged_hash = {
+        key1: 'val1',
+        key2: 'val2'
+      }
+
+      it 'merges source_hash and other_hash' do
+        expect(helpers.deep_merge(source_hash, other_hash)).to eq(merged_hash)
+      end
+    end
+
+    context 'when source_hash and other_hash have nested hash' do
+      let(:source_hash) { { key1: { s1: 'sv1' } } }
+      let(:other_hash) { { key1: { s2: 'sv2' }, key2: 'val2' } }
+
+      merged_hash = {
+        key1: { s1: 'sv1', s2: 'sv2' },
+        key2: 'val2'
+      }
+
+      it 'merges source_hash and other_hash' do
+        expect(helpers.deep_merge(source_hash, other_hash)).to eq(merged_hash)
+      end
+    end
+  end
+end

data/spec/lib/sparkpost/request_spec.rb

@@ -1,26 +1,100 @@
 require 'spec_helper'
 
 RSpec.describe SparkPost::Request do
-    describe '#request' do 
-        api_url = 'https://api.sparkpost.com/api/'
-
-        let(:api_key) { '123' }
-        let(:request) { SparkPost::Request.request }
-
-        context 'when was successful' do 
-            response = {results: {"total_rejected_recipients"=>0, "total_accepted_recipients"=>1, "id"=>"102238681582044821"} }
-            before do 
-                stub_request(:post, api_url).to_return(body: response.to_json, status: 200)
-            end
-            it { expect(SparkPost::Request.request(api_url, '123', {})).to eq(response[:results]) }
-        end
-        context 'when was not successful' do 
-            response = {errors: {message: 'end of world'} }
-            before do 
-                stub_request(:post, api_url).to_return(body: response.to_json, status: 500)
-            end
-
-            it { expect { SparkPost::Request.request(api_url, '123', {})}.to raise_error(SparkPost::DeliveryException).with_message(/end of world/) }
-        end
+  describe '#request' do
+    api_url = 'https://api.sparkpost.com/api/'
+
+    let(:api_key) { '123' }
+    let(:request) { SparkPost::Request.request }
+
+    success_response = {
+      results: {
+        'total_rejected_recipients' => 0,
+        'total_accepted_recipients' => 1,
+        'id' => '123456789123456789'
+      }
+    }
+
+    context 'when GET request was successful' do
+      before do
+        stub_request(:get, api_url).to_return(
+          body: JSON.generate(success_response),
+          status: 200)
+      end
+      it do
+        expect(SparkPost::Request.request(api_url, '123', {}, 'GET'))
+          .to eq(success_response[:results])
+      end
+    end
+
+    context 'when PUT request was successful' do
+      before do
+        stub_request(:put, api_url).to_return(
+          body: JSON.generate(success_response),
+          status: 200)
+      end
+      it do
+        expect(SparkPost::Request.request(api_url, '123', {}, 'PUT'))
+          .to eq(success_response[:results])
+      end
+    end
+
+    context 'when DELETE request was successful' do
+      before do
+        stub_request(:delete, api_url).to_return(
+          body: JSON.generate(success_response),
+          status: 200)
+      end
+      it do
+        expect(SparkPost::Request.request(api_url, '123', {}, 'DELETE'))
+          .to eq(success_response[:results])
+      end
+    end
+
+    context 'when POST request was successful' do
+      before do
+        stub_request(:post, api_url).to_return(
+          body: JSON.generate(success_response),
+          status: 200)
+      end
+      it do
+        expect(SparkPost::Request.request(api_url, '123', {}))
+          .to eq(success_response[:results])
+      end
+    end
+
+    context 'when request was not successful' do
+      response = { errors: { message: 'end of world' } }
+      before do
+        stub_request(:post, api_url).to_return(
+          body: JSON.generate(response),
+          status: 500)
+      end
+
+      it do
+        expect { SparkPost::Request.request(api_url, '123', {}) }
+          .to raise_error(SparkPost::DeliveryException).with_message(
+            /end of world/)
+      end
+    end
+
+    describe 'json encoding' do
+      api_url = 'https://api.sparkpost.com/api/'
+      before do
+        stub_request(:post, api_url).to_return(
+          body: JSON.generate({}),
+          status: 200)
+      end
+
+      it 'encodes hash to json' do
+        allow(JSON).to receive(:generate).with(foo: 'bar')
+        SparkPost::Request.request(api_url, '123', foo: 'bar')
+      end
+
+      it 'does not encode nil to json' do
+        expect(JSON).to_not receive(:generate)
+        SparkPost::Request.request(api_url, '123', nil)
+      end
     end
-end 
+  end
+end