sendgrid-ruby 1.1.6 → 6.0.4

data/lib/sendgrid/recipient.rb

@@ -1,29 +0,0 @@
-require 'smtpapi'
-
-module SendGrid
-  class Recipient
-    class NoAddress < StandardError; end
-
-    attr_reader :address, :substitutions
-
-    def initialize(address)
-      @address = address
-      @substitutions = {}
-
-      raise NoAddress, 'Recipient address cannot be nil' if @address.nil?
-    end
-
-    def add_substitution(key, value)
-      substitutions[key] = value
-    end
-
-    def add_to_smtpapi(smtpapi)
-      smtpapi.add_to(@address)
-
-      @substitutions.each do |key, value|
-        existing = smtpapi.sub[key] || []
-        smtpapi.add_substitution(key, existing + [value])
-      end
-    end
-  end
-end

data/lib/sendgrid/response.rb

@@ -1,14 +0,0 @@
-require 'json'
-
-module SendGrid
-  class Response
-    attr_reader :code, :headers, :body, :raw_body
-
-    def initialize(params)
-      @code = params[:code]
-      @headers = params[:headers]
-      @body = JSON.parse(params[:body])
-      @raw_body = params[:body]
-    end
-  end
-end

data/lib/sendgrid/template.rb

@@ -1,26 +0,0 @@
-require 'smtpapi'
-
-module SendGrid
-  class Template
-    attr_reader :id, :recipients
-
-    def initialize(id)
-      @id = id
-      @recipients = []
-    end
-
-    def add_recipient(recipient)
-      recipients << recipient
-    end
-
-    def add_to_smtpapi(smtpapi)
-      return if smtpapi.nil?
-
-      smtpapi.tap do |api|
-        api.add_filter(:templates, :enable, 1)
-        api.add_filter(:templates, :template_id, id)
-        recipients.each { |r| r.add_to_smtpapi(smtpapi) }
-      end
-    end
-  end
-end

data/lib/sendgrid/template_mailer.rb

@@ -1,59 +0,0 @@
-module SendGrid
-  class InvalidClient < StandardError; end
-  class InvalidTemplate < StandardError; end
-  class InvalidRecipients < StandardError; end
-
-  class TemplateMailer
-
-    # This class is responsible for coordinating the responsibilities
-    #  of various models in the gem.
-    # It makes use of the Recipient, Template and Mail models to create
-    #  a single work flow, an example might look like:
-    #
-    # users = User.where(email: ['first@gmail.com', 'second@gmail.com'])
-    #
-    # recipients = []
-    #
-    # users.each do |user|
-    #   recipient = SendGrid::Recipient.new(user.email)
-    #   recipient.add_substitution('first_name', user.first_name)
-    #   recipient.add_substitution('city', user.city)
-    #
-    #   recipients << recipient
-    # end
-    #
-    # template = SendGrid::Template.new('MY_TEMPLATE_ID')
-    #
-    # client = SendGrid::Client.new(api_user: my_user, api_key: my_key)
-    #
-    # mail_defaults = {
-    #   from: 'admin@email.com',
-    #   html: '<h1>I like email</h1>',
-    #   text: 'I like email',
-    #   subject: 'Email is great',
-    # }
-    #
-    # mailer = SendGrid::TemplateMailer.new(client, template, recipients)
-    # mailer.mail(mail_defaults)
-    def initialize(client, template, recipients = [])
-      @client = client
-      @template = template
-      @recipients = recipients
-
-      raise InvalidClient, 'Client must be present' if @client.nil?
-      raise InvalidTemplate, 'Template must be present' if @template.nil?
-      raise InvalidRecipients, 'Recipients may not be empty' if @recipients.empty?
-
-      @recipients.each do |recipient|
-        @template.add_recipient(recipient)
-      end
-    end
-
-    def mail(params = {})
-      mail = Mail.new(params)
-
-      mail.template = @template
-      @client.send(mail.to_h)
-    end
-  end
-end

data/spec/lib/sendgrid/client_spec.rb

