sendgrid4r 0.2.0 → 0.3.0

data/spec/contacts/segments_spec.rb

@@ -1,94 +1,226 @@
 # encoding: utf-8
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe 'SendGrid4r::REST::Contacts::Segments' do
-  before :all do
-    Dotenv.load
-    @client = SendGrid4r::Client.new(
-      ENV['SENDGRID_USERNAME'], ENV['SENDGRID_PASSWORD'])
-    @name = 'test_segment'
-    @edit_name = 'test_segment_edit'
-    @field = 'last_name'
-    @value = 'Miller'
-    @operator = 'eq'
-    @and_or = ''
-    @condition_factory = SendGrid4r::Factory::ConditionFactory.new
-    @segment_factory = SendGrid4r::Factory::SegmentFactory.new
-  end
-
-  context 'always' do
-    it 'is normal' do
+describe SendGrid4r::REST::Contacts::Segments do
+  describe 'integration test' do
+    before do
       begin
-        # celan up test env
-        segments = @client.get_segments
-        expect(segments.segments.length >= 0).to eq(true)
-        segments.segments.each do |segment|
-          next if segment.name != @name && segment.name != @edit_name
-          @client.delete_segment(segment.id)
+        Dotenv.load
+        @client = SendGrid4r::Client.new(
+          username: ENV['SENDGRID_USERNAME'],
+          password: ENV['SENDGRID_PASSWORD'])
+        @name1 = 'test_segment1'
+        @name2 = 'test_segment2'
+        @edit_name1 = 'test_segment_edit'
+        @field = 'last_name1'
+        @value = 'Miller'
+        @operator = 'eq'
+        @and_or = ''
+        @condition_factory = SendGrid4r::Factory::ConditionFactory.new
+        @segment_factory = SendGrid4r::Factory::SegmentFactory.new
+
+        # celan up test env(segment)
+        @client.get_segments.segments.each do |segment|
+          @client.delete_segment(segment.id) if segment.name == @name1
+          @client.delete_segment(segment.id) if segment.name == @edit_name1
+          @client.delete_segment(segment.id) if segment.name == @name2
+        end
+        # clean up test env(custom_fields)
+        @client.get_custom_fields.custom_fields.each do |field|
+          @client.delete_custom_field(field.id) if field.name == @field
         end
