parity-sendgrid-api 0.0.4

data/spec/fixtures/schedule.json

@@ -0,0 +1,3 @@
+{
+  "date": "2013-10-30 18:01:40"
+}

data/spec/fixtures/sender_addresses/sender_address.json

@@ -0,0 +1,11 @@
+{
+  "city": "Anaheim",
+  "name": "SendGrid",
+  "zip": "92806",
+  "replyto": "contact@sendgrid.com",
+  "country": "US",
+  "state": "CA",
+  "address": "1065 N Pacificenter Drive, Suite 425",
+  "email": "contact@sendgrid.com",
+  "identity": "sendgrid"
+}

data/spec/fixtures/sender_addresses/sender_addresses.json

@@ -0,0 +1,11 @@
+[
+  {
+    "identity": "sendgrid"
+  },
+  {
+    "identity": "sendgrid helpdesk"
+  },
+  {
+    "identity": "sendgrid developers"
+  }
+]

data/spec/fixtures/stats.json

@@ -0,0 +1,50 @@
+[
+  {
+    "delivered":4792,
+    "unique_open":308,
+    "spamreport":3,
+    "unique_click":11,
+    "drop":57,
+    "request":5359,
+    "bounce":622,
+    "deferred":1975,
+    "processed":5302,
+    "date":"2013-06-18",
+    "open":481,
+    "click":11,
+    "blocked":29
+  },
+  {
+    "delivered":3,
+    "unique_open":17,
+    "unique_click":1,
+    "deferred":405,
+    "date":"2013-06-19",
+    "open":37,
+    "click":1
+  },
+  {
+    "date":"2013-06-20",
+    "deferred":381,
+    "unique_open":4,
+    "open":7,
+    "bounce":2
+  },
+  {
+    "unique_open":2,
+    "bounce":1,
+    "deferred":113,
+    "date":"2013-06-21",
+    "open":8,
+    "blocked":31
+  },
+  {
+    "date":"2013-06-23",
+    "unique_open":2,
+    "open":2
+  },
+  {
+    "date":"2013-06-24",
+    "open":1
+  }
+]

data/spec/fixtures/success.json

@@ -0,0 +1,3 @@
+{
+  "message":"success"
+}