@@ -1,87 +0,0 @@
-require 'json'
-require 'spec_helper'
-require 'webmock/rspec'
-
-describe 'SendGrid::Client' do
-  it 'should accept a username and password' do
-    expect(SendGrid::Client.new(api_user: 'test', api_key: 'test')).to be_an_instance_of(SendGrid::Client)
-  end
-
-  it 'should accept an api key' do
-    expect(SendGrid::Client.new(api_key: 'sendgrid_123')).to be_an_instance_of(SendGrid::Client)
-  end
-
-  it 'should build the default url' do
-    expect(SendGrid::Client.new.url).to eq('https://api.sendgrid.com')
-  end
-
-  it 'should build a custom url' do
-    expect(SendGrid::Client.new(port: 3000, host: 'foo.sendgrid.com', protocol: 'tacos').url).to eq('tacos://foo.sendgrid.com:3000')
-  end
-
-  it 'should use the default endpoint' do
-    expect(SendGrid::Client.new.endpoint).to eq('/api/mail.send.json')
-  end
-
-  it 'accepts a block' do
-    expect { |b| SendGrid::Client.new(&b) }.to yield_control
-  end
-
-  describe ':send' do
-    it 'should make a request to sendgrid' do
-      stub_request(:any, 'https://api.sendgrid.com/api/mail.send.json')
-        .to_return(body: {message: 'success'}.to_json, status: 200, headers: {'X-TEST' => 'yes'})
-
-      client = SendGrid::Client.new(api_key: 'abc123')
-      mail = SendGrid::Mail.new
-      res = client.send(mail)
-      expect(res.code).to eq(200)
-    end
-
-    it 'should have an auth header when using an api key' do
-      stub_request(:any, 'https://api.sendgrid.com/api/mail.send.json')
-        .to_return(body: {message: 'success'}.to_json, status: 200, headers: {'X-TEST' => 'yes'})
-
-      client = SendGrid::Client.new(api_key: 'abc123')
-      mail = SendGrid::Mail.new
-
-      client.send(mail)
-
-      expect(WebMock).to have_requested(:post, 'https://api.sendgrid.com/api/mail.send.json')
-        .with(headers: {'Authorization' => 'Bearer abc123'})
-    end
-
-    it 'should have a username + password when using them' do
-      stub_request(:any, 'https://api.sendgrid.com/api/mail.send.json')
-        .to_return(body: {message: 'success'}.to_json, status: 200, headers: {'X-TEST' => 'yes'})
-
-      client = SendGrid::Client.new(api_user: 'foobar', api_key: 'abc123')
-      mail = SendGrid::Mail.new
-
-      res = client.send(mail)
-
-      expect(WebMock).to have_requested(:post, 'https://api.sendgrid.com/api/mail.send.json')
-        .with(body: 'api_key=abc123&api_user=foobar')
-    end
-
-    it 'should raise a SendGrid::Exception if status is not 200' do
-      stub_request(:any, 'https://api.sendgrid.com/api/mail.send.json')
-        .to_return(body: {message: 'error', errors: ['Bad username / password']}.to_json, status: 400, headers: {'X-TEST' => 'yes'})
-
-      client = SendGrid::Client.new(api_user: 'foobar', api_key: 'abc123')
-      mail = SendGrid::Mail.new
-
-      expect {client.send(mail)}.to raise_error(SendGrid::Exception)
-    end
-
-    it 'should not raise a SendGrid::Exception if raise_exceptions is disabled' do
-      stub_request(:any, 'https://api.sendgrid.com/api/mail.send.json')
-        .to_return(body: {message: 'error', errors: ['Bad username / password']}.to_json, status: 400, headers: {'X-TEST' => 'yes'})
-
-      client = SendGrid::Client.new(api_user: 'foobar', api_key: 'abc123', raise_exceptions: false)
-      mail = SendGrid::Mail.new
-
-      expect {client.send(mail)}.not_to raise_error
-    end
-  end
-end

data/spec/lib/sendgrid/mail_spec.rb

