sendgrid4r 0.1.0 → 0.2.0

data/lib/sendgrid4r/rest/request.rb

@@ -11,52 +11,52 @@ module SendGrid4r
     # SendGrid Web API v3 Request
     #
     module Request
-      def get(auth, endpoint, params = nil)
-        resource = RestClient::Resource.new(
-          endpoint, auth.username, auth.password)
-        p = { params: params } unless params.nil?
-        if p.nil?
-          body = resource.get
-        else
-          body = resource.get(p)
-          # TODO: handle ratelimit headers
-          # do |response, request, result, &block|
-          #   # puts response.headers
-          #   break response.body
-          # end
-        end
-        JSON.parse(body)
+      # TODO: handle ratelimit headers
+      def get(auth, endpoint, params = nil, payload = nil)
+        execute(:get, auth, endpoint, params, payload)
       end
 
-      def post(auth, endpoint, params = nil)
-        resource = RestClient::Resource.new(
-          endpoint, auth.username, auth.password)
-        if params.nil?
-          body = resource.post(content_type: :json).body
-        else
-          body = resource.post(params.to_json, content_type: :json).body
-        end
-        JSON.parse(body)
+      def post(auth, endpoint, payload = nil)
+        execute(:post, auth, endpoint, nil, payload)
+      end
+
+      def patch(auth, endpoint, payload)
+        execute(:patch, auth, endpoint, nil, payload)
       end
 
-      def patch(auth, endpoint, params)
-        resource = RestClient::Resource.new(
-          endpoint, auth.username, auth.password)
-        body = resource.patch(params.to_json, content_type: :json).body
-        JSON.parse(body)
+      def put(auth, endpoint, payload)
+        execute(:put, auth, endpoint, nil, payload)
       end
 
-      def put(auth, endpoint, params)
-        resource = RestClient::Resource.new(
-          endpoint, auth.username, auth.password)
-        body = resource.put(params.to_json, content_type: :json).body
-        JSON.parse(body)
+      def delete(auth, endpoint, payload = nil)
+        execute(:delete, auth, endpoint, nil, payload)
       end
 
-      def delete(auth, endpoint)
-        resource = RestClient::Resource.new(
-          endpoint, auth.username, auth.password)
-        resource.delete
+      def execute(method, auth, endpoint, params, payload)
+        args = {}
+        args[:method] = method
+        args[:url] = process_url_params(endpoint, params)
+        args[:user] = auth.username
+        args[:password] = auth.password
+        args[:headers] = { content_type: :json }
+        args[:payload] = payload.to_json unless payload.nil?
+        body = RestClient::Request.execute(args)
+        if body.nil? || body.length < 2
+          body
+        else
+          JSON.parse(body)
+        end
+      end
+
+      def process_url_params(endpoint, params)
+        if params.nil? || params.empty?
+          endpoint
+        else
+          query_string = params.collect do |k, v|
+            "#{k}=#{CGI.escape(v.to_s)}"
+          end.join('&')
+          endpoint + "?#{query_string}"
+        end
       end
     end
   end

data/lib/sendgrid4r/rest/stats/category.rb

@@ -18,7 +18,6 @@ module SendGrid4r
             aggregated_by: aggregated_by,
             categories: categories
           }
-          # TODO: categories does not support array yet
           resp_a = get(
             @auth, "#{SendGrid4r::Client::BASE_URL}/categories/stats", params)
           SendGrid4r::REST::Stats.create_top_stats(resp_a)

data/lib/sendgrid4r/version.rb

@@ -2,5 +2,5 @@
 # SendGrid API v3 wrapper implementation.
 #
 module SendGrid4r
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/asm/suppressions_spec.rb

@@ -38,9 +38,12 @@ describe 'SendGrid4r::REST::Asm::Groups::Suppressions' do
       # get the suppressions
       suppressions = @client.get_suppressions(@email1)
       expect(suppressions.length >= 1).to eq(true)
