sendgrid-api 0.0.2 → 0.0.3

data/spec/sendgrid/api/newsletter/sender_addresses_spec.rb

@@ -0,0 +1,300 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    module Newsletter
+      module SenderAddresses
+        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(:sender_address) { Entities::SenderAddress.new(:identity => identity, :email => email) }
+          let(:identity) { 'my sender address' }
+          let(:email) { 'john@example.com' }
+
+          describe '#add' do
+            let(:url) { 'newsletter/identity/add.json' }
+            let(:stub_post) { sg_mock.stub_post(url, sender_address.as_json) }
+            subject { service.add(sender_address) }
+
+            context 'when add a sender address successfully' do
+              it_behaves_like 'a success response'
+            end
+
+            context 'when the sender address already exists' do
+              it_behaves_like 'an unauthorized response'
+            end
+
+            context 'when the sender address is invalid' do
+              it_behaves_like 'an invalid fields response'
+            end
+
+            context 'when permission failed' do
+              it_behaves_like 'a forbidden response'
+            end
+          end
+
+          describe '#edit' do
+            let(:url) { 'newsletter/identity/edit.json' }
+            let(:stub_post) { sg_mock.stub_post(url, sender_address.as_json) }
+            subject { service.edit(sender_address) }
+
+            context 'when edit a sender address successfully' do
+              it_behaves_like 'a success response'
+            end
+
+            context 'when edit the sender address identity successfully' do
+              let(:stub_post) { sg_mock.stub_post(url, sender_address.as_json.merge(:newidentity => new_identity)) }
+              let(:new_identity) { 'my new sender address' }
+              subject { service.edit(sender_address, new_identity) }
+              it_behaves_like 'a success response'
+            end
+
+            context 'when the sender address is invalid' do
+              it_behaves_like 'a does not exist response'
+            end
+
+            context 'when permission failed' do
+              it_behaves_like 'a forbidden response'
+            end
+          end
+
+          describe '#get' do
+            let(:url) { 'newsletter/identity/get.json' }
+            let(:stub_post) { sg_mock.stub_post(url, :identity => identity) }
+            subject { service.get(sender_address) }
+
+            context 'when get the sender address successfully' do
+              before do
+                stub_post.to_return(:body => fixture('sender_addresses/sender_address.json'))
+              end
+
+              context 'with name' do
+                subject { service.get(identity) }
+                its(:identity) { should == 'sendgrid' }
+              end
+
+              context 'with object' do
+                its(:identity) { should == 'sendgrid' }
+              end
+            end
+
+            context 'when the sender address is not found' do
+              before do
+                stub_post.to_return(:body => fixture('errors/does_not_exist.json'), :status => 401)
+              end
+
+              it 'raises an error' do
+                expect { subject }.to raise_error(REST::Errors::Unauthorized)
+              end
+            end
+
+            context 'when permission failed' do
+              it_behaves_like 'a forbidden response'
+            end
+          end
+
+          describe '#list' do
+            let(:url) { 'newsletter/identity/list.json' }
+            let(:stub_post) { sg_mock.stub_post(url) }
+            subject { service.list }
+
+            context 'when list sender addresses successfully' do
+              before do
+                stub_post.to_return(:body => fixture('sender_addresses/sender_addresses.json'))
+              end
+              it { should have(3).items }
+              describe 'first item' do
+                subject { service.list.first }
+                its(:identity) { should == 'sendgrid' }
+              end
+            end
+
+            context 'when permission failed' do
+              it_behaves_like 'a forbidden response'
+            end
+          end
+
+          describe '#delete' do
+            let(:url) { 'newsletter/identity/delete.json' }
+            let(:stub_post) { sg_mock.stub_post(url, :identity => identity) }
+            subject { service.delete(sender_address) }
+
+            context 'when delete the sender address successfully' do
+              it_behaves_like 'a success response'
+            end
+
+            context 'when the sender address is not found' do
+              it_behaves_like 'a does not exist response'
+            end
+
+            context 'when permission failed' do
+              it_behaves_like 'a forbidden response'
+            end
+          end
+
+          describe 'online tests', :online => true do
+            include_examples 'online tests'
+            let(:online) { Online.new(env_user, env_key) }
+            let(:sender_address) { online.sender_address_example }
+
+            context 'when credentials are valid' do
+              let(:resource) { REST::Resource.new(env_user, env_key) }
+
+              describe '#add' do
+                context 'when add a sender address successfully' do
+                  after do
+                    subject.delete(sender_address)
+                  end
+                  it 'adds the sender address' do
+                    subject.add(sender_address).success?.should be_true
+                  end
+                end
+
+                context 'when the sender address already exists' do
+                  before do
+                    subject.add(sender_address)
+                  end
+                  after do
+                    subject.delete(sender_address)
+                  end
+                  it 'raises an error' do
+                    expect { subject.add(sender_address) }.to raise_error(Sendgrid::API::REST::Errors::Unauthorized)
+                  end
+                end
+
+                context 'when the sender address is invalid' do
+                  let(:email) { nil }
+                  it 'raises an error' do
+                    sender_address.email = email
+                    expect { subject.add(sender_address) }.to raise_error(Sendgrid::API::REST::Errors::BadRequest)
+                  end
+                end
+              end
+
+              describe '#edit' do
+                context 'when edit a sender address successfully' do
+                  let(:address) { 'new address' }
+                  before do
+                    subject.add(sender_address)
+                  end
+                  after do
+                    subject.delete(sender_address)
+                  end
+                  it 'edits the sender address' do
+                    sender_address.address = address
+                    subject.edit(sender_address).success?.should be_true
+                  end
+                end
+
+                context 'when edit the sender address identity successfully' do
+                  let(:newidentity) { 'sendgrid-api sender address new' }
+                  before do
+                    subject.add(sender_address)
+                  end
+                  after do
+                    subject.delete(newidentity)
+                  end
+                  it 'edits the sender address' do
+                    subject.edit(sender_address, newidentity).success?.should be_true
+                  end
+                end
+
+                context 'when the sender address is invalid' do
+                  it 'raises an error' do
+                    expect { subject.edit(sender_address) }.to raise_error(Sendgrid::API::REST::Errors::Unauthorized)
+                  end
+                end
+              end
+
+              describe '#get' do
+                context 'when get the sender address successfully' do
+                  before do
+                    subject.add(sender_address)
+                  end
+                  after do
+                    subject.delete(sender_address)
+                  end
+                  it 'edits the sender address' do
+                    sender = subject.get(sender_address)
+                    sender.name.should == sender_address.name
+                    sender.address.should == sender_address.address
+                  end
+                end
+
+                context 'when the sender address is not found' do
+                  it 'raises an error' do
+                    expect { subject.edit(sender_address) }.to raise_error(Sendgrid::API::REST::Errors::Unauthorized)
+                  end
+                end
+              end
+
+              describe '#list' do
+                context 'when list sender addresses successfully' do
+                  it 'gets all the sender addresses' do
+                    subject.list.should_not be_empty
+                  end
+                end
+              end
+
+              describe '#delete' do
+                context 'when delete the sender address successfully' do
+                  before do
+                    subject.add(sender_address)
+                  end
+                  it 'deletes the sender address' do
+                    subject.delete(sender_address).success?.should be_true
+                  end
+                end
+
+                context 'when the sender address is not found' do
+                  it 'raises an error' do
+                    expect { subject.delete(sender_address) }.to raise_error(Sendgrid::API::REST::Errors::Unauthorized)
+                  end
+                end
+              end
+            end
+
+            context 'when credentials are invalid' do
+              describe '#add' do
+                it 'raises an error' do
+                  expect { subject.add(sender_address) }.to raise_error(REST::Errors::Forbidden)
+                end
+              end
+
+              describe '#edit' do
+                it 'raises an error' do
+                  expect { subject.edit(sender_address) }.to raise_error(REST::Errors::Forbidden)
+                end
+              end
+
+              describe '#get' do
+                it 'raises an error' do
+                  expect { subject.get(sender_address) }.to raise_error(REST::Errors::Forbidden)
+                end
+              end
+
+              describe '#list' do
+                it 'raises an error' do
+                  expect { subject.list }.to raise_error(REST::Errors::Forbidden)
+                end
+              end
+
+              describe '#delete' do
+                it 'raises an error' do
+                  expect { subject.delete(sender_address) }.to raise_error(REST::Errors::Forbidden)
+                end
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -41,41 +41,65 @@ module Sendgrid
 
                 it { should == Errors::BadRequest.new('error message') }
               end
