parity-sendgrid-api 0.0.4

data/spec/sendgrid/api/rest/errors/error_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    module REST
+      module Errors
+        describe Error do
+          subject { described_class }
+
+          describe '.from_response' do
+            context 'when response has a status error' do
+              context 'known status' do
+                let(:env) do
+                  { :status => 400,
+                    :body => nil }
+                end
+
+                subject { described_class.from_response(env) }
+
+                it { should be_instance_of(Errors::BadRequest) }
+              end
+
+              context 'unknown status' do
+                let(:env) do
+                  { :status => 413,
+                    :body => nil }
+                end
+
+                subject { described_class.from_response(env) }
+
+                it { should be_instance_of(Errors::Unknown) }
+              end
+
+              context 'with message' do
+                let(:env) do
+                  { :status => 400,
+                    :body => { :error => 'error message' } }
+                end
+
+                subject { described_class.from_response(env) }
+
+                it { should == Errors::BadRequest.new('error message') }
+              end
+
+              context 'with multiple messages' do
+                let(:env) do
+                  { :status => 400,
+                    :body => { :errors => ['error message 1', 'error message 2'] } }
+                end
+
+                subject { described_class.from_response(env) }
+
+                it { should == Errors::BadRequest.new('error message 1, error message 2') }
+              end
+            end
+
+            context 'when response has body error' do
+              context 'when error is a Hash' do
+                context 'known status' do
+                  let(:env) do
+                    { :status => 200,
+                      :body => { :error => { :code => 400 } } }
+                  end
+
+                  subject { described_class.from_response(env) }
+
+                  it { should be_instance_of(Errors::BadRequest) }
+                end
+
+                context 'unknown status' do
+                  let(:env) do
+                    { :status => 200,
+                      :body => { :error => { :code => 413 } } }
+                  end
+
+                  subject { described_class.from_response(env) }
+
+                  it { should be_instance_of(Errors::Unknown) }
+                end
+
+                context 'with message' do
+                  let(:env) do
+                    { :status => 200,
+                      :body => { :error => { :code => 400,
+                                             :message => 'error message' } } }
+                  end
+
+                  subject { described_class.from_response(env) }
+
+                  it { should == Errors::BadRequest.new('error message') }
+                end
+              end
+
+              context 'when error is a String' do
+                let(:env) do
+                  { :status => 200,
+                    :body => { :error => 'error message' } }
+                end
+
+                subject { described_class.from_response(env) }
+
+                it { should == Errors::UnprocessableEntity.new('error message') }
+              end
+            end
+
+            context 'when response has no error' do
+              let(:env) do
+                { :status => 200,
+                  :body => nil }
+              end
+
+              subject { described_class.from_response(env) }
+
+              it { should be_nil }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sendgrid/api/rest/resource_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    module REST
+      describe Resource do
+        subject { resource }
+        let(:resource) { described_class.new(user, key) }
+        let(:user) { 'my_user' }
+        let(:key) { 'my_key' }
+
+        its(:user) { should == user }
+        its(:key) { should == key }
+
+        it 'should have a valid ENDPOINT' do
+          described_class::ENDPOINT.should == 'https://sendgrid.com/api'
+        end
+
+        describe '#post' do
+          let(:url) { 'any_path' }
+          let(:response) { double('response') }
+
+          context 'without params' do
+            before do
+              subject.should_receive(:request).with(:post, url, {}).and_return(response)
+            end
+
+            it 'should perform the request' do
+              subject.post(url).should == response
+            end
+          end
+
+          context 'with params' do
+            before do
+              subject.should_receive(:request).with(:post, url, params).and_return(response)
+            end
+            let(:params) { {:name => 'my name'} }
+
+            it 'should perform the request' do
+              subject.post(url, params).should == response
+            end
+          end
+        end
+
+        describe '#request' do
+          let(:url) { 'any_path' }
+          let(:sg_mock) { Sendgrid::Mock.new(user, key) }
+
+          context 'without params' do
+            before do
+              sg_mock.stub_post(url)
+            end
+
+            it 'should perform a request' do
+              subject.send(:request, :post, url)
+              sg_mock.a_post(url).should have_been_made
+            end
+          end
+
+          context 'with params' do
+            before do
+              sg_mock.stub_post(url, params)
+            end
+            let(:params) { {:name => 'my name'} }
+
+            it 'should perform a request' do
+              subject.send(:request, :post, url, params)
+              sg_mock.a_post(url, params).should have_been_made
+              params.should_not include(:api_user)
+              params.should_not include(:api_key)
+            end
+          end
+
+          context 'catches the errors' do
+            it 'catches Faraday errors' do
+              subject.stub(:connection).and_raise(Faraday::Error::ClientError.new('unknown error'))
+              expect { subject.send(:request, :post, url) }.to raise_error Sendgrid::API::REST::Errors::Unknown
+            end
+
+            it 'catches JSON::ParserError errors' do
+              subject.stub(:connection).and_raise(JSON::ParserError.new('unexpected token"'))
+              expect { subject.send(:request, :post, url) }.to raise_error Sendgrid::API::REST::Errors::Unknown
+            end
+
+            it 'catches status errors' do
+              sg_mock.stub_post(url).to_return(:status => 400)
+              expect { subject.send(:request, :post, url) }.to raise_error Sendgrid::API::REST::Errors::BadRequest
+            end
+
+            it 'catches body errors' do
+              sg_mock.stub_post(url).to_return(:body => {:error => {:code => 401}}.to_json)
+              expect { subject.send(:request, :post, url) }.to raise_error Sendgrid::API::REST::Errors::Unauthorized
+            end
+          end
+
+          context 'parses body as JSON' do
+            before do
+              sg_mock.stub_post(url).to_return(:body => {'name' => 'my name'}.to_json)
+            end
+
+            subject { resource.send(:request, :post, url).body }
+
+            it { should be_instance_of(Hash) }
+            its([:name]) { should == 'my name'}
+          end
+        end
+
+        describe '#middleware' do
+          it 'should be a valid Faraday middleware' do
+            subject.send(:middleware).should be_instance_of(Faraday::Builder)
+          end
+
+          it 'should memoize the middleware' do
+            middleware = double('middleware')
+            Faraday::Builder.should_receive(:new).once.and_return(middleware)
+
+            subject.send(:middleware).should == middleware
+            subject.send(:middleware).should == middleware
+          end
+        end
+
+        describe '#connection' do
+          it 'should be a valid Faraday connection' do
+            subject.send(:connection).should be_instance_of(Faraday::Connection)
+          end
+
+          it 'should memoize the connection' do
+            connection = double('connection')
+            Faraday.should_receive(:new).once.and_return(connection)
+
+            subject.send(:connection).should == connection
+            subject.send(:connection).should == connection
+          end
+        end
+
+        describe '#authentication_params' do
+          subject { resource.send(:authentication_params) }
+
+          its([:api_user]) { should == user }
+          its([:api_key]) { should == key }
+        end
+      end
+    end
+  end
+end