data/spec/sendgrid/api/client_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    describe Client do
+
+      subject { described_class.new(user, key) }
+      let(:user) { 'some user' }
+      let(:key) { 'some key' }
+
+      its(:user) { should == user }
+      its(:key) { should == key }
+
+      it { should respond_to(:profile) }
+      it { should respond_to(:stats) }
+      it { should respond_to(:mail) }
+      it { should respond_to(:lists) }
+      it { should respond_to(:emails) }
+      it { should respond_to(:sender_addresses) }
+      it { should respond_to(:categories) }
+      it { should respond_to(:marketing_emails) }
+      it { should respond_to(:recipients) }
+      it { should respond_to(:schedule) }
+
+      its(:profile) { should_not be_nil }
+      its(:stats) { should_not be_nil }
+      its(:mail) { should_not be_nil }
+      its(:lists) { should_not be_nil }
+      its(:emails) { should_not be_nil }
+      its(:sender_addresses) { should_not be_nil }
+      its(:categories) { should_not be_nil }
+      its(:marketing_emails) { should_not be_nil }
+      its(:recipients) { should_not be_nil }
+      its(:schedule) { should_not be_nil }
+
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    module Entities
+      describe Category do
+        subject { described_class.new }
+
+        it { should respond_to(:category) }
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    module Entities
+      describe Email do
+        subject { described_class.new }
+
+        it { should respond_to(:email) }
+        it { should respond_to(:name) }
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,279 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    module Entities
+      describe Entity do
+
+        subject { described_class }
+
+        after do
+          described_class.clear_attributes
+        end
+
+        describe '.clear_attributes' do
+          before do
+            subject.attribute :attr1
+          end
+
+          it 'should clear the attributes' do
+            subject.clear_attributes
+            subject.attributes.should be_empty
+          end
+        end
+
+        describe '.attribute' do
+          context 'when the attributes are empty' do
+            before do
+              subject.clear_attributes
+            end
+
+            it 'should set the entity attributes' do
+              subject.attribute :attr1, :attr2
+              subject.attributes.should have(2).items
+            end
+          end
+
+          context 'when the attributes are not empty' do
+            before do
+              subject.clear_attributes
+              subject.attribute :attr1
+            end
+
+            it 'should add attributes to the entity' do
+              subject.attribute :attr2
+              subject.attributes.should have(2).items
+            end
+          end
+
+          context 'when the attributes are repeated' do
+            before do
+              subject.clear_attributes
+              subject.attribute :attr1
+            end
+
+            it 'should add distinct attributes to the entity' do
+              subject.attribute :attr1, :attr2
+              subject.attributes.should have(2).items
+            end
+          end
+        end
+
+        describe '#attributes' do
+          before do
+            subject.clear_attributes
+          end
+
+          context 'without attributes' do
+            its(:attributes) { should be_empty }
+          end
+
+          context 'with attributes' do
+            before do
+              subject.attribute :attr1, :attr2
+            end
+
+            its(:attributes) { should have(2).items }
+          end
+        end
+
+        describe '.from_response' do
+          context 'when response is an array' do
+            before do
+              response.should_receive(:body).and_return([item1, item2])
+            end
+            let(:response) { double('response') }
+            let(:item1) { double('item').as_null_object }
+            let(:item2) { double('item').as_null_object }
+
+            subject { described_class.from_response(response) }
+
+            it { should have(2).items }
+            its([0]) { should be_instance_of(described_class) }
+            its([1]) { should be_instance_of(described_class) }
+          end
+
+          context 'when response is a hash' do
+            before do
+              response.should_receive(:body).and_return(item)
+            end
+            let(:response) { double('response') }
+            let(:item) { Hash.new }
+
+            subject { described_class.from_response(response) }
+
+            it { should be_instance_of(described_class) }
+          end
+
+          context 'when response is a string' do
+            before do
+              response.should_receive(:body).and_return(item)
+            end
+            let(:response) { double('response') }
+            let(:item) { 'some string' }
+
+            subject { described_class.from_response(response) }
+
+            it { should be_nil }
+          end
+
+          context 'when response is a number' do
+            before do
+              response.should_receive(:body).and_return(item)
+            end
+            let(:response) { double('response') }
+            let(:item) { 45 }
+
+            subject { described_class.from_response(response) }
+
+            it { should be_nil }
+          end
+
+          context 'when response is a nil object' do
+            before do
+              response.should_receive(:body).and_return(item)
+            end
+            let(:response) { double('response') }
+            let(:item) { nil }
+
+            subject { described_class.from_response(response) }
+
+            it { should be_nil }
+          end
+        end
+
+        describe '.new' do
+          before do
+            described_class.attribute :attr1, :attr2
+          end
+
+          context 'creating entity with no attributes' do
+            subject { entity }
+            let(:entity) { described_class.new }
+
+            it { should respond_to(:attr1) }
+            it { should respond_to(:attr2) }
+
+            its(:attr1) { should be_nil }
+            its(:attr2) { should be_nil }
+
+            it 'should raise error for invalid attributes' do
+              expect { subject.attr3 }.to raise_error(NameError)
+            end
+
+            it 'should set attr1' do
+              subject.attr1 = 'attr1 value'
+              subject.attr1.should == 'attr1 value'
+            end
+
+            it 'should set attr2' do
+              subject.attr1 = 'attr2 value'
+              subject.attr1.should == 'attr2 value'
+            end
+
+            describe '#attributes' do
+              subject { entity.attributes }
+
+              it { should be_empty }
+            end
+
+            describe '#as_json' do
+              subject { entity.as_json }
+
+              it { should be_empty }
+            end
+
+            describe '#to_json' do
+              subject { JSON.parse(entity.to_json) }
+
+              it { should be_empty }
+            end
+          end
+
+          context 'creating entity with valid attributes' do
+            subject { entity }
+            let(:entity) { described_class.new(:attr1 => attr1, :attr2 => attr2) }
+            let(:attr1) { 'attr1 value' }
+            let(:attr2) { 'attr2 value' }
+
+            it { should respond_to(:attr1) }
+            it { should respond_to(:attr2) }
+
+            its(:attr1) { should == attr1 }
+            its(:attr2) { should == attr2 }
+
+            describe '#attributes' do
+              subject { entity.attributes }
+
+              it { should have(2).items }
+              it { should include(:attr1) }
+              it { should include(:attr2) }
+              it { should_not include(:attr3) }
+            end
+
+            describe '#as_json' do
+              subject { entity.as_json }
+
+              it { should have(2).items }
+              it { should include(:attr1) }
+              it { should include(:attr2) }
+              it { should_not include(:attr3) }
+            end
+
+            describe '#to_json' do
+              subject { JSON.parse(entity.to_json) }
+
+              it { should have(2).items }
+              it { should include('attr1') }
+              it { should include('attr2') }
+              it { should_not include('attr3') }
+            end
+          end
+
+          context 'creating entity with invalid attributes' do
+            subject { entity }
+            let(:entity) { described_class.new(:attr1 => attr1, :attr2 => attr2, :attr3 => attr3) }
+            let(:attr1) { 'attr1 value' }
+            let(:attr2) { 'attr2 value' }
+            let(:attr3) { 'attr3 value' }
+
+            its(:attr1) { should == attr1 }
+            its(:attr2) { should == attr2 }
+
+            it 'should raise error for invalid attributes' do
+              expect { subject.attr3 }.to raise_error(NameError)
+            end
+
+            describe '#attributes' do
+              subject { entity.attributes }
+
+              it { should have(2).items }
+              it { should include(:attr1) }
+              it { should include(:attr2) }
+              it { should_not include(:attr3) }
+            end
+
+            describe '#as_json' do
+              subject { entity.as_json }
+
+              it { should have(2).items }
+              it { should include(:attr1) }
+              it { should include(:attr2) }
+              it { should_not include(:attr3) }
+            end
+
+            describe '#to_json' do
+              subject { JSON.parse(entity.to_json) }
+
+              it { should have(2).items }
+              it { should include('attr1') }
+              it { should include('attr2') }
+              it { should_not include('attr3') }
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module Sendgrid
+  module API
+    module Entities
+      describe List do
+        subject { described_class.new }
+
+        it { should respond_to(:list) }
+
+        describe '.from_object' do
+          context 'when object is a String' do
+            let(:object) { 'my list name' }
+            subject { described_class.from_object(object) }
+            it { should be_instance_of(described_class) }
+            its(:list) { should == object }
+          end
+
+          context 'when object is a List' do
+            let(:object) { described_class.new(:list => 'my list name') }
+            subject { described_class.from_object(object) }
+            it { should == object }
+          end
+
+          context 'when object is nil' do
+            let(:object) { nil }
+            subject { described_class.from_object(object) }
+            it { should be_nil }
+          end
+        end
+      end
+    end
+  end
+end