-      expect(suppressions[0].name).to eq(@group_name)
-      expect(suppressions[0].description).to eq(@group_desc)
-      expect(suppressions[0].suppressed).to eq(true)
+      suppressions.each do |suppression|
+        next unless suppression.name == @group_name
+        expect(suppression.name).to eq(@group_name)
+        expect(suppression.description).to eq(@group_desc)
+        expect(suppression.suppressed).to eq(true)
+      end
       # get the recipient emails
       actual_emails = @client.get_suppressed_emails(new_group.id)
       expect(actual_emails.length).to eq(suppressed_emails.length)

data/spec/client_spec.rb

@@ -87,12 +87,49 @@ describe 'SendGrid4r::Client' do
         expect(@client.respond_to?('get_esp_stats')).to eq(true)
         expect(@client.respond_to?('get_browsers_stats')).to eq(true)
         expect(@client.respond_to?('get_parse_stats')).to eq(true)
+        # Contacts
+        # CustomFields
+        expect(@client.respond_to?('post_custom_field')).to eq(true)
+        expect(@client.respond_to?('get_custom_fields')).to eq(true)
+        expect(@client.respond_to?('get_custom_field')).to eq(true)
+        expect(@client.respond_to?('delete_custom_field')).to eq(true)
+        # Lists
+        expect(@client.respond_to?('post_list')).to eq(true)
+        expect(@client.respond_to?('get_lists')).to eq(true)
+        expect(@client.respond_to?('get_list')).to eq(true)
+        expect(@client.respond_to?('patch_list')).to eq(true)
+        expect(@client.respond_to?('delete_list')).to eq(true)
+        expect(@client.respond_to?('post_recipients_to_list')).to eq(true)
+        expect(@client.respond_to?('get_recipients_from_list')).to eq(true)
+        expect(@client.respond_to?('post_recipients_to_list')).to eq(true)
+        expect(@client.respond_to?('delete_recipient_from_list')).to eq(true)
+        expect(@client.respond_to?('delete_lists')).to eq(true)
+        # Recipients
+        expect(@client.respond_to?('post_recipient')).to eq(true)
+        expect(@client.respond_to?('delete_recipients')).to eq(true)
+        expect(@client.respond_to?('get_recipients')).to eq(true)
+        expect(@client.respond_to?('get_recipients_by_id')).to eq(true)
+        expect(@client.respond_to?('get_recipients_count')).to eq(true)
+        expect(@client.respond_to?('search_recipients')).to eq(true)
+        expect(@client.respond_to?('get_recipient')).to eq(true)
+        expect(@client.respond_to?('delete_recipient')).to eq(true)
+        expect(@client.respond_to?('get_lists_recipient_belong')).to eq(true)
+        expect(@client.respond_to?('post_recipients')).to eq(true)
+        # ReservedFields
+        expect(@client.respond_to?('get_reserved_fields')).to eq(true)
+        # Segments
+        expect(@client.respond_to?('post_segment')).to eq(true)
+        expect(@client.respond_to?('get_segments')).to eq(true)
+        expect(@client.respond_to?('get_segment')).to eq(true)
+        expect(@client.respond_to?('put_segment')).to eq(true)
+        expect(@client.respond_to?('delete_segment')).to eq(true)
+        expect(@client.respond_to?('get_recipients_from_segment')).to eq(true)
       end
     end
 
     describe 'VERSION' do
       it 'returns VERSION value' do
-        expect(SendGrid4r::VERSION).to eq('0.1.0')
+        expect(SendGrid4r::VERSION).to eq('0.2.0')
       end
     end
   end