data/spec/sendgrid/api/rest/response/parse_error_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    module REST
+      module Response
+        describe ParseError do
+
+          subject { described_class.new }
+
+          describe '#on_complete' do
+            context 'response with error' do
+              before do
+                REST::Errors::Error.should_receive(:from_response).and_return(Errors::Error)
+              end
+              let(:env) { double('env') }
+
+              it 'should raise the error' do
+                expect { subject.on_complete(env) }.to raise_error(Errors::Error)
+              end
+            end
+
+            context 'response without error' do
+              before do
+                REST::Errors::Error.should_receive(:from_response).and_return(nil)
+              end
+              let(:env) { double('env') }
+
+              it 'should return nil' do
+                subject.on_complete(env).should be_nil
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/sendgrid/api/rest/response/parse_json_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    module REST
+      module Response
+        describe ParseJson do
+
+          subject { parse_json }
+          let(:parse_json) { described_class.new }
+
+          describe '#parse' do
+            context 'body is nil' do
+              let(:body) { nil }
+
+              it 'should return nil' do
+                subject.parse(body).should be_nil
+              end
+            end
+
+            context 'body is not a valid JSON' do
+              let(:body) { 'some plain text' }
+
+              it 'should raise JSON::ParserError' do
+                expect { subject.parse(body) }.to raise_error(JSON::ParserError)
+              end
+            end
+
+            context 'body is a valid JSON' do
+              let(:body) do
+                { 'name' => 'my name' }.to_json
+              end
+
+              subject { parse_json.parse(body) }
+
+              it { should be_instance_of(Hash) }
+              its([:name]) { should == 'my name'}
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/sendgrid/api/service_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    describe Service do
+
+      subject { described_class.new(resource) }
+      let(:resource) { double('resource') }
+
+      its(:resource) { should == resource }
+
+      describe '#perform_request' do
+        before do
+          entity.should_receive(:from_response).and_return(response)
+        end
+        let(:entity) { double('entity') }
+        let(:response) { double('response') }
+        let(:url) { double('url') }
+
+        context 'with params' do
+          before do
+            resource.should_receive(:post).with(url, params)
+          end
+          let(:params) { double('params') }
+
+          it 'should perform a request' do
+            subject.perform_request(entity, url, params).should == response
+          end
+        end
+
+        context 'without params' do
+          before do
+            resource.should_receive(:post).with(url, {})
+          end
+
+          it 'should perform a request' do
+            subject.perform_request(entity, url).should == response
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/sendgrid/api/version_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+module Sendgrid
+  describe API do
+
+    it 'has a non-null VERSION constant' do
+      API::VERSION.should_not be_nil
+    end
+
+  end
+end