@@ -1,151 +0,0 @@
-require 'spec_helper'
-
-describe 'SendGrid::Mail' do
-  before(:each) do
-    @mail = SendGrid::Mail.new
-  end
-
-  it 'should create an instance' do
-    expect(SendGrid::Mail.new).to be_an_instance_of(SendGrid::Mail)
-  end
-
-  describe 'add_to_name' do
-    it 'should accept a name' do
-      @mail.add_to_name('Frank Foo')
-      expect(@mail.to_name).to eq(['Frank Foo'])
-    end
-
-    it 'should accept an array of names' do
-      @mail.add_to_name(['Frank Foo', 'Bob Bar'])
-      expect(@mail.to_name).to eq(['Frank Foo', 'Bob Bar'])
-    end
-  end
-
-  describe 'add_to' do
-    it 'should accept an email' do
-      @mail.add_to('foo@example.com')
-      expect(@mail.to).to eq(['foo@example.com'])
-
-      @mail.add_to('bar@example.com')
-      expect(@mail.to).to eq(['foo@example.com', 'bar@example.com'])
-    end
-
-    it 'should accept an email and name' do
-      @mail.add_to('foo@example.com', 'Frank Foo')
-      expect(@mail.to).to eq(['foo@example.com'])
-      expect(@mail.to_name).to eq(['Frank Foo'])
-
-      @mail.add_to('bar@example.com', 'Bob Bar')
-      expect(@mail.to).to eq(['foo@example.com', 'bar@example.com'])
-      expect(@mail.to_name).to eq(['Frank Foo', 'Bob Bar'])
-    end
-
-    it 'should accept an array of emails' do
-      @mail.add_to(['foo@example.com', 'bar@example.com'])
-      expect(@mail.to).to eq(['foo@example.com', 'bar@example.com'])
-    end
-
-    it 'should accept an array of emails and names' do
-      @mail.add_to(['foo@example.com', 'bar@example.com'], ['Frank Foo', 'Bob Bar'])
-      expect(@mail.to).to eq(['foo@example.com', 'bar@example.com'])
-      expect(@mail.to_name).to eq(['Frank Foo', 'Bob Bar'])
-    end
-  end
-
-  describe 'add_cc' do
-    it 'should accept an email' do
-      @mail.add_cc('foo@example.com')
-      expect(@mail.cc).to eq(['foo@example.com'])
-    end
-
-    it 'should accept an email and a name' do
-      @mail.add_cc('foo@example.com', 'Frank Foo')
-      expect(@mail.cc).to eq(['foo@example.com'])
-      expect(@mail.cc_name).to eq(['Frank Foo'])
-    end
-
-    it 'should accept an array of emails' do
-      @mail.add_cc(['foo@example.com', 'bar@example.com'])
-      expect(@mail.cc).to eq(['foo@example.com', 'bar@example.com'])
-    end
-
-    it 'should accept an array of emails and names' do
-      @mail.add_cc(['foo@example.com', 'bar@example.com'], ['Frank Foo', 'Bob Bar'])
-      expect(@mail.cc).to eq(['foo@example.com', 'bar@example.com'])
-      expect(@mail.cc_name).to eq(['Frank Foo', 'Bob Bar'])
-    end
-  end
-
-  describe 'add_bcc' do
-    it 'should accept an email' do
-      @mail.add_bcc('foo@example.com')
-      expect(@mail.bcc).to eq(['foo@example.com'])
-    end
-
-    it 'should accept an email and a name' do
-      @mail.add_bcc('foo@example.com', 'Frank Foo')
-      expect(@mail.bcc).to eq(['foo@example.com'])
-      expect(@mail.bcc_name).to eq(['Frank Foo'])
-    end
-
-    it 'should accept an array of emails' do
-      @mail.add_bcc(['foo@example.com', 'bar@example.com'])
-      expect(@mail.bcc).to eq(['foo@example.com', 'bar@example.com'])
-    end
-
-    it 'should accept an array of emails and names' do
-      @mail.add_bcc(['foo@example.com', 'bar@example.com'], ['Frank Foo', 'Bob Bar'])
-      expect(@mail.bcc).to eq(['foo@example.com', 'bar@example.com'])
-      expect(@mail.bcc_name).to eq(['Frank Foo', 'Bob Bar'])
-    end
-  end
-
-  describe 'to' do
-    it 'should be set' do
-      @mail.to = 'foo@example.com'
-      expect(@mail.to).to eq('foo@example.com')
-    end
-  end
-
-  describe 'from_name' do
-    it 'should be set' do
-      @mail.from_name = 'Frank Foo'
-      expect(@mail.from_name).to eq('Frank Foo')
-    end
-  end
-
-  describe 'reply_to' do
-    it 'should be set' do
-      @mail.reply_to = 'foo@example.com'
-      expect(@mail.reply_to).to eq('foo@example.com')
-    end
-  end
-
-  describe 'smtpapi_json' do
-    before do
-      @mail.template = template
-    end
-
-    context 'a template has been set' do
-      let(:template) { SendGrid::Template.new(anything) }
-
-      it 'adds the template to the smtpapi header' do
-        expect(@mail.template).to receive(:add_to_smtpapi).with(@mail.smtpapi)
-        expect(@mail.smtpapi).to receive(:to_json)
-
-        @mail.to_h
-      end
-    end
-
-    context 'no template has been set' do
-      let(:template) { nil }
-
-      it 'does not add anything to the smtpapi header' do
-        expect_any_instance_of(SendGrid::Template).to_not receive(:add_to_smtpapi)
-        expect(@mail.smtpapi).to receive(:to_json)
-
-        @mail.to_h
-      end
-    end
-  end
-end