-            end
 
-            context 'when response has body error' do
-              context 'known status' do
+              context 'with multiple messages' do
                 let(:env) do
-                  { :status => 200,
-                    :body => { :error => { :code => 400 } } }
+                  { :status => 400,
+                    :body => { :errors => ['error message 1', 'error message 2'] } }
                 end
 
                 subject { described_class.from_response(env) }
 
-                it { should be_instance_of(Errors::BadRequest) }
+                it { should == Errors::BadRequest.new('error message 1, error message 2') }
               end
+            end
 
-              context 'unknown status' do
-                let(:env) do
-                  { :status => 200,
-                    :body => { :error => { :code => 413 } } }
+            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
 
-                subject { described_class.from_response(env) }
+                context 'unknown status' do
+                  let(:env) do
+                    { :status => 200,
+                      :body => { :error => { :code => 413 } } }
+                  end
 
-                it { should be_instance_of(Errors::Unknown) }
+                  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 'with message' do
+              context 'when error is a String' do
                 let(:env) do
                   { :status => 200,
-                    :body => { :error => { :code => 400,
-                                           :message => 'error message' } } }
+                    :body => { :error => 'error message' } }
                 end
 
                 subject { described_class.from_response(env) }
 
-                it { should == Errors::BadRequest.new('error message') }
+                it { should == Errors::UnprocessableEntity.new('error message') }
               end
             end
 

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

@@ -66,6 +66,8 @@ module Sendgrid
             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
 

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