data/spec/sendgrid/api/web/mail_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    module Web
+      module Mail
+        describe Services do
+
+          subject { service }
+          let(:service) { described_class.new(resource) }
+          let(:resource) { REST::Resource.new(user, key) }
+          let(:user) { 'my_user' }
+          let(:key) { 'my_key' }
+          let(:sg_mock) { Sendgrid::Mock.new(user, key) }
+
+          let(:to) { 'test@coffeebeantech.com' }
+          let(:from) { 'test@coffeebeantech.com' }
+          let(:email_subject) { 'sendgrid-api mail test' }
+          let(:text) { 'This is an email to test the sendgrid-api gem' }
+          let(:files) do
+            { 'sample1.txt' => sample_file(:name => 'sample1.txt'),
+              'sample2.txt' => sample_file(:name => 'sample2.txt') }
+          end
+          let(:x_smtpapi) do
+            { :category => ['sendgrid-api test'] }.to_json
+          end
+          let(:required_options) do
+            { :to => to, :subject => email_subject, :text => text, :from => from }
+          end
+
+          describe '#mail' do
+            let(:url) { 'mail.send.json' }
+
+            context 'with required fields' do
+              let(:stub_post) { sg_mock.stub_post(url, required_options) }
+              subject { service.send(required_options) }
+              it_behaves_like 'a success response'
+            end
+
+            context 'without required fields' do
+              let(:stub_post) { sg_mock.stub_post(url, :to => to) }
+              subject { service.send(:to => to) }
+              it_behaves_like 'an invalid fields response'
+            end
+
+            context 'with files attached' do
+              let(:stub_post) { stub_request(:post, sg_mock.uri(url)).with(:body => /sample1.txt/) }
+              subject { service.send(required_options.merge(:files => files)) }
+              it_behaves_like 'a success response'
+            end
+
+            context 'with SMTP API headers' do
+              let(:stub_post) { sg_mock.stub_post(url, :to => to, :subject => email_subject, :text => text, :from => from, 'x-smtpapi' => x_smtpapi) }
+              subject { service.send(required_options.merge(:x_smtpapi => x_smtpapi)) }
+              it_behaves_like 'a success response'
+            end
+
+            context 'when permission failed' do
+              let(:stub_post) { sg_mock.stub_post(url) }
+              subject { service.send }
+              it_behaves_like 'a bad request response'
+            end
+          end
+
+          describe 'online tests', :online => true do
+            include_examples 'online tests'
+
+            context 'when credentials are valid' do
+              let(:resource) { REST::Resource.new(env_user, env_key) }
+
+              describe '#mail' do
+                context 'with required fields' do
+                  it 'sends the email' do
+                    subject.send(required_options).success?.should be_true
+                  end
+                end
+
+                context 'without required fields' do
+                  it 'raises an error' do
+                    expect { subject.send(:to => to) }.to raise_error(REST::Errors::BadRequest)
+                  end
+                end
+
+                context 'with files attached' do
+                  it 'sends the email' do
+                    subject.send(required_options.merge(:files => files)).success?.should be_true
+                  end
+                end
+
+                context 'with SMTP API headers' do
+                  it 'sends the email' do
+                    subject.send(required_options.merge(:x_smtpapi => x_smtpapi)).success?.should be_true
+                  end
+                end
+              end
+            end
+
+            context 'when credentials are invalid' do
+              describe '#mail' do
+                it 'raises error' do
+                  expect { subject.send(required_options) }.to raise_error(REST::Errors::BadRequest)
+                end
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end