-        # post a segment
-        condition = @condition_factory.create(
-          field: @field,
-          value: @value,
-          operator: @operator,
-          and_or: @and_or
+        # post a custom field and a segment
+        @client.post_custom_field(@field, 'text')
+        @condition = @condition_factory.create(
+          field: @field, value: @value, operator: @operator, and_or: @and_or
         )
-        params = @segment_factory.create(
-          name: @name, conditions: [condition]
+        params1 = @segment_factory.create(
+          name: @name1, conditions: [@condition]
         )
-        new_segment = @client.post_segment(params)
-        expect(new_segment.id.is_a?(Fixnum)).to eq(true)
-        expect(new_segment.name).to eq(@name)
-        expect(new_segment.list_id).to eq(nil)
-        expect(new_segment.conditions.length).to eq(1)
-        expect(new_segment.recipient_count).to eq(0)
-        new_condition = new_segment.conditions[0]
-        expect(new_condition.field).to eq(@field)
-        expect(new_condition.value).to eq(@value)
-        expect(new_condition.operator).to eq(@operator)
-        expect(new_condition.and_or).to eq(nil)
-        expect(new_segment.recipient_count).to eq(0)
-        # get a single segment
-        actual_segment = @client.get_segment(new_segment.id)
-        expect(actual_segment.id).to eq(new_segment.id)
-        expect(actual_segment.name).to eq(new_segment.name)
-        expect(actual_segment.list_id).to eq(nil)
-        actual_condition = actual_segment.conditions[0]
-        expect(actual_condition.field).to eq(@field)
-        expect(actual_condition.value).to eq(@value)
-        expect(actual_condition.operator).to eq(@operator)
-        expect(actual_condition.and_or).to eq(nil)
-        expect(actual_segment.recipient_count).to eq(1)
-        # update the segment
-        edit_condition = @condition_factory.create(
-          field: @field,
-          value: @value,
-          operator: @operator,
-          and_or: @and_or
+        @segment1 = @client.post_segment(params1)
+      rescue => e
+        puts e.inspect
+        raise e
+      end
+    end
+
+    context 'without block call' do
+      it '#post_segment' do
+        begin
+          params2 = @segment_factory.create(
+            name: @name2, conditions: [@condition]
+          )
+          segment = @client.post_segment(params2)
+          expect(segment.id).to be_a(Fixnum)
+          expect(segment.name).to eq(@name2)
+          expect(segment.list_id).to eq(nil)
+          expect(segment.conditions.length).to eq(1)
+          expect(segment.recipient_count).to eq(0)
+          condition = segment.conditions[0]
+          expect(condition.field).to eq(@field)
+          expect(condition.value).to eq(@value)
+          expect(condition.operator).to eq(@operator)
+          expect(condition.and_or).to eq(nil)
+          expect(segment.recipient_count).to eq(0)
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+
+      it '#get_segments' do
+        begin
+          segments = @client.get_segments
+          segments.segments.each do |segment|
+            expect(
+              segment
+            ).to be_a(SendGrid4r::REST::Contacts::Segments::Segment)
+          end
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+
+      it '#get_segment' do
+        begin
+          segment = @client.get_segment(@segment1.id)
+          expect(segment.id).to eq(@segment1.id)
+          expect(segment.name).to eq(@segment1.name)
+          expect(segment.list_id).to eq(nil)
+          condition = segment.conditions[0]
+          expect(condition.field).to eq(@field)
+          expect(condition.value).to eq(@value)
+          expect(condition.operator).to eq(@operator)
+          expect(condition.and_or).to eq(nil)
+          expect(segment.recipient_count).to be_a(Fixnum)
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+
+      it '#put_segment' do
+        begin
+          pending 'waiting sendgrid documentation update'
+          edit_params = @segment_factory.create(
+            name: @edit_name1, conditions: [@condition]
+          )
+          edit_segment = @client.put_segment(@segment1.id, edit_params)
+          expect(edit_segment.name).to eq(@edit_name1)
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+
+      it '#get_recipients_from_segment' do
+        begin
+          # list recipients from a single segment
+          recipients = @client.get_recipients_from_segment(@segment1.id)
+          recipients.recipients.each do |recipient|
+            expect(
+              recipient
+            ).to be_a(SendGrid4r::REST::Contacts::Recipients::Recipient)
+          end
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+
+      it '#delete_segment' do
+        begin
+          # delete the segment
+          @client.delete_segment(@segment1.id)
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+    end
+
+    context 'with block all' do
+      it '#post_segment' do
+        params2 = @segment_factory.create(
+          name: @name2, conditions: [@condition]
         )
+        @client.post_segment(params2) do |resp, req, res|
+          resp =
+            SendGrid4r::REST::Contacts::Segments.create_segment(
+              JSON.parse(resp)
+            )
+          expect(resp).to be_a(SendGrid4r::REST::Contacts::Segments::Segment)
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPCreated)
+        end
+      end
+
+      it '#get_segments' do
+        @client.get_segments do |resp, req, res|
+          resp =
+            SendGrid4r::REST::Contacts::Segments.create_segments(
+              JSON.parse(resp)
+            )
+          expect(resp).to be_a(SendGrid4r::REST::Contacts::Segments::Segments)
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPOK)
+        end
+      end
+
+      it '#get_segment' do
+        @client.get_segment(@segment1.id) do |resp, req, res|
+          resp =
+            SendGrid4r::REST::Contacts::Segments.create_segment(
+              JSON.parse(resp)
+            )
+          expect(resp).to be_a(SendGrid4r::REST::Contacts::Segments::Segment)
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPOK)
+        end
+      end
+
+      it '#put_segment' do
+        pending 'waiting sendgrid documentation update'
         edit_params = @segment_factory.create(
-          name: @edit_name, conditions: [edit_condition]
+          name: @edit_name1, conditions: [@condition]
         )