data/spec/contacts/custom_fields_spec.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'SendGrid4r::REST::Contacts::CustomFields' do
+  before :all do
+    Dotenv.load
+    @client = SendGrid4r::Client.new(
+      ENV['SENDGRID_USERNAME'], ENV['SENDGRID_PASSWORD'])
+    @name = 'birthday'
+    @type = 'text'
+  end
+
+  context 'always' do
+    it 'is normal' do
+      begin
+        # celan up test env
+        fields = @client.get_custom_fields
+        expect(fields.custom_fields.length >= 0).to eq(true)
+        fields.custom_fields.each do |field|
+          next if field.name != @name
+          @client.delete_custom_field(field.id)
+        end
+        # post a custom field
+        new_field = @client.post_custom_field(@name, @type)
+        expect(new_field.id.is_a?(Fixnum)).to eq(true)
+        expect(new_field.name).to eq(@name)
+        expect(new_field.type).to eq(@type)
+        # post same custom fieled
+        expect do
+          @client.post_custom_field(@name, @type)
+        end.to raise_error(RestClient::BadRequest)
+        # get the custom fields
+        fields = @client.get_custom_fields
+        expect(fields.length >= 1).to eq(true)
+        fields.custom_fields.each do |field|
+          next if field.name != @name
+          expect(field.id).to eq(new_field.id)
+          expect(field.name).to eq(new_field.name)
+          expect(field.type).to eq(new_field.type)
+        end
+        # get a single custom field
+        actual_field = @client.get_custom_field(new_field.id)
+        expect(actual_field.id).to eq(new_field.id)
+        expect(actual_field.name).to eq(new_field.name)
+        expect(actual_field.type).to eq(new_field.type)
+        # delete the custom field
+        @client.delete_custom_field(new_field.id)
+        expect do
+          @client.get_custom_field(new_field.id)
+        end.to raise_error(RestClient::ResourceNotFound)
+      rescue => e
+        puts e.inspect
+        raise e
+      end
+    end
+
+    it 'creates field instance' do
+      json =
+        '{'\
+          '"id": 1,'\
+          '"name": "pet",'\
+          '"type": "text"'\
+        '}'
+      hash = JSON.parse(json)
+      actual = SendGrid4r::REST::Contacts::CustomFields.create_field(hash)
+      expect(actual.id).to eq(1)
+      expect(actual.name).to eq('pet')
+      expect(actual.type).to eq('text')
+    end
+
+    it 'creates fields instance' do
+      json =
+        '{'\
+          '"custom_fields": ['\
+            '{'\
+              '"id": 1,'\
+              '"name": "birthday",'\
+              '"type": "date"'\
+            '},'\
+            '{'\
+              '"id": 2,'\
+              '"name": "middle_name",'\
+              '"type": "text"'\
+            '},'\
+            '{'\
+              '"id": 3,'\
+              '"name": "favorite_number",'\
+              '"type": "number"'\
+            '}'\
+          ']'\
+        '}'
+      hash = JSON.parse(json)
+      actual = SendGrid4r::REST::Contacts::CustomFields.create_fields(hash)
+      expect(actual.custom_fields.is_a?(Array)).to eq(true)
+      actual.custom_fields.each do |field|
+        expect(
+          field.is_a?(SendGrid4r::REST::Contacts::CustomFields::Field)
+        ).to eq(true)
+      end
+    end
+  end
+end

data/spec/contacts/lists_spec.rb

