sendgrid4r 0.2.0 → 0.3.0

data/spec/asm/asm_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe SendGrid4r::REST::Asm do
+  describe 'unit test' do
+    it 'creates recipient_emails instance' do
+      json =
+        '{'\
+          '"recipient_emails": ['\
+            '"test1@example.com",'\
+            '"test2@example.com"'\
+          ']'\
+        '}'
+      hash = JSON.parse(json)
+      actual = SendGrid4r::REST::Asm.create_recipient_emails(hash)
+      expect(actual).to be_a(SendGrid4r::REST::Asm::RecipientEmails)
+      expect(actual.recipient_emails).to be_a(Array)
+      expect(actual.recipient_emails).to include('test1@example.com')
+      expect(actual.recipient_emails).to include('test2@example.com')
+    end
+
+    it 'creates recipient_email instance' do
+      json =
+        '{'\
+          '"recipient_email": "test1@example.com"'\
+        '}'
+      hash = JSON.parse(json)
+      actual = SendGrid4r::REST::Asm.create_recipient_email(hash)
+      expect(actual).to be_a(SendGrid4r::REST::Asm::RecipientEmail)
+      expect(actual.recipient_email).to eq('test1@example.com')
+    end
+  end
+end

data/spec/asm/global_suppressions_spec.rb

@@ -1,52 +1,118 @@
 # encoding: utf-8
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe 'SendGrid4r::REST::Asm::GlobalSuppressions' do
-  before :all do
-    Dotenv.load
-    @client = SendGrid4r::Client.new(
-      ENV['SENDGRID_USERNAME'], ENV['SENDGRID_PASSWORD'])
-    @email1 = 'test1@test.com'
-    @email2 = 'test2@test.com'
-    @email3 = 'test3@test.com'
-  end
+describe SendGrid4r::REST::Asm::GlobalSuppressions do
+  describe 'integration test' do
+    before do
+      begin
+        Dotenv.load
+        @client = SendGrid4r::Client.new(
+          username: ENV['SENDGRID_USERNAME'],
+          password: ENV['SENDGRID_PASSWORD'])
+        @email1 = 'test1@test.com'
+        @email2 = 'test2@test.com'
+        @email3 = 'test3@test.com'
+
+        actual_email1 = @client.get_global_suppressed_email(@email1)
+        actual_email2 = @client.get_global_suppressed_email(@email2)
+        actual_email3 = @client.get_global_suppressed_email(@email3)
+        @client.delete_global_suppressed_email(
+          @email1
+        ) if actual_email1 == @email1
+        @client.delete_global_suppressed_email(
+          @email2
+        ) if actual_email2 == @email2
+        @client.delete_global_suppressed_email(
+          @email3
+        ) if actual_email3 == @email3
+      rescue => e
+        puts e.inspect
+        raise e
+      end
+    end
+
+    context 'without block call' do
+      it '#post_global_suppressed_emails' do
+        begin
+          emails = @client.post_global_suppressed_emails(
+            [@email1, @email2, @email3]
+          )
+          expect(emails.recipient_emails.length).to eq(3)
+          expect(emails.recipient_emails.include? @email1).to eq(true)
+          expect(emails.recipient_emails.include? @email2).to eq(true)
+          expect(emails.recipient_emails.include? @email3).to eq(true)
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+
+      it '#get_global_suppressed_email' do
+        begin
+          actual_email1 = @client.get_global_suppressed_email(@email1)
+          actual_email2 = @client.get_global_suppressed_email(@email2)
+          actual_email3 = @client.get_global_suppressed_email(@email3)
+          actual_notexist = @client.get_global_suppressed_email('notexist')
+          expect(actual_email1.recipient_email).to eq(@email1)
+          expect(actual_email2.recipient_email).to eq(@email2)
+          expect(actual_email3.recipient_email).to eq(@email3)
+          expect(actual_notexist.recipient_email).to eq(nil)
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+
+      it '#delete_global_suppressed_email' do
+        begin
+          expect(@client.delete_global_suppressed_email(@email1)).to eq('')
+          expect(@client.delete_global_suppressed_email(@email2)).to eq('')
+          expect(@client.delete_global_suppressed_email(@email3)).to eq('')
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+    end
+
+    context 'with block call' do
+      it '#post_global_suppressed_emails' do
+        @client.post_global_suppressed_emails(
+          [@email1, @email2, @email3]
+        ) do |resp, req, res|
+          resp =
+            SendGrid4r::REST::Asm.create_recipient_emails(
+              JSON.parse(resp)
+            )
+          expect(resp).to be_a(
+            SendGrid4r::REST::Asm::RecipientEmails
+          )
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPCreated)
+        end
+      end
+
+      it '#get_global_suppressed_email' do
+        @client.get_global_suppressed_email(@email1) do |resp, req, res|
+          resp =
+            SendGrid4r::REST::Asm.create_recipient_email(
+              JSON.parse(resp)
+            )
+          expect(resp).to be_a(
+            SendGrid4r::REST::Asm::RecipientEmail
+          )
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPOK)
+        end
+      end
 