-        edit_segment = @client.put_segment(new_segment.id, edit_params)
-        expect(edit_segment.name).to eq(@edit_name)
-        # list recipients from a single segment
-        recipients = @client.get_recipients_from_segment(new_segment.id)
-        recipients.recipients.each do |recipient|
-          expect(
-            recipient.is_a?(SendGrid4r::REST::Contacts::Recipients::Recipient)
-          ).to eq(true)
+        @client.put_segment(@segment1.id, edit_params) do |resp, req, res|
+          resp =
+            SendGrid4r::REST::Contacts::Segments.create_segment(
+              JSON.parse(resp)
+            )
+          expect(resp).to be_a(SendGrid4r::REST::Contacts::Segments::Segment)
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPOK)
+        end
+      end
+
+      it '#get_recipients_from_segment' do
+        @client.get_recipients_from_segment(@segment1.id) do |resp, req, res|
+          resp =
+            SendGrid4r::REST::Contacts::Recipients.create_recipients(
+              JSON.parse(resp)
+            )
+          expect(resp).to be_a(
+            SendGrid4r::REST::Contacts::Recipients::Recipients
+          )
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPOK)
+        end
+      end
+
+      it '#delete_segment' do
+        @client.delete_segment(@segment1.id) do |resp, req, res|
+          expect(resp).to eq('')
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPNoContent)
         end
-        # delete the segment
-        @client.delete_segment(new_segment.id)
-        expect do
-          @client.get_segment(new_segment.id)
-        end.to raise_error(RestClient::ResourceNotFound)
-      rescue => e
-        puts e.inspect
-        raise e
       end
     end
+  end
 
+  describe 'unit test' do
     it 'creates condition instance' do
       json =
         '{'\
@@ -99,6 +231,7 @@ describe 'SendGrid4r::REST::Contacts::Segments' do
         '}'
       hash = JSON.parse(json)
       actual = SendGrid4r::REST::Contacts::Segments.create_condition(hash)
+      expect(actual).to be_a(SendGrid4r::REST::Contacts::Segments::Condition)
       expect(actual.field).to eq('last_name')
       expect(actual.value).to eq('Miller')
       expect(actual.operator).to eq('eq')
@@ -123,18 +256,17 @@ describe 'SendGrid4r::REST::Contacts::Segments' do
         '}'
       hash = JSON.parse(json)
       actual = SendGrid4r::REST::Contacts::Segments.create_segment(hash)
+      expect(actual).to be_a(SendGrid4r::REST::Contacts::Segments::Segment)
       expect(actual.id).to eq(1)
       expect(actual.name).to eq('Last Name Miller')
       expect(actual.list_id).to eq(nil)
-      expect(actual.conditions.is_a?(Array)).to eq(true)
+      expect(actual.conditions).to be_a(Array)
       actual.conditions.each do |condition|
-        expect(
-          condition.is_a?(
-            SendGrid4r::REST::Contacts::Segments::Condition
-          )
-        ).to eq(true)
+        expect(condition).to be_a(
+          SendGrid4r::REST::Contacts::Segments::Condition
+        )
       end
-      expect(actual.recipient_count).to eq(1)
+      expect(actual.recipient_count).to be_a(Fixnum)
     end
 
     it 'creates segments instance' do
@@ -159,11 +291,10 @@ describe 'SendGrid4r::REST::Contacts::Segments' do
         '}'
       hash = JSON.parse(json)
       actual = SendGrid4r::REST::Contacts::Segments.create_segments(hash)