@@ -0,0 +1,150 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'SendGrid4r::REST::Contacts::Lists' do
+  context 'it test' do
+    before :all do
+      Dotenv.load
+      @client = SendGrid4r::Client.new(
+        ENV['SENDGRID_USERNAME'], ENV['SENDGRID_PASSWORD'])
+      @list_name1 = 'test_list1'
+      @edit_name1 = 'test_list1_edit'
+      @list_name2 = 'test_list2'
+      @email1 = 'jones@example.com'
+      @email2 = 'miller@example.com'
+      @last_name1 = 'Jones'
+      @last_name2 = 'Miller'
+      @pet1 = 'Fluffy'
+      @pet2 = 'FrouFrou'
+      @custom_field_name = 'pet'
+      @recipients = [@email1, @email2]
+    end
+
+    it 'is normal' do
+      begin
+        # celan up test env(lists)
+        lists = @client.get_lists
+        expect(lists.lists.length >= 0).to eq(true)
+        lists.lists.each do |list|
+          @client.delete_list(list.id) if list.name == @list_name1
+          @client.delete_list(list.id) if list.name == @edit_name1
+          @client.delete_list(list.id) if list.name == @list_name2
+        end
+        # celan up test env(recipients)
+        recipients = @client.get_recipients
+        expect(recipients.recipients.length >= 0).to eq(true)
+        recipients.recipients.each do |recipient|
+          @client.delete_recipient(recipient.id) if recipient.email == @email1
+          @client.delete_recipient(recipient.id) if recipient.email == @email2
+        end
+        # post a first list
+        new_list = @client.post_list(@list_name1)
+        expect(new_list.id.is_a?(Fixnum)).to eq(true)
+        expect(new_list.name).to eq(@list_name1)
+        expect(new_list.recipient_count).to eq(0)
+        # post same list
+        expect do
+          @client.post_list(@list_name1)
+        end.to raise_error(RestClient::BadRequest)
+        # get all list
+        lists = @client.get_lists
+        expect(lists.length >= 1).to eq(true)
+        lists.lists.each do |list|
+          next if list.name != @list_name1
+          expect(list.id).to eq(new_list.id)
+          expect(list.name).to eq(new_list.name)
+          expect(list.recipient_count).to eq(0)
+        end
+        # get a single list
+        actual_list = @client.get_list(new_list.id)
+        expect(actual_list.id).to eq(new_list.id)
+        expect(actual_list.name).to eq(new_list.name)
+        expect(actual_list.recipient_count).to eq(0)
+        # update the list
+        edit_list = @client.patch_list(new_list.id, @edit_name1)
+        expect(edit_list.id).to eq(new_list.id)
+        expect(edit_list.name).to eq(@edit_name1)
+        # add multiple recipients
+        recipient1 = {}
+        recipient1['email'] = @email1
+        recipient1['last_name'] = @last_name1
+        recipient1[@custom_field_name] = @pet1
+        @client.post_recipient(recipient1)
+        recipient2 = {}
+        recipient2['email'] = @email2
+        recipient2['last_name'] = @last_name2
+        recipient2[@custom_field_name] = @pet2
+        @client.post_recipient(recipient2)
+        # Add multiple recipients to a single list
+        @client.post_recipients_to_list(edit_list.id, @recipients)
+        # list recipients from a single list
+        recipients = @client.get_recipients_from_list(new_list.id)
+        recipients.recipients.each do |recipient|
+          expect(
+            recipient.is_a?(SendGrid4r::REST::Contacts::Recipients::Recipient)
+          ).to eq(true)
+        end
+        # list recipients from a single list with offset & limit
+        recipients = @client.get_recipients_from_list(new_list.id, 10, 0)
+        recipients.recipients.each do |recipient|
+          expect(
+            recipient.is_a?(SendGrid4r::REST::Contacts::Recipients::Recipient)
+          ).to eq(true)
+        end
+        # Add single recipient to a list
+        @client.post_recipient_to_list(edit_list.id, @email1)
+        # delete a single recipient from a single list
+        @client.delete_recipient_from_list(edit_list.id, @email1)
+        # delete the list
+        @client.delete_list(new_list.id)
+        expect do
+          @client.get_list(new_list.id)
+        end.to raise_error(RestClient::ResourceNotFound)
+        # post 2 lists
+        list1 = @client.post_list(@list_name1)
+        list2 = @client.post_list(@list_name2)
+        @client.delete_lists([list1.id, list2.id])
+      rescue => e
+        puts e.inspect
+        raise e
+      end
+    end
+  end
+
+  context 'unit test' do
+    it 'creates list instance' do
+      json =
+        '{'\
+          '"id": 1,'\
+          '"name": "listname",'\
+          '"recipient_count": 0'\
+        '}'
+      hash = JSON.parse(json)
+      actual = SendGrid4r::REST::Contacts::Lists.create_list(hash)
+      expect(actual.id).to eq(1)
+      expect(actual.name).to eq('listname')
+      expect(actual.recipient_count).to eq(0)
+    end
+
+    it 'creates lists instance' do
+      json =
+        '{'\
+          '"lists": ['\
+            '{'\
+              '"id": 1,'\
+              '"name": "the jones",'\
+              '"recipient_count": 1'\
+            '}'\
+          ']'\
+        '}'
+      hash = JSON.parse(json)
+      actual = SendGrid4r::REST::Contacts::Lists.create_lists(hash)
+      expect(actual.lists.is_a?(Array)).to eq(true)
+      actual.lists.each do |list|
+        expect(
+          list.is_a?(SendGrid4r::REST::Contacts::Lists::List)
+        ).to eq(true)
+      end
+    end
+  end
+end

