sendgrid-api 0.0.1 → 0.0.2

data/spec/sendgrid/api/entities/profile_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    module Entities
+      describe Profile do
+        subject { described_class.new }
+
+        it { should respond_to(:username) }
+        it { should respond_to(:email) }
+        it { should respond_to(:active) }
+        it { should respond_to(:first_name) }
+        it { should respond_to(:last_name) }
+        it { should respond_to(:address) }
+        it { should respond_to(:address2) }
+        it { should respond_to(:city) }
+        it { should respond_to(:state) }
+        it { should respond_to(:zip) }
+        it { should respond_to(:country) }
+        it { should respond_to(:phone) }
+        it { should respond_to(:website) }
+        it { should respond_to(:website_access) }
+      end
+    end
+  end
+end

data/spec/sendgrid/api/entities/response_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    module Entities
+      describe Response do
+        subject { described_class.new }
+
+        it { should respond_to(:message) }
+        it { should respond_to(:errors) }
+
+        context 'message is true' do
+          subject { described_class.new(:message => 'success') }
+
+          its(:success?) { should be_true }
+          its(:error?) { should be_false }
+        end
+
+        context 'message is error' do
+          subject { described_class.new(:message => 'error') }
+
+          its(:success?) { should be_false }
+          its(:error?) { should be_true }
+        end
+      end
+    end
+  end
+end

data/spec/sendgrid/api/entities/stats_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    module Entities
+      describe Stats do
+        subject { described_class.new }
+
+        it { should respond_to(:delivered) }
+        it { should respond_to(:request) }
+        it { should respond_to(:unique_open) }
+        it { should respond_to(:unique_click) }
+        it { should respond_to(:processed) }
+        it { should respond_to(:date) }
+        it { should respond_to(:open) }
+        it { should respond_to(:click) }
+        it { should respond_to(:blocked) }
+        it { should respond_to(:spamreport) }
+        it { should respond_to(:drop) }
+        it { should respond_to(:bounce) }
+        it { should respond_to(:deferred) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+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
+            end
+
+            context 'when response has body error' 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 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,143 @@
+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
+            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