data/spec/lib/sendgrid/recipient_spec.rb

@@ -1,91 +0,0 @@
-require_relative '../../../lib/sendgrid/recipient'
-
-module SendGrid
-  describe Recipient do
-    subject { described_class.new(anything) }
-
-    describe '#initialize' do
-      it 'sets the address instance var' do
-        expect(subject.instance_variable_get(:@address)).to_not be_nil
-      end
-
-      it 'sets substitutions to an empty hash' do
-        expect(subject.instance_variable_get(:@substitutions)).to eq({})
-      end
-
-      context 'initialized with nil' do
-        it 'raises an error' do
-          expect do
-            described_class.new(nil)
-          end.to raise_error(Recipient::NoAddress, 'Recipient address cannot be nil')
-        end
-      end
-    end
-
-    describe '#add_substitution' do
-      it 'adds the key and value to the substitutions hash' do
-        subject.add_substitution(:foo, :bar)
-        expect(subject.substitutions).to have_key(:foo)
-        expect(subject.substitutions[:foo]).to eq(:bar)
-      end
-
-      context 'the same substiution key already exists' do
-        before do
-          subject.add_substitution(:foo, :bar)
-        end
-
-        it 'replaces the value' do
-          subject.add_substitution(:foo, :baz)
-          expect(subject.substitutions).to have_key(:foo)
-          expect(subject.substitutions[:foo]).to eq(:baz)
-        end
-      end
-    end
-
-    describe '#add_to_smtpapi' do
-      let(:substitutions) { { foo: :bar, baz: :qux } }
-      let(:smtp_api) { Smtpapi::Header.new }
-      before do
-        substitutions.each do |key, value|
-          subject.add_substitution(key, value)
-        end
-      end
-
-      it 'adds the address' do
-        expect(smtp_api).to receive(:add_to)
-        subject.add_to_smtpapi(smtp_api)
-      end
-
-      it 'calls add_substitution as many times as there are substitution keys' do
-        substitutions.each do |key, value|
-          expect(smtp_api).to receive(:add_substitution).with(key, [value])
-        end
-
-        subject.add_to_smtpapi(smtp_api)
-      end
-
-      context 'a substitution for the same key already exists' do
-        let(:substitutions) { { foo: :bar } }
-        let(:added_value) { [:bar, :rab] }
-
-        before do
-          smtp_api.add_substitution(:foo, [:rab])
-        end
-
-        it 'adds to it' do
-          expect(smtp_api).to receive(:add_substitution).with(:foo, array_including(added_value))
-          subject.add_to_smtpapi(smtp_api)
-        end
-      end
-
-      context 'substitutions is empty' do
-        let(:substitutions) { {} }
-
-        it 'does nothing' do
-          expect(smtp_api).to_not receive(:add_substitution)
-          subject.add_to_smtpapi(smtp_api)
-        end
-      end
-    end
-  end
-end

data/spec/lib/sendgrid/template_mailer_spec.rb