-      expect(actual.segments.is_a?(Array)).to eq(true)
+      expect(actual).to be_a(SendGrid4r::REST::Contacts::Segments::Segments)
+      expect(actual.segments).to be_a(Array)
       actual.segments.each do |segment|
-        expect(
-          segment.is_a?(SendGrid4r::REST::Contacts::Segments::Segment)
-        ).to eq(true)
+        expect(segment).to be_a(SendGrid4r::REST::Contacts::Segments::Segment)
       end
     end
   end

data/spec/factory/condition_factory_spec.rb

@@ -1,19 +1,19 @@
 # encoding: utf-8
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe 'SendGrid4r::Factory::ConditionFactory' do
-  before :all do
-    Dotenv.load
-    @factory = SendGrid4r::Factory::ConditionFactory.new
-    @expect = {}
-    @expect[:field] = 'last_name'
-    @expect[:value] = 'Miller'
-    @expect[:operator] = 'eq'
-    @expect[:and_or] = ''
-  end
+describe SendGrid4r::Factory::ConditionFactory do
+  describe 'unit test' do
+    before do
+      Dotenv.load
+      @factory = SendGrid4r::Factory::ConditionFactory.new
+      @expect = {}
+      @expect[:field] = 'last_name'
+      @expect[:value] = 'Miller'
+      @expect[:operator] = 'eq'
+      @expect[:and_or] = ''
+    end
 
-  context 'always' do
-    it 'is full case' do
+    it 'specify all params' do
       condition = @factory.create(
         field: 'last_name',
         value: 'Miller',

data/spec/factory/segment_factory_spec.rb

@@ -1,26 +1,26 @@
 # encoding: utf-8
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe 'SendGrid4r::Factory::SegmentFactory' do
-  before :all do
-    Dotenv.load
-    @segment_factory = SendGrid4r::Factory::SegmentFactory.new
-    @condition_factory = SendGrid4r::Factory::ConditionFactory.new
-    @condition = @condition_factory.create(
-      field: 'last_name',
-      value: 'Miller',
-      operator: 'eq',
-      and_or: '')
-    @expect = {}
-    @expect[:id] = nil
-    @expect[:name] = 'Last Name Miller'
-    @expect[:list_id] = nil
-    @expect[:conditions] = [@condition]
-    @expect[:recipient_count] = nil
-  end
+describe SendGrid4r::Factory::SegmentFactory do
+  describe 'unit test' do
+    before do
+      Dotenv.load
+      @segment_factory = SendGrid4r::Factory::SegmentFactory.new
+      @condition_factory = SendGrid4r::Factory::ConditionFactory.new
+      @condition = @condition_factory.create(
+        field: 'last_name',
+        value: 'Miller',
+        operator: 'eq',
+        and_or: '')
+      @expect = {}
+      @expect[:id] = nil
+      @expect[:name] = 'Last Name Miller'
+      @expect[:list_id] = nil
+      @expect[:conditions] = [@condition]
+      @expect[:recipient_count] = nil
+    end
 
-  context 'always' do
-    it 'is full params case' do
+    it 'specify all params' do
       segment = @segment_factory.create(
         name: 'Last Name Miller', conditions: [@condition]
       )

data/spec/factory/version_factory_spec.rb

@@ -1,13 +1,13 @@
 # encoding: utf-8
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe 'SendGrid4r::Factory::VersionFactory' do
-  before :all do
-    Dotenv.load
-    @factory = SendGrid4r::Factory::VersionFactory.new
-  end
+describe SendGrid4r::Factory::VersionFactory do
+  describe 'unit test' do
+    before do
+      Dotenv.load
+      @factory = SendGrid4r::Factory::VersionFactory.new
+    end
 
-  context 'always' do
     it 'is simple case' do
       version = @factory.create(name: 'version_name')
       expect(version.name).to eq('version_name')