-  context 'always' do
-    it 'is normal' do
-      # celan up test env
-      actual_email1 = @client.get_global_suppressed_email(@email1)
-      actual_email2 = @client.get_global_suppressed_email(@email2)
-      actual_email3 = @client.get_global_suppressed_email(@email3)
-      @client.delete_global_suppressed_email(
-        @email1
-      ) if actual_email1 == @email1
-      @client.delete_global_suppressed_email(
-        @email2
-      ) if actual_email2 == @email2
-      @client.delete_global_suppressed_email(
-        @email3
-      ) if actual_email3 == @email3
-      # post_global_suppressed_emails
-      suppressed_emails = @client.post_global_suppressed_emails(
-        [@email1, @email2, @email3]
-      )
-      expect(suppressed_emails.length).to eq(3)
-      expect(suppressed_emails.include? @email1).to eq(true)
-      expect(suppressed_emails.include? @email2).to eq(true)
-      expect(suppressed_emails.include? @email3).to eq(true)
-      # get_global_suppressed_email
-      actual_email1 = @client.get_global_suppressed_email(@email1)
-      actual_email2 = @client.get_global_suppressed_email(@email2)
-      actual_email3 = @client.get_global_suppressed_email(@email3)
-      actual_notexist = @client.get_global_suppressed_email('notexist')
-      expect(actual_email1).to eq(@email1)
-      expect(actual_email2).to eq(@email2)
-      expect(actual_email3).to eq(@email3)
-      expect(actual_notexist).to eq(nil)
-      # delete_global_suppressed_email
-      expect(@client.delete_global_suppressed_email(@email1)).to eq('')
-      expect(@client.delete_global_suppressed_email(@email2)).to eq('')
-      expect(@client.delete_global_suppressed_email(@email3)).to eq('')
+      it '#delete_global_suppressed_email' do
+        @client.delete_global_suppressed_email(@email1) do |resp, req, res|
+          expect(resp).to eq('')
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPNoContent)
+        end
+      end
     end
   end
 end

data/spec/asm/groups_spec.rb

@@ -1,58 +1,182 @@
 # encoding: utf-8
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe 'SendGrid4r::REST::Asm::Groups' do
-  before :all do
-    Dotenv.load
-    @client = SendGrid4r::Client.new(
-      ENV['SENDGRID_USERNAME'], ENV['SENDGRID_PASSWORD'])
-    @group_name = 'group_test'
-    @group_edit = 'group_edit'
-    @group_desc = 'group_desc'
-    @group_desc_edit = 'group_desc_edit'
-  end
+describe SendGrid4r::REST::Asm::Groups do
+  describe 'integration test' do
+    before do
+      begin
+        Dotenv.load
+        @client = SendGrid4r::Client.new(
+          username: ENV['SENDGRID_USERNAME'],
+          password: ENV['SENDGRID_PASSWORD'])
+        @group_name1 = 'group_test1'
+        @group_name2 = 'group_test2'
+        @group_name_edit1 = 'group_edit1'
+        @group_desc = 'group_desc'
+        @group_desc_edit = 'group_desc_edit'
+
+        # celan up test env
+        grps = @client.get_groups
+        grps.each do |grp|
+          @client.delete_group(grp.id) if grp.name == @group_name1
+          @client.delete_group(grp.id) if grp.name == @group_name_edit1
+          @client.delete_group(grp.id) if grp.name == @group_name2
+        end
+        # post a group
+        @group1 = @client.post_group(@group_name1, @group_desc)
+      rescue => e
+        puts e.inspect
+        raise e
+      end
+    end
+
+    context 'without block call' do
+      it '#post_group' do
+        begin
+          group2 = @client.post_group(@group_name2, @group_desc)
+          expect(@group_name2).to eq(group2.name)
+          expect(@group_desc).to eq(group2.description)
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+
+      it '#patch_group' do
+        begin
+          @group1.name = @group_name_edit1
+          @group1.description = @group_desc_edit
+          group_edit1 = @client.patch_group(@group1.id, @group1)
+          expect(group_edit1.id).to be_a(Fixnum)
+          expect(group_edit1.name).to eq(@group_name_edit1)
+          expect(group_edit1.description).to eq(@group_desc_edit)
+          expect(group_edit1.last_email_sent_at).to eq(nil)
+          expect(group_edit1.unsubscribes).to eq(nil)
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+
+      it '#get_groups' do
+        begin
+          groups = @client.get_groups
+          expect(groups).to be_a(Array)
+          groups.each do |group|
+            expect(group).to be_a(SendGrid4r::REST::Asm::Groups::Group)
+          end
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
 