@@ -1,86 +0,0 @@
-require_relative '../../../lib/sendgrid/template_mailer'
-
-module SendGrid
-  describe TemplateMailer do
-    let(:client) { anything }
-    let(:template) { Template.new(anything) }
-    let(:recipients) { [Recipient.new(anything)] }
-
-    describe '#initialize' do
-      let(:client) { anything }
-      let(:template) { Template.new(anything) }
-      let(:recipients) { [anything] }
-
-      subject { described_class.new(client, template, recipients) }
-
-      it 'sets the instance variables' do
-        expect(subject.instance_variable_get(:@client)).to_not be_nil
-        expect(subject.instance_variable_get(:@template)).to_not be_nil
-        expect(subject.instance_variable_get(:@recipients)).to_not be_nil
-      end
-
-      context 'nil variables' do
-        context 'template is nil' do
-          let(:template) { nil }
-
-          it 'raises error' do
-            expect do
-              subject
-            end.to raise_error(InvalidTemplate, 'Template must be present')
-          end
-        end
-
-        context 'client is nil' do
-          let(:client) { nil }
-
-          it 'raises error' do
-            expect do
-              subject
-            end.to raise_error(InvalidClient, 'Client must be present')
-          end
-        end
-      end
-
-      context 'recipients' do
-        let(:first_recipient) { Recipient.new('someone@anything.com') }
-        let(:second_recipient) { Recipient.new('test@test.com') }
-        let(:recipients) { [first_recipient, second_recipient] }
-
-        it 'adds them to the template' do
-          expect(template).to receive(:add_recipient).with(first_recipient)
-          expect(template).to receive(:add_recipient).with(second_recipient)
-
-          subject
-        end
-      end
-    end
-
-    describe '#mail' do
-      subject { described_class.new(client, template, recipients) }
-
-      let(:mail_params) { {} }
-      let(:mail_to_h) { '' }
-
-      before do
-        allow(subject).to receive(:mail_params) { mail_params }
-        allow_any_instance_of(Mail).to receive(:to_h) { mail_to_h }
-        allow(client).to receive(:send)
-      end
-
-      it 'creates a new mail object' do
-        expect(Mail).to receive(:new).with(mail_params).and_call_original
-        subject.mail
-      end
-
-      it 'adds the template to the mail object' do
-        expect_any_instance_of(Mail).to receive(:template=).with(template)
-        subject.mail
-      end
-
-      it 'calls send on the client with the mail object' do
-        expect(client).to receive(:send).with(mail_to_h)
-        subject.mail
-      end
-    end
-  end
-end

data/spec/lib/sendgrid/template_spec.rb

@@ -1,61 +0,0 @@
-require_relative '../../../lib/sendgrid/template'
-
-module SendGrid
-  describe Template do
-    let(:id) { anything }
-    subject { described_class.new(id) }
-
-    describe '#initialize' do
-      it 'sets the id instance var' do
-        expect(subject.instance_variable_get(:@id)).to_not be_nil
-      end
-    end
-
-    describe '#add_to_smtpapi' do
-      let(:id) { rand(8999) }
-      let(:smtpapi) { Smtpapi::Header.new }
-
-      it 'adds enabled and the templates id' do
-        expect(smtpapi).to receive(:add_filter).with(:templates, :enable, 1)
-        expect(smtpapi).to receive(:add_filter).with(:templates, :template_id, id)
-        subject.add_to_smtpapi(smtpapi)
-      end
-
-      context 'smtpapi is nil' do
-        it 'does not error' do
-          expect do
-            subject.add_to_smtpapi(nil)
-          end.to_not raise_error
-        end
-      end
-
-      context 'with recipients' do
-        let(:substitution_key) { :foo }
-        let(:substitution_value) { :bar }
-        let(:recipients) do
-          [].tap do |recipients|
-            3.times.each do
-              r = Recipient.new("test+#{ rand(100) }@example.com")
-              r.add_substitution(substitution_key, substitution_value)
-              recipients << r
-            end
-          end
-        end
-
-        before do
-          recipients.each do |r|
-            subject.add_recipient(r)
-          end
-        end
-
-        it 'calls the recipients call to add to smtpapi' do
-          recipients.each do |recipient|
-            expect(recipient).to receive(:add_to_smtpapi).with(smtpapi)
-          end
-
-          subject.add_to_smtpapi(smtpapi)
-        end
-      end
-    end
-  end
-end

data/spec/lib/sendgrid_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe 'SendGrid' do
-  it 'should have a version' do
-    expect(SendGrid::VERSION).to eq('1.1.6')
-  end
-end