data/spec/contacts/recipients_spec.rb

@@ -0,0 +1,200 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'SendGrid4r::REST::Contacts::Recipients' do
+  before :all do
+    Dotenv.load
+    @client = SendGrid4r::Client.new(
+      ENV['SENDGRID_USERNAME'], ENV['SENDGRID_PASSWORD'])
+    @email1 = 'jones@example.com'
+    @email2 = 'miller@example.com'
+    @last_name1 = 'Jones'
+    @last_name2 = 'Miller'
+    @pet1 = 'Fluffy'
+    @pet2 = 'FrouFrou'
+    @custom_field_name = 'pet'
+  end
+
+  context 'always' do
+    it 'is normal' do
+      begin
+        # celan up test env
+        recipients = @client.get_recipients
+        expect(recipients.recipients.length >= 0).to eq(true)
+        recipients.recipients.each do |recipient|
+          next if recipient.email != @email1
+          @client.delete_recipient(recipient.id)
+        end
+        custom_fields = @client.get_custom_fields
+        custom_fields.custom_fields.each do |custom_field|
+          next if custom_field.name != @custom_field_name
+          @client.delete_custom_field(custom_field.id)
+        end
+        @client.post_custom_field(@custom_field_name, 'text')
+        # post a recipient
+        params = {}
+        params['email'] = @email1
+        params['last_name'] = @last_name1
+        params[@custom_field_name] = @pet1
+        new_recipient = @client.post_recipient(params)
+        expect(new_recipient.created_at.is_a?(Fixnum)).to eq(true)
+        new_recipient.custom_fields.each do |custom_field|
+          expect(
+            custom_field.is_a?(
+              SendGrid4r::REST::Contacts::CustomFields::Field
+            )
+          ).to eq(true)
+        end
+        expect(new_recipient.email).to eq(@email1)
+        expect(new_recipient.first_name).to eq(nil)
+        expect(new_recipient.id).to eq(@email1)
+        expect(new_recipient.last_clicked).to eq(nil)
+        expect(new_recipient.last_emailed).to eq(nil)
+        expect(new_recipient.last_name).to eq(@last_name1)
+        expect(new_recipient.last_opened).to eq(nil)
+        expect(new_recipient.updated_at.is_a?(Fixnum)).to eq(true)
+        # post same recipients
+        @client.post_recipient(params)
+        # get all recipients
+        recipients = @client.get_recipients(100, 0)
+        expect(recipients.recipients.length > 0).to eq(true)
+        recipients.recipients.each do |recipient|
+          expect(
+            recipient.is_a?(SendGrid4r::REST::Contacts::Recipients::Recipient)
+          ).to eq(true)
+        end
+        # get multiple recipients
+        recipient_ids = [@email1, @email2]
+        actual_recipients = @client.get_recipients_by_id(recipient_ids)
+        expect(actual_recipients.recipients.is_a?(Array)).to eq(true)
+        expect(actual_recipients.recipients.length).to eq(2)
+        actual_recipients.recipients.each do |recipient|
+          expect(
+            recipient.is_a?(SendGrid4r::REST::Contacts::Recipients::Recipient)
+          ).to eq(true)
+        end
+        # read a count of recipients
+        actual_count = @client.get_recipients_count
+        expect(actual_count > 0).to eq(true)
+        # Search recipients
+        params = {}
+        params['email'] = @email1
+        recipients = @client.search_recipients(params)
+        expect(recipients.recipients.length).to eq(1)
+        # get a single recipient
+        recipient = @client.get_recipient(new_recipient.id)
+        expect(
+          recipient.is_a?(SendGrid4r::REST::Contacts::Recipients::Recipient)
+        ).to eq(true)
+        # List the recipient lists to which the recipient belongs
+        lists = @client.get_lists_recipient_belong(new_recipient.id)
+        lists.lists.each do |list|
+          expect(
+            list.is_a?(SendGrid4r::REST::Contacts::Lists::List)
+          ).to eq(true)
+        end
+        # add multiple recipients
+        recipient1 = {}
+        recipient1['email'] = @email1
+        recipient1['last_name'] = @last_name1
+        recipient1[@custom_field_name] = @pet1
+        recipient2 = {}
+        recipient2['email'] = @email2
+        recipient2['last_name'] = @last_name2
+        recipient2[@custom_field_name] = @pet2
+        params = [recipient1, recipient2]
+        result = @client.post_recipients(params)
+        expect(result.error_count).to eq(0)
+        result.error_indices.each do |index|
+          expect(index.is_a?(Fixnum)).to eq(true)
+        end
+        expect(result.new_count).to eq(0)
+        expect(result.updated_count).to eq(2)
+        # delete a recipient
+        @client.delete_recipient(new_recipient.id)
+        expect do
+          @client.get_recipient(new_recipient.id)
+        end.to raise_error(RestClient::ResourceNotFound)
+        # delete multiple recipients
+        @client.delete_recipients([@email1, @email2])
+      rescue => e
+        puts e.inspect
+        raise e
+      end
+    end
+
+    it 'creates recipient instance' do
+      json =
+        '{'\
+          '"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"'\
+            '}'\
+          ']'\
+        '}'
+      hash = JSON.parse(json)
+      actual = SendGrid4r::REST::Contacts::Recipients.create_recipient(hash)
+      expect(actual.created_at).to eq(1422313607)
+      expect(actual.email).to eq('jones@example.com')
+      expect(actual.first_name).to eq(nil)
+      expect(actual.id).to eq('jones@example.com')
+      expect(actual.last_clicked).to eq(nil)
+      expect(actual.last_emailed).to eq(nil)
+      expect(actual.last_name).to eq('Jones')
+      expect(actual.last_opened).to eq(nil)
+      expect(actual.updated_at).to eq(1422313790)
+      custom_field = actual.custom_fields[0]
+      expect(custom_field.id).to eq(23)
+      expect(custom_field.name).to eq('pet')
+      expect(custom_field.value).to eq('Fluffy')
+      expect(custom_field.type).to eq('text')
+    end
+
+    it 'creates recipients instance' do
+      json =
+        '{'\
+          '"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"'\
+                '}'\
+              ']'\
+            '}'\
+          ']'\
+        '}'
+      hash = JSON.parse(json)
+      actual = SendGrid4r::REST::Contacts::Recipients.create_recipients(hash)
+      expect(actual.recipients.is_a?(Array)).to eq(true)
+      actual.recipients.each do |recipient|
+        expect(
+          recipient.is_a?(SendGrid4r::REST::Contacts::Recipients::Recipient)
+        ).to eq(true)
+      end
+    end
+  end
+end