-  context 'always' do
-    it 'is normal' do
-      # celan up test env
-      grps = @client.get_groups
-      expect(grps.length >= 0).to eq(true)
-      grps.each do |grp|
-        if grp.name == @group_name || grp.name == @group_edit
-          @client.delete_group(grp.id)
-        end
-      end
-      # post a group
-      new_group = @client.post_group(@group_name, @group_desc)
-      expect(@group_name).to eq(new_group.name)
-      expect(@group_desc).to eq(new_group.description)
-      # patch the group
-      new_group.name = @group_edit
-      new_group.description = @group_desc_edit
-      @client.patch_group(new_group.id, new_group)
-      # get the group
-      edit_group = @client.get_group(new_group.id)
-      expect(edit_group.respond_to?('id')).to eq(true)
-      expect(edit_group.respond_to?('name')).to eq(true)
-      expect(edit_group.respond_to?('description')).to eq(true)
-      expect(edit_group.respond_to?('last_email_sent_at')).to eq(true)
-      expect(edit_group.respond_to?('unsubscribes')).to eq(true)
-      expect(new_group.id).to eq(edit_group.id)
-      expect(@group_edit).to eq(edit_group.name)
-      expect(@group_desc_edit).to eq(edit_group.description)
-      # delete the group
-      @client.delete_group(edit_group.id)
-      expect do
-        @client.get_group(edit_group.id)
-      end.to raise_error(RestClient::ResourceNotFound)
+      it '#get_group' do
+        begin
+          group = @client.get_group(@group1.id)
+          expect(group.id).to be_a(Fixnum)
+          expect(group.name).to eq(@group_name1)
+          expect(group.description).to eq(@group_desc)
+          expect(group.last_email_sent_at).to eq(nil)
+          expect(group.unsubscribes).to eq(0)
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+
+      it '#delete_group' do
+        begin
+          @client.delete_group(@group1.id)
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+    end
+
+    context 'with block call' do
+      it '#post_group' do
+        @client.post_group(@group_name2, @group_desc) do |resp, req, res|
+          resp =
+            SendGrid4r::REST::Asm::Groups.create_group(
+              JSON.parse(resp)
+            )
+          expect(resp).to be_a(SendGrid4r::REST::Asm::Groups::Group)
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPCreated)
+        end
+      end
+
+      it '#patch_group' do
+        @client.patch_group(@group1.id, @group1) do |resp, req, res|
+          resp =
+            SendGrid4r::REST::Asm::Groups.create_group(
+              JSON.parse(resp)
+            )
+          expect(resp).to be_a(SendGrid4r::REST::Asm::Groups::Group)
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPOK)
+        end
+      end
+
+      it '#get_groups' do
+        @client.get_groups do |resp, req, res|
+          resp =
+            SendGrid4r::REST::Asm::Groups.create_groups(
+              JSON.parse(resp)
+            )
+          expect(resp).to be_a(Array)
+          resp.each do |group|
+            expect(group).to be_a(SendGrid4r::REST::Asm::Groups::Group)
+          end
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPOK)
+        end
+      end
+
+      it '#get_group' do
+        @client.get_group(@group1.id) do |resp, req, res|
+          resp =
+            SendGrid4r::REST::Asm::Groups.create_group(
+              JSON.parse(resp)
+            )
+          expect(resp).to be_a(SendGrid4r::REST::Asm::Groups::Group)
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPOK)
+        end
+      end
+
+      it '#delete_group' do
+        @client.delete_group(@group1.id) do |resp, req, res|
+          expect(resp).to eq('')
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPNoContent)
+        end
+      end
     end
   end
 
-  context 'abnormal' do
-    it 'raise resource not found for none existance id' do
-      expect do
-        @client.get_group('notexistid')
-      end.to raise_error(RestClient::ResourceNotFound)
+  describe 'unit test' do
+    it 'creates group instance' do
+      json =
+        '{'\
+          '"id": 100,'\
+          '"name": "Newsletters",'\
+          '"description": "Our monthly newsletter.",'\
+          '"last_email_sent_at": "2014-09-04 01:34:43",'\
+          '"unsubscribes": 400'\
+        '}'
+      hash = JSON.parse(json)
+      actual = SendGrid4r::REST::Asm::Groups.create_group(hash)
+      expect(actual).to be_a(
+        SendGrid4r::REST::Asm::Groups::Group
+      )
+      expect(actual.id).to eq(100)
+      expect(actual.name).to eq('Newsletters')
+      expect(actual.description).to eq('Our monthly newsletter.')
+      expect(actual.last_email_sent_at).to eq('2014-09-04 01:34:43')
+      expect(actual.unsubscribes).to eq(400)
     end
   end
 end

data/spec/asm/suppressions_spec.rb

@@ -1,64 +1,190 @@
 # encoding: utf-8
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe 'SendGrid4r::REST::Asm::Groups::Suppressions' do
-  before :all do
-    Dotenv.load
-    @client = SendGrid4r::Client.new(
-      ENV['SENDGRID_USERNAME'], ENV['SENDGRID_PASSWORD'])
-    @email1 = 'test1@test.com'
-    @email2 = 'test2@test.com'
-    @email3 = 'test3@test.com'
-    @group_name = 'suppressions_test'
-    @group_desc = 'group_desc'
-  end
+describe SendGrid4r::REST::Asm::Suppressions do
+  describe 'integration test' do
+    before do
+      begin
+        Dotenv.load
+        @client = SendGrid4r::Client.new(
+          username: ENV['SENDGRID_USERNAME'],
+          password: ENV['SENDGRID_PASSWORD'])
+        @email1 = 'test1@test.com'
+        @email2 = 'test2@test.com'
+        @email3 = 'test3@test.com'
+        @group_name = 'suppressions_test'
+        @group_desc = 'group_desc'
+
+        # celan up test env
+        grps = @client.get_groups
+        grps.each do |grp|
+          next if grp.name != @group_name
+          emails = @client.get_suppressed_emails(grp.id)
+          emails.each do |email|
+            @client.delete_suppressed_email(grp.id, email)
+          end
+          @client.delete_group(grp.id)
+        end
+        # post a group
+        @group = @client.post_group(@group_name, @group_desc)
+        # post suppressed email
+        @client.post_suppressed_emails(@group.id, [@email1])
+      rescue => e
+        puts e.inspect
+        raise e
+      end
+    end
+
+    context 'wthout block call' do
+      it '#post_suppressed_emails' do
+        begin
+          emails = @client.post_suppressed_emails(
+            @group.id, [@email2, @email3]
+          )
+          expect(emails.recipient_emails.length).to eq(2)
+          expect(emails.recipient_emails[0]).to eq(@email2)
+          expect(emails.recipient_emails[1]).to eq(@email3)
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+
+      it '#get_suppressed_emails' do
+        begin
+          emails = @client.get_suppressed_emails(@group.id)
+          expect(emails.length).to eq(1)
+          expect(emails[0]).to eq(@email1)
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+
+      it '#get_suppressions' do
+        begin
+          suppressions = @client.get_suppressions(@email1)
+          expect(suppressions.suppressions).to be_a(Array)
+          suppressions.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
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+
+      it '#delete_suppressed_email' do
+        begin
+          @client.delete_suppressed_email(@group.id, @email1)
+          @client.delete_suppressed_email(@group.id, @email2)
+          @client.delete_suppressed_email(@group.id, @email3)
+        rescue => e
+          puts e.inspect
+          raise e
+        end
+      end
+    end
+
+    context 'wthout block call' do
+      it '#post_suppressed_emails' do
+        @client.post_suppressed_emails(
+          @group.id, [@email2, @email3]
+        ) do |resp, req, res|
+          resp =
+            SendGrid4r::REST::Asm.create_recipient_emails(
+              JSON.parse(resp)
+            )
+          expect(resp).to be_a(
+            SendGrid4r::REST::Asm::RecipientEmails
+          )
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPCreated)
+        end
+      end
+
+      it '#get_suppressed_emails' do
+        @client.get_suppressed_emails(@group.id) do |resp, req, res|
+          expect(resp).to be_a(Array)
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPOK)
+        end
+      end
 
