sendgrid4r 1.8.1 → 1.10.0

data/spec/rest/contacts/segments_spec.rb

@@ -1,307 +0,0 @@
-# encoding: utf-8
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe SendGrid4r::REST::Contacts::Segments do
-  describe 'integration test', :it do
-    before do
-      begin
-        Dotenv.load
-        @client = SendGrid4r::Client.new(api_key: ENV['API_KEY'])
-        @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: segment.id
-          ) if segment.name == @name1
-          @client.delete_segment(
-            segment_id: segment.id
-          ) if segment.name == @edit_name1
-          @client.delete_segment(
-            segment_id: 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(
-            custom_field_id: field.id
-          ) if field.name == @field
-        end
-        # post a custom field and a segment
-        @client.post_custom_field(name: @field, type: 'text')
-        @condition = @condition_factory.create(
-          field: @field, value: @value, operator: @operator, and_or: @and_or
-        )
-        params1 = @segment_factory.create(
-          name: @name1, list_id: nil, conditions: [@condition]
-        )
-        @segment1 = @client.post_segment(params: params1)
-      rescue RestClient::ExceptionWithResponse => e
-        puts e.inspect
-        raise e
-      end
-    end
-
-    context 'without block call' do
-      it '#post_segment' do
-        begin
-          lists = @client.get_lists
-          params2 = @segment_factory.create(
-            name: @name2, list_id: lists.lists[0].id, conditions: [@condition]
-          )
-          segment = @client.post_segment(params: params2)
-          expect(segment.id).to be_a(Fixnum)
-          expect(segment.name).to eq(@name2)
-          expect(segment.list_id).to eq(lists.lists[0].id)
-          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 RestClient::ExceptionWithResponse => 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 RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#get_segment' do
-        begin
-          segment = @client.get_segment(segment_id: @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 RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#patch_segment' do
-        begin
-          edit_params = @segment_factory.create(
-            name: @edit_name1, conditions: [@condition]
-          )
-          edit_segment = @client.patch_segment(
-            segment_id: @segment1.id, params: edit_params
-          )
-          expect(edit_segment.name).to eq(@edit_name1)
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#delete_segment' do
-        begin
-          @client.delete_segment(segment_id: @segment1.id)
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#get_recipients_on_segment' do
-        begin
-          recipients = @client.get_recipients_on_segment(
-            segment_id: @segment1.id
-          )
-          recipients.recipients.each do |recipient|
-            expect(
-              recipient
-            ).to be_a(SendGrid4r::REST::Contacts::Recipients::Recipient)
-          end
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-    end
-  end
-
-  describe 'unit test', :ut do
-    let(:client) do
-      SendGrid4r::Client.new(api_key: '')
-    end
-
-    let(:condition) do
-      JSON.parse(
-        '{'\
-          '"field": "last_name",'\
-          '"value": "Miller",'\
-          '"operator": "eq",'\
-          '"and_or": ""'\
-        '}'
-      )
-    end
-
-    let(:segment) do
-      JSON.parse(
-        '{'\
-          '"id": 1,'\
-          '"name": "Last Name Miller",'\
-          '"list_id": 4,'\
-          '"conditions": ['\
-            '{'\
-              '"field": "last_name",'\
-              '"value": "Miller",'\
-              '"operator": "eq",'\
-              '"and_or": ""'\
-            '}'\
-          '],'\
-          '"recipient_count": 1'\
-        '}'
-      )
-    end
-
-    let(:segments) do
-      JSON.parse(
-        '{'\
-          '"segments": ['\
-            '{'\
-              '"id": 1,'\
-              '"name": "Last Name Miller",'\
-              '"list_id": 4,'\
-              '"conditions": ['\
-                '{'\
-                  '"field": "last_name",'\
-                  '"value": "Miller",'\
-                  '"operator": "eq",'\
-                  '"and_or": ""'\
-                '}'\
-              '],'\
-              '"recipient_count": 1'\
-            '}'\
-          ']'\
-        '}'
-      )
-    end
-
-    let(:recipients) do
-      JSON.parse(
-        '{'\
-          '"recipients": ['\
-            '{'\
-              '"created_at": 1422313607,'\
-              '"email": "jones@example.com",'\
-              '"first_name": null,'\
-              '"id": "jones@example.com",'\
-              '"last_clicked": null,'\
-              '"last_emailed": null,'\
-              '"last_name": "Jones",'\
-              '"last_opened": null,'\
-              '"updated_at": 1422313790,'\
-              '"custom_fields": ['\
-                '{'\
-                  '"id": 23,'\
-                  '"name": "pet",'\
-                  '"value": "Fluffy",'\
-                  '"type": "text"'\
-                '}'\
-              ']'\
-            '}'\
-          ']'\
-        '}'
-      )
-    end
-
-    it '#post_segment' do
-      allow(client).to receive(:execute).and_return(segment)
-      actual = client.post_segment(params: nil)
-      expect(actual).to be_a(SendGrid4r::REST::Contacts::Segments::Segment)
-    end
-
-    it '#get_segments' do
-      allow(client).to receive(:execute).and_return(segments)
-      actual = client.get_segments
-      expect(actual).to be_a(SendGrid4r::REST::Contacts::Segments::Segments)
-    end
-
-    it '#get_segment' do
-      allow(client).to receive(:execute).and_return(segment)
-      actual = client.get_segment(segment_id: 0)
-      expect(actual).to be_a(SendGrid4r::REST::Contacts::Segments::Segment)
-    end
-
-    it '#patch_segment' do
-      allow(client).to receive(:execute).and_return(segment)
-      actual = client.patch_segment(segment_id: 0, params: nil)
-      expect(actual).to be_a(SendGrid4r::REST::Contacts::Segments::Segment)
-    end
-
-    it '#get_recipients_on_segment' do
-      allow(client).to receive(:execute).and_return(recipients)
-      actual = client.get_recipients_on_segment(segment_id: 0)
-      expect(actual).to be_a(SendGrid4r::REST::Contacts::Recipients::Recipients)
-    end
-
-    it '#delete_segment' do
-      allow(client).to receive(:execute).and_return('')
-      actual = client.delete_segment(segment_id: 0)
-      expect(actual).to eq('')
-    end
-
-    it 'creates condition instance' do
-      actual = SendGrid4r::REST::Contacts::Segments.create_condition(condition)
-      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')
-      expect(actual.and_or).to eq('')
-    end
-
-    it 'creates segment instance' do
-      actual = SendGrid4r::REST::Contacts::Segments.create_segment(segment)
-      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(4)
-      expect(actual.conditions).to be_a(Array)
-      actual.conditions.each do |condition|
-        expect(condition).to be_a(
-          SendGrid4r::REST::Contacts::Segments::Condition
-        )
-      end
-      expect(actual.recipient_count).to be_a(Fixnum)
-    end
-
-    it 'creates segments instance' do
-      actual = SendGrid4r::REST::Contacts::Segments.create_segments(segments)
-      expect(actual).to be_a(SendGrid4r::REST::Contacts::Segments::Segments)
-      expect(actual.segments).to be_a(Array)
-      actual.segments.each do |segment|
-        expect(segment).to be_a(SendGrid4r::REST::Contacts::Segments::Segment)
-      end
-    end
-  end
-end

data/spec/rest/email_activity/email_activity_spec.rb

@@ -1,179 +0,0 @@
-# encoding: utf-8
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe SendGrid4r::REST::EmailActivity do
-  describe 'integration test', :it do
-    before do
-      begin
-        Dotenv.load
-        @client = SendGrid4r::Client.new(api_key: ENV['API_KEY'])
-      rescue RestClient::ExceptionWithResponse => e
-        puts e.inspect
-        raise e
-      end
-    end
-
-    context 'without block call' do
-      it '#get_email_activities' do
-        begin
-          activities = @client.get_email_activities
-          activities.each do |activity|
-            expect(activity).to be_a(SendGrid4r::REST::EmailActivity::Activity)
-          end
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#get_email_activities with email' do
-        begin
-          activities = @client.get_email_activities(email: 'test@test.com')
-          activities.each do |activity|
-            expect(activity).to be_a(SendGrid4r::REST::EmailActivity::Activity)
-          end
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#get_email_activities with events' do
-        begin
-          activities = @client.get_email_activities(
-            events: [SendGrid4r::Client::Event::DROPS]
-          )
-          expect(activities.length).to be >= 0
-          activities.each do |activity|
-            expect(activity).to be_a(SendGrid4r::REST::EmailActivity::Activity)
-            expect(activity.event).to eq('drop')
-          end
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#get_email_activities with multiple events' do
-        begin
-          events = []
-          events.push(SendGrid4r::Client::Event::DROPS)
-          events.push(SendGrid4r::Client::Event::DELIVERED)
-          events.push(SendGrid4r::Client::Event::BOUNCES)
-          events.push(SendGrid4r::Client::Event::CLICKS)
-          events.push(SendGrid4r::Client::Event::DEFERRED)
-          events.push(SendGrid4r::Client::Event::DELIVERED)
-          events.push(SendGrid4r::Client::Event::DROPS)
-          events.push(SendGrid4r::Client::Event::GROUP_UNSUBSCRIBE)
-          events.push(SendGrid4r::Client::Event::GROUP_RESUBSCRIBE)
-          events.push(SendGrid4r::Client::Event::OPENS)
-          events.push(SendGrid4r::Client::Event::PROCESSED)
-          events.push(SendGrid4r::Client::Event::PARSEAPI)
-          events.push(SendGrid4r::Client::Event::SPAM_REPORTS)
-          events.push(SendGrid4r::Client::Event::UNSUBSCRIBE)
-          activities = @client.get_email_activities(events: events)
-          expect(activities.length).to be >= 0
-          activities.each do |activity|
-            expect(activity).to be_a(SendGrid4r::REST::EmailActivity::Activity)
-          end
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#get_email_activities with start_time and end_time' do
-        begin
-          pending('unknown field')
-          start_time = Time.local(2015, 5, 20, 12, 23, 45)
-          end_time = Time.local(2015, 5, 23, 12, 23, 45)
-          activities = @client.get_email_activities(
-            start_time: start_time, end_time: end_time
-          )
-          expect(activities.length).to be >= 0
-          activities.each do |activity|
-            expect(activity).to be_a(SendGrid4r::REST::EmailActivity::Activity)
-            puts activity.inspect
-          end
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-    end
-  end
-
-  describe 'unit test', :ut do
-    let(:client) do
-      SendGrid4r::Client.new(api_key: '')
-    end
-
-    let(:activities) do
-      JSON.parse(
-        '['\
-          '{'\
-            '"email": "test@example.com",'\
-            '"event": "processed",'\
-            '"created": 1431624000,'\
-            '"category": ["my_category"],'\
-            '"smtp_id": "filter001-2348927389",'\
-            '"asm_group_id": null,'\
-            '"msg_id": "xxx-abc-123",'\
-            '"ip": null,'\
-            '"url": null'\
-          '}'\
-        ']'
-      )
-    end
-
-    let(:activity) do
-      JSON.parse(
-        '{'\
-          '"email": "test@example.com",'\
-          '"event": "processed",'\
-          '"created": 1431624000,'\
-          '"category": ["my_category"],'\
-          '"smtp_id": "filter001-2348927389",'\
-          '"asm_group_id": null,'\
-          '"msg_id": "xxx-abc-123",'\
-          '"ip": null,'\
-          '"url": null'\
-        '}'\
-      )
-    end
-
-    it '#get_email_activities' do
-      allow(client).to receive(:execute).and_return(activities)
-      actual = client.get_email_activities
-      expect(actual).to be_a(Array)
-      actual.each do |activity|
-        expect(activity).to be_a(SendGrid4r::REST::EmailActivity::Activity)
-      end
-    end
-
-    it 'creates activity instance' do
-      actual = SendGrid4r::REST::EmailActivity.create_activity(activity)
-      expect(actual).to be_a(SendGrid4r::REST::EmailActivity::Activity)
-      expect(actual.email).to eq('test@example.com')
-      expect(actual.event).to eq('processed')
-      expect(actual.created).to eq(Time.at(1431624000))
-      expect(actual.category).to be_a(Array)
-      actual.category.each do |category|
-        expect(category).to eq('my_category')
-      end
-      expect(actual.smtp_id).to eq('filter001-2348927389')
-      expect(actual.asm_group_id).to eq(nil)
-      expect(actual.msg_id).to eq('xxx-abc-123')
-      expect(actual.ip).to eq(nil)
-      expect(actual.url).to eq(nil)
-    end
-
-    it 'creates activities instance' do
-      actual = SendGrid4r::REST::EmailActivity.create_activities(activities)
-      expect(actual).to be_a(Array)
-      actual.each do |activity|
-        expect(activity).to be_a(SendGrid4r::REST::EmailActivity::Activity)
-      end
-    end
-  end
-end

data/spec/rest/templates/templates_spec.rb

@@ -1,222 +0,0 @@
-# encoding: utf-8
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe SendGrid4r::REST::Templates do
-  describe 'integration test', :it do
-    before do
-      begin
-        Dotenv.load
-        @client = SendGrid4r::Client.new(api_key: ENV['SILVER_API_KEY'])
-        @template_name1 = 'template_test1'
-        @template_name2 = 'template_test2'
-        @template_edit1 = 'template_edit1'
-        @version_name1 = 'version_test1'
-        @factory = SendGrid4r::Factory::VersionFactory.new
-
-        # celan up test env
-        tmps = @client.get_templates
-        tmps.templates.each do |tmp|
-          delete_template(tmp) if tmp.name == @template_name1
-          delete_template(tmp) if tmp.name == @template_name2
-          delete_template(tmp) if tmp.name == @template_edit1
-        end
-        # post a template
-        @template1 = @client.post_template(name: @template_name1)
-      rescue RestClient::ExceptionWithResponse => e
-        puts e.inspect
-        raise e
-      end
-    end
-
-    def delete_template(tmp)
-      tmp.versions.each do |ver|
-        @client.delete_version(template_id: tmp.id, version_id: ver.id)
-      end
-      @client.delete_template(template_id: tmp.id)
-    end
-
-    context 'without block call' do
-      it '#post_template' do
-        begin
-          new_template = @client.post_template(name: @template_name2)
-          expect(new_template.id).to be_a(String)
-          expect(new_template.name).to eq(@template_name2)
-          expect(new_template.versions).to be_a(Array)
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#get_templates' do
-        begin
-          tmps = @client.get_templates
-          tmps.templates.each do |tmp|
-            expect(tmp.id).to be_a(String)
-            expect(tmp.name).to be_a(String)
-            expect(tmp.versions).to be_a(Array)
-            tmp.versions.each do |ver|
-              expect(ver.id).to be_a(String)
-              expect(ver.template_id).to be_a(String)
-              expect(ver.active).to be_a(Fixnum)
-              expect(ver.name).to be_a(String)
-              expect(ver.updated_at).to be_a(String)
-            end
-          end
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#patch_template' do
-        begin
-          version = @factory.create(name: @version_name1)
-          @client.post_version(template_id: @template1.id, version: version)
-          tmp = @client.patch_template(
-            template_id: @template1.id, name: @template_edit1
-          )
-          expect(tmp.id).to be_a(String)
-          expect(tmp.name).to be_a(String)
-          expect(tmp.versions).to be_a(Array)
-          tmp.versions.each do |ver|
-            expect(ver.id).to be_a(String)
-            expect(ver.template_id).to be_a(String)
-            expect(ver.active).to be_a(Fixnum)
-            expect(ver.name).to be_a(String)
-            expect(ver.updated_at).to be_a(String)
-          end
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#get_template' do
-        begin
-          tmp = @client.get_template(template_id: @template1.id)
-          expect(tmp.id).to eq(@template1.id)
-          expect(tmp.versions).to eq(@template1.versions)
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#delete_template' do
-        begin
-          @client.delete_template(template_id: @template1.id)
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-    end
-  end
-
-  describe 'unit test', :ut do
-    let(:client) do
-      SendGrid4r::Client.new(api_key: '')
-    end
-
-    let(:template) do
-      JSON.parse(
-        '{'\
-          '"id": "733ba07f-ead1-41fc-933a-3976baa23716",'\
-          '"name": "example_name",'\
-          '"versions": []'\
-        '}'
-      )
-    end
-
-    let(:templates) do
-      JSON.parse(
-        '{'\
-          '"templates": ['\
-            '{'\
-              '"id": "e8ac01d5-a07a-4a71-b14c-4721136fe6aa",'\
-              '"name": "example template name",'\
-              '"versions": ['\
-                '{'\
-                  '"id": "de37d11b-082a-42c0-9884-c0c143015a47",'\
-                  '"user_id": 1234,'\
-                  '"template_id": "d51480ba-ca3f-465c-bc3e-ceb71d73c38d",'\
-                  '"active": 1,'\
-                  '"name": "example version",'\
-                  '"html_content": "<%body%><strong>Click to Reset</strong>",'\
-                  '"plain_content": "Click to Reset<%body%>",'\
-                  '"subject": "<%subject%>",'\
-                  '"updated_at": "2014-05-22 20:05:21"'\
-                '}'\
-              ']'\
-            '}'\
-          ']'\
-        '}'
-      )
-    end
-
-    it '#post_template' do
-      allow(client).to receive(:execute).and_return(template)
-      actual = client.post_template(name: '')
-      expect(actual).to be_a(SendGrid4r::REST::Templates::Template)
-    end
-
-    it '#get_templates' do
-      allow(client).to receive(:execute).and_return(templates)
-      actual = client.get_templates
-      expect(actual).to be_a(SendGrid4r::REST::Templates::Templates)
-    end
-
-    it '#patch_template' do
-      allow(client).to receive(:execute).and_return(template)
-      actual = client.patch_template(template_id: '', name: '')
-      expect(actual).to be_a(SendGrid4r::REST::Templates::Template)
-    end
-
-    it '#get_template' do
-      allow(client).to receive(:execute).and_return(template)
-      actual = client.get_template(template_id: '')
-      expect(actual).to be_a(SendGrid4r::REST::Templates::Template)
-    end
-
-    it '#delete_template' do
-      allow(client).to receive(:execute).and_return('')
-      actual = client.delete_template(template_id: '')
-      expect(actual).to eq('')
-    end
-
-    it 'creates template instance' do
-      actual = SendGrid4r::REST::Templates.create_template(template)
-      expect(actual).to be_a(SendGrid4r::REST::Templates::Template)
-      expect(actual.id).to eq('733ba07f-ead1-41fc-933a-3976baa23716')
-      expect(actual.name).to eq('example_name')
-      expect(actual.versions).to be_a(Array)
-    end
-
-    it 'creates templates instance' do
-      actual = SendGrid4r::REST::Templates.create_templates(templates)
-      expect(actual).to be_a(SendGrid4r::REST::Templates::Templates)
-      expect(actual.templates).to be_a(Array)
-      actual.templates.each do |template|
-        expect(template.id).to eq('e8ac01d5-a07a-4a71-b14c-4721136fe6aa')
-        expect(template.name).to eq('example template name')
-        expect(template.versions).to be_a(Array)
-        template.versions do |version|
-          expect(version.id).to eq('de37d11b-082a-42c0-9884-c0c143015a47')
-          expect(version.user_id).to eq(1234)
-          expect(version.template_id).to eq(
-            'd51480ba-ca3f-465c-bc3e-ceb71d73c38d'
-          )
-          expect(version.active).to eq(1)
-          expect(version.name).to eq('example version')
-          expect(version.html_content).to eq(
-            '<%body%><strong>Click to Reset</strong>'
-          )
-          expect(version.plain_content).to eq('Click to Reset<%body%>')
-          expect(version.subject).to eq('<%subject%>')
-          expect(version.updated_at).to eq('2014-05-22 20:05:21')
-        end
-      end
-    end
-  end
-end