-  context 'always' do
-    it 'is normal' do
-      # celan up test env
-      grps = @client.get_groups
-      expect(grps.length >= 0).to eq(true)
-      grps.each do |grp|
-        next if grp.name != @group_name
-        emails = @client.get_suppressed_emails(grp.id)
-        emails.each do |email|
-          @client.delete_suppressed_email(grp.id, email)
+      it '#get_suppressions' do
+        @client.get_suppressions(@email1) do |resp, req, res|
+          resp =
+            SendGrid4r::REST::Asm::Suppressions.create_suppressions(resp)
+          expect(resp).to be_a(
+            SendGrid4r::REST::Asm::Suppressions::Suppressions
+          )
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPOK)
         end
-        @client.delete_group(grp.id)
       end
-      # post a group
-      new_group = @client.post_group(@group_name, @group_desc)
-      # post recipient emails to the suppression group
-      suppressed_emails = @client.post_suppressed_emails(
-        new_group.id, [@email1, @email2, @email3])
-      expect(suppressed_emails.length).to eq(3)
-      expect(suppressed_emails[0]).to eq(@email1)
-      expect(suppressed_emails[1]).to eq(@email2)
-      expect(suppressed_emails[2]).to eq(@email3)
-      # get the suppressions
-      suppressions = @client.get_suppressions(@email1)
-      expect(suppressions.length >= 1).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)
+
+      it '#delete_suppressed_email' do
+        @client.delete_suppressed_email(@group.id, @email1) do |resp, req, res|
+          expect(resp).to eq('')
+          expect(req).to be_a(RestClient::Request)
+          expect(res).to be_a(Net::HTTPNoContent)
+        end
+      end
+    end
+  end
+
+  describe 'unit test' do
+    it 'creates suppressions instance' do
+      json =
+        '{'\
+          '"suppressions": ['\
+            '{'\
+              '"id": 1,'\
+              '"name": "Weekly Newsletter",'\
+              '"description": "The weekly newsletter",'\
+              '"suppressed": false'\
+            '},'\
+            '{'\
+              '"id": 4,'\
+              '"name": "Special Offers",'\
+              '"description": "Special offers and coupons",'\
+              '"suppressed": false'\
+            '}'\
+          ']'\
+        '}'
+      hash = JSON.parse(json)
+      actual = SendGrid4r::REST::Asm::Suppressions.create_suppressions(hash)
+      expect(actual).to be_a(
+        SendGrid4r::REST::Asm::Suppressions::Suppressions
+      )
+      expect(actual.suppressions).to be_a(Array)
+      actual.suppressions.each do |suppression|
+        expect(suppression).to be_a(
+          SendGrid4r::REST::Asm::Suppressions::Suppression
+        )
       end
-      # get the recipient emails
-      actual_emails = @client.get_suppressed_emails(new_group.id)
-      expect(actual_emails.length).to eq(suppressed_emails.length)
-      expect(actual_emails[0]).to eq(suppressed_emails[0])
-      expect(actual_emails[1]).to eq(suppressed_emails[1])
-      expect(actual_emails[2]).to eq(suppressed_emails[2])
-      # delete the suppressed email
-      @client.delete_suppressed_email(new_group.id, @email1)
-      @client.delete_suppressed_email(new_group.id, @email2)
-      @client.delete_suppressed_email(new_group.id, @email3)
-      # delete the group
-      @client.delete_group(new_group.id)
-      expect do
-        @client.get_group(new_group.id)
-      end.to raise_error(RestClient::ResourceNotFound)
+    end
+
+    it 'creates suppression instance' do
+      json =
+        '{'\
+          '"id": 4,'\
+          '"name": "Special Offers",'\
+          '"description": "Special offers and coupons",'\
+          '"suppressed": false'\
+        '}'
+      hash = JSON.parse(json)
+      actual = SendGrid4r::REST::Asm::Suppressions.create_suppression(hash)
+      expect(actual).to be_a(
+        SendGrid4r::REST::Asm::Suppressions::Suppression
+      )
+      expect(actual.id).to eq(4)
+      expect(actual.name).to eq('Special Offers')
+      expect(actual.description).to eq('Special offers and coupons')
+      expect(actual.suppressed).to eq(false)
     end
   end
 end