sendgrid4r 0.2.0 → 0.3.0

data/spec/ips/addresses_spec.rb

@@ -1,116 +1,209 @@
 # encoding: utf-8
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe 'SendGrid4r::REST::Ips::Addresses' do
-  before :all do
-    Dotenv.load
-  end
-
-  context 'if account is free' do
-    before :all do
+describe SendGrid4r::REST::Ips::Addresses do
+  describe 'integration test' do
+    before do
+      Dotenv.load
       @client = SendGrid4r::Client.new(
-        ENV['SENDGRID_USERNAME'], ENV['SENDGRID_PASSWORD'])
+        username: ENV['SENDGRID_USERNAME'],
+        password: ENV['SENDGRID_PASSWORD'])
     end
 
-    describe '#get_ips_assigned' do
-      it 'raise error' do
-        expect do
-          @client.get_ips_assigned
-        end.to raise_error(RestClient::Forbidden)
+    context 'account is free' do
+      describe '#get_ip' do
+        it 'raise error' do
+          begin
+            expect do
+              @client.get_ip('10.10.10.10').to raise_error(
+                RestClient::Forbidden
+              )
+            end
+          rescue => e
+            puts e.inspect
+            raise e
+          end
+        end
       end
     end
 
-    describe '#get_ip' do
-      it 'raise error' do
+    context 'account is silver' do
+      TEST_POOL = 'test_pool'
+
+      before do
         begin
-          expect do
-            @client.get_ip('10.10.10.10').to raise_error(RestClient::Forbidden)
+          @client = SendGrid4r::Client.new(
+            username: ENV['SILVER_SENDGRID_USERNAME'],
+            password: ENV['SILVER_SENDGRID_PASSWORD'])
+          # refresh the pool
+          pools = @client.get_pools
+          pools.each do |pool|
+            @client.delete_pool(TEST_POOL) if pool.name == TEST_POOL
           end
+          @client.post_pool(TEST_POOL)
         rescue => e
           puts e.inspect
           raise e
         end
       end
-    end
-  end
 
-  context 'if account is silver' do
-    TEST_POOL = 'test_pool'
-    before :all do
-      begin
-        @client = SendGrid4r::Client.new(
-          ENV['SILVER_SENDGRID_USERNAME'], ENV['SILVER_SENDGRID_PASSWORD'])
-        # refresh the pool
-        pools = @client.get_pools
-        pools.each do |pool|
-          @client.delete_pool(TEST_POOL) if pool.name == TEST_POOL
+      context 'without block call' do
+        it '#get_ips' do
+          begin
+            ips = @client.get_ips
+            expect(ips.length).to be > 0
+            ip = ips[0]
+            expect(ip).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
+            expect(ip.ip).to be_a(String)
+            expect(ip.pools).to be_a(Array)
+            expect(ip.warmup ? true : true).to eq(true)
+          rescue => e
+            puts e.inspect
+            raise e
+          end
         end
-        @client.post_pool(TEST_POOL)
-        # ips = @client.get_ips
-        # @client.delete_ip_from_pool(TEST_POOL, ips[0].ip)
-      rescue => e
-        puts e.inspect
-        raise e
-      end
-    end
 
-    describe '#get_ips' do
-      it 'returns Array of Address instance' do
-        ips = @client.get_ips
-        expect(ips.length > 0).to be(true)
-        ip = ips[0]
-        expect(ip.class).to be(SendGrid4r::REST::Ips::Addresses::Address)
-        expect(ip.ip.nil?).to be(false)
-        # expect(ip.pools.nil?).to be(false)
-        # expect(ip.start_date.nil?).to be(false)
-        expect(ip.warmup.nil?).to be(false)
+        it '#get_ips_assigned' do
+          begin
+            ips = @client.get_ips_assigned
+            expect(ips.length).to be > 0
+            expect(ips[0]).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
+          rescue => e
+            puts e.inspect
+            raise e
+          end
+        end
+
+        it '#get_ip' do
+          begin
+            ips = @client.get_ips_assigned
+            expect(
+              @client.get_ip(ips[0].ip)
+            ).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
+          rescue => e
+            puts e.inspect
+            raise e
+          end
+        end
+
+        it '#post_ip_to_pool' do
+          begin
+            ips = @client.get_ips_assigned
+            actual = @client.post_ip_to_pool(TEST_POOL, ips[0].ip)
+            expect(actual.ip).to eq(ips[0].ip)
+            expect(actual.pools).to include(TEST_POOL)
+            expect(actual.pools).to be_a(Array)
+            @client.delete_ip_from_pool(TEST_POOL, ips[0].ip)
+          rescue => e
+            puts e.inspect
+            raise e
+          end
+        end
       end
-    end
 
-    describe '#get_ips_assigned' do
-      it 'returns Array of Address instance' do
-        ips = @client.get_ips_assigned
-        expect(ips.length > 0).to be(true)
-        expect(ips[0].class).to be(SendGrid4r::REST::Ips::Addresses::Address)
+      context 'with block call' do
+        it '#get_ips' do
+          @client.get_ips do |resp, req, res|
+            resp =
+              SendGrid4r::REST::Ips::Addresses.create_addresses(
+                JSON.parse(resp)
+              )
+            expect(resp).to be_a(Array)
+            expect(req).to be_a(RestClient::Request)
+            expect(res).to be_a(Net::HTTPOK)
+          end
+        end
+
+        it '#get_ips_assigned' do
+          @client.get_ips_assigned do |resp, req, res|
+            resp =
+              SendGrid4r::REST::Ips::Addresses.create_addresses(
+                JSON.parse(resp)
+              )
+            expect(resp).to be_a(Array)
+            expect(req).to be_a(RestClient::Request)
+            expect(res).to be_a(Net::HTTPOK)
+          end
+        end
+
+        it '#get_ip' do
+          ips = @client.get_ips_assigned
+          @client.get_ip(ips[0].ip) do |resp, req, res|
+            resp =
+              SendGrid4r::REST::Ips::Addresses.create_address(
+                JSON.parse(resp)
+              )
+            expect(resp).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
+            expect(req).to be_a(RestClient::Request)
+            expect(res).to be_a(Net::HTTPOK)
+          end
+        end
+
+        it '#post_ip_to_pool' do
+          ips = @client.get_ips_assigned
+          @client.post_ip_to_pool(TEST_POOL, ips[0].ip) do |resp, req, res|
+            resp =
+              SendGrid4r::REST::Ips::Addresses.create_address(
+                JSON.parse(resp)
+              )
+            expect(resp).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
+            expect(req).to be_a(RestClient::Request)
+            expect(res).to be_a(Net::HTTPCreated)
+          end
+          @client.delete_ip_from_pool(TEST_POOL, ips[0].ip) 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 '#get_ip' do
-      it 'returns Address instance' do
-        begin
-          ips = @client.get_ips_assigned
+    describe 'unit test' do
+      it 'creates addresses instance' do
+        json =
+          '['\
+            '{'\
+              '"ip":"000.00.00.0",'\
+              '"pools":["new_test5"],'\
+              '"warmup":true,'\
+              '"start_date":1409616000,'\
+              '"subusers": ["username1", "username2"],'\
+              '"rdns": "01.email.test.com",'\
+              '"pools": ["pool1", "pool2"]'\
+            '}'\
+          ']'
+        hash = JSON.parse(json)
+        actual = SendGrid4r::REST::Ips::Addresses.create_addresses(hash)
+        expect(actual).to be_a(Array)
+        actual.each do |address|
           expect(
-            @client.get_ip(ips[0].ip).class
-          ).to be(SendGrid4r::REST::Ips::Addresses::Address)
-        rescue => e
-          puts e.inspect
-          raise e
+            address
+          ).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
         end
       end
-    end
 
-    describe '#post_ip_to_pool' do
-      it 'add ip to pool successfully' do
-        ips = @client.get_ips_assigned
-        actual = @client.post_ip_to_pool(TEST_POOL, ips[0].ip)
-        expect(actual.ip).to eq(ips[0].ip)
-        expect(actual.pools).to include(TEST_POOL)
-        expect(actual.pools.class).to be(Array)
+      it 'creates address instance' do
+        json =
+          '{'\
+            '"ip": "000.00.00.0",'\
+            '"pools": ['\
+              '"test1"'\
+            '],'\
+            '"start_date": 1409616000,'\
+            '"warmup": true'\
+          '}'
+        hash = JSON.parse(json)
+        actual = SendGrid4r::REST::Ips::Addresses.create_address(hash)
+        expect(actual).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
+        expect(actual.ip).to eq('000.00.00.0')
+        expect(actual.pools).to be_a(Array)
+        actual.pools.each do |pool|
+          expect(pool).to eq('test1')
+        end
+        expect(actual.start_date).to eq(Time.at(1409616000))
+        expect(actual.warmup).to eq(true)
       end
     end
-
-    # Could not test because POST an IP to a pool takes 60 sec
-    # describe '#delete_ip_from_pool' do
-    #   it 'delete ip from pool successfully' do
-    #     begin
-    #       ips = @client.get_ips
-    #       @client.post_ip_to_pool(TEST_POOL, ips[0].ip)
-    #       @client.delete_ip_from_pool(TEST_POOL, ips[0].ip)
-    #     rescue => e
-    #       puts e.inspect
-    #       raise e
-    #     end
-    #   end
-    # end
   end
 end

data/spec/ips/pools_spec.rb

@@ -1,43 +1,199 @@
 # encoding: utf-8
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe 'SendGrid4r::REST::Ips::Pools' do
-  before :all do
-    Dotenv.load
-    @client = SendGrid4r::Client.new(
-      ENV['SILVER_SENDGRID_USERNAME'], ENV['SILVER_SENDGRID_PASSWORD'])
-    @pool_name = 'pool_test'
-    @pool_edit = 'pool_edit'
-  end
+describe SendGrid4r::REST::Ips::Pools do
+  describe 'integration test' do
+    before do
+      begin
+        Dotenv.load
+        @client = SendGrid4r::Client.new(
+          username: ENV['SILVER_SENDGRID_USERNAME'],
+          password: ENV['SILVER_SENDGRID_PASSWORD'])
+
+        @pool_name1 = 'pool_test1'
+        @pool_name2 = 'pool_test2'
+        @pool_edit1 = 'pool_edit1'
+
+        # clean up test env
+        pools = @client.get_pools
+        pools.each do |pool|
+          @client.delete_pool(pool.name) if pool.name == @pool_name1
+          @client.delete_pool(pool.name) if pool.name == @pool_name2
+          @client.delete_pool(pool.name) if pool.name == @pool_edit1
+        end
+        # post a pool
+        @client.post_pool(@pool_name1)
+      rescue => e
+        puts e.inspect
+        raise e
+      end
+    end
+
+    context 'account is silver' do
+      context 'without block call' do
+        it '#post_pool' do
+          begin
+            new_pool = @client.post_pool(@pool_name2)
+            expect(new_pool.name).to eq(@pool_name2)
+          rescue => e
+            puts e.inspect
+            raise e
+          end
+        end
+
+        it '#get_pools' do
+          begin
+            pools = @client.get_pools
+            expect(pools.length).to be > 0
+            pools.each do |pool|
+              expect(pool).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
+              expect(pool.name).to be_a(String)
+            end
+          rescue => e
+            puts e.inspect
+            raise e
+          end
+        end
+
+        it '#get_pool' do
+          begin
+            pool = @client.get_pool(@pool_name1)
+            expect(pool).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
+            expect(pool.pool_name).to eq(@pool_name1)
+            expect(pool.ips).to be_a(Array)
+          rescue => e
+            puts e.inspect
+            raise e
+          end
+        end
+
+        it '#put_pool' do
+          begin
+            edit_pool = @client.put_pool(@pool_name1, @pool_edit1)
+            expect(edit_pool.name).to eq(@pool_edit1)
+          rescue => e
+            puts e.inspect
+            raise e
+          end
+        end
+
+        it '#delete_pool' do
+          begin
+            @client.delete_pool(@pool_name1)
+          rescue => e
+            puts e.inspect
+            raise e
+          end
+        end
+      end
+
+      context 'with block call' do
+        it '#post_pool' do
+          @client.post_pool(@pool_name2) do |resp, req, res|
+            resp =
+              SendGrid4r::REST::Ips::Pools.create_pool(
+                JSON.parse(resp)
+              )
+            expect(resp).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
+            expect(req).to be_a(RestClient::Request)
+            expect(res).to be_a(Net::HTTPCreated)
+          end
+        end
+
+        it '#get_pools' do
+          @client.get_pools do |resp, req, res|
+            resp =
+              SendGrid4r::REST::Ips::Pools.create_pools(
+                JSON.parse(resp)
+              )
+            expect(resp).to be_a(Array)
+            expect(req).to be_a(RestClient::Request)
+            expect(res).to be_a(Net::HTTPOK)
+          end
+        end
+
+        it '#get_pool' do
+          @client.get_pool(@pool_name1) do |resp, req, res|
+            resp =
+              SendGrid4r::REST::Ips::Pools.create_pool(
+                JSON.parse(resp)
+              )
+            expect(resp).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
+            expect(req).to be_a(RestClient::Request)
+            expect(res).to be_a(Net::HTTPOK)
+          end
+        end
+
+        it '#put_pool' do
+          @client.put_pool(@pool_name1, @pool_edit1) do |resp, req, res|
+            resp =
+              SendGrid4r::REST::Ips::Pools.create_pool(
+                JSON.parse(resp)
+              )
+            expect(resp).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
+            expect(req).to be_a(RestClient::Request)
+            expect(res).to be_a(Net::HTTPOK)
+          end
+        end
+
+        it '#delete_pool' do
+          @client.delete_pool(@pool_name1) 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 pool instance' do
+        json = '{"name":"marketing"}'
+        hash = JSON.parse(json)
+        actual = SendGrid4r::REST::Ips::Pools.create_pool(hash)
+        expect(actual).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
+        expect(actual.name).to eq('marketing')
+      end
+
+      it 'creates pool instance with ips' do
+        json =
+          '{'\
+            '"ips":["167.89.21.3"],'\
+            '"name":"new_test5"'\
+          '}'
+        hash = JSON.parse(json)
+        actual = SendGrid4r::REST::Ips::Pools.create_pool(hash)
+        expect(actual).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
+        expect(actual.ips).to be_a(Array)
+        actual.ips.each do |ip|
+          expect(ip).to eq('167.89.21.3')
+        end
+        expect(actual.name).to eq('new_test5')
+      end
 
-  context 'if account is silver' do
-    it 'is normal' do
-      # clean up test env
-      pools = @client.get_pools
-      expect(pools.length >= 0).to eq(true)
-      pools.each do |pool|
-        if pool.name == @pool_name || pool.name == @pool_edit
-          @client.delete_pool(pool.name)
+      it 'creates pool instances' do
+        json =
+          '['\
+            '{'\
+              '"name": "test1"'\
+            '},'\
+            '{'\
+              '"name": "test2"'\
+            '},'\
+            '{'\
+              '"name": "test3"'\
+            '},'\
+            '{'\
+              '"name": "new_test3"'\
+            '}'\
+          ']'
+        hash = JSON.parse(json)
+        actual = SendGrid4r::REST::Ips::Pools.create_pools(hash)
+        expect(actual).to be_a(Array)
+        actual.each do |pool|
+          expect(pool).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
         end
       end
-      # post a pool
-      new_pool = @client.post_pool(@pool_name)
-      expect(@pool_name).to eq(new_pool.name)
-      # put the pool
-      edit_pool = @client.put_pool(@pool_name, @pool_edit)
-      expect(@pool_edit).to eq(edit_pool.name)
-      # get the pool
-      pool = @client.get_pool(@pool_edit)
-      expect(SendGrid4r::REST::Ips::Pools::Pool).to be(pool.class)
-      # delete the pool
-      @client.delete_pool(pool.pool_name)
-      expect { @client.get_pool(pool.name) }
-      ips = @client.get_ips
-      expect(ips.length).to be(1)
-      expect(ips[0].class).to be(SendGrid4r::REST::Ips::Addresses::Address)
-      expect(
-        @client.get_ip(ips[0].ip).class
-      ).to be(SendGrid4r::REST::Ips::Addresses::Address)
     end
   end
 end

data/spec/ips/warmup_spec.rb

@@ -1,52 +1,120 @@
 # encoding: utf-8
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe 'SendGrid4r::REST::Ips::WarmUp' do
-  before :all do
-    Dotenv.load
-  end
+describe SendGrid4r::REST::Ips::Warmup do
+  describe 'integration test' do
+    before do
+      Dotenv.load
+      @client = SendGrid4r::Client.new(
+        username: ENV['SILVER_SENDGRID_USERNAME'],
+        password: ENV['SILVER_SENDGRID_PASSWORD'])
+    end
 
-  context 'normal' do
-    it 'is normal' do
-      begin
-        client = SendGrid4r::Client.new(
-          ENV['SILVER_SENDGRID_USERNAME'], ENV['SILVER_SENDGRID_PASSWORD'])
-        # celan up test env
-        warmup_ips = client.get_warmup_ips
-        expect(warmup_ips.length >= 0).to eq(true)
-        if warmup_ips.length > 0
-          warmup_ips.each do |warmup_ip|
-            client.delete_warmup_ip(warmup_ip.ip)
+    context 'account is silver' do
+      before do
+        begin
+          # celan up test env
+          warmup_ips = @client.get_warmup_ips
+          if warmup_ips.length > 0
+            warmup_ips.each do |warmup_ip|
+              @client.delete_warmup_ip(warmup_ip.ip)
+            end
           end
+        rescue => e
+          puts e.inspect
+          raise e
         end
-        # get warmup ip
-        warmup_ips = client.get_warmup_ips
-        expect(warmup_ips.length).to eq(0)
-        # post warmup ip
-        ips = client.get_ips
-        if ips.length > 0
-          warmup_ip = client.post_warmup_ip(ips[0].ip)
-          expect(warmup_ip.ip).to eq(ips[0].ip)
+      end
+
+      context 'without block call' do
+        it 'warmup_ip spec' do
+          begin
+            # get warmup ip
+            warmup_ips = @client.get_warmup_ips
+            expect(warmup_ips.length).to eq(0)
+            # post warmup ip
+            ips = @client.get_ips
+            expect(ips.length).to be > 0
+            warmup_ip = @client.post_warmup_ip(ips[0].ip)
+            expect(warmup_ip.ip).to eq(ips[0].ip)
+            warmup_ip = @client.get_warmup_ip(warmup_ip.ip)
+            expect(warmup_ip.ip).to eq(ips[0].ip)
+            # delete the warmup ip
+            @client.delete_warmup_ip(warmup_ip.ip)
+            expect do
+              @client.get_warmup_ip(warmup_ip.ip)
+            end.to raise_error(RestClient::ResourceNotFound)
+          rescue => ex
+            puts ex.inspect
+            raise ex
+          end
+        end
+      end
+
+      context 'with block call' do
+        it 'warmup_ip spec' do
+          # get warmup ips
+          @client.get_warmup_ips do |resp, req, res|
+            resp =
+              SendGrid4r::REST::Ips::Warmup.create_warmup_ips(
+                JSON.parse(resp)
+              )
+            expect(resp).to be_a(Array)
+            expect(req).to be_a(RestClient::Request)
+            expect(res).to be_a(Net::HTTPOK)
+          end
+          # post warmup ip
+          warmup_ip = nil
+          ips = @client.get_ips
+          expect(ips.length).to be > 0
+          @client.post_warmup_ip(ips[0].ip) do |resp, req, res|
+            resp =
+              SendGrid4r::REST::Ips::Warmup.create_warmup_ip(
+                JSON.parse(resp)
+              )
+            warmup_ip = resp
+            expect(resp).to be_a(SendGrid4r::REST::Ips::Warmup::WarmupIp)
+            expect(req).to be_a(RestClient::Request)
+            expect(res).to be_a(Net::HTTPCreated)
+          end
+          # get warmup ip
+          @client.get_warmup_ip(warmup_ip.ip) do |resp, req, res|
+            resp =
+              SendGrid4r::REST::Ips::Warmup.create_warmup_ip(
+                JSON.parse(resp)
+              )
+            expect(resp).to be_a(SendGrid4r::REST::Ips::Warmup::WarmupIp)
+            expect(req).to be_a(RestClient::Request)
+            expect(res).to be_a(Net::HTTPOK)
+          end
+          # delete the warmup ip
+          @client.delete_warmup_ip(warmup_ip.ip) do |resp, req, res|
+            expect(resp).to eq('')
+            expect(req).to be_a(RestClient::Request)
+            expect(res).to be_a(Net::HTTPNoContent)
+          end
         end
-        warmup_ip = client.get_warmup_ip(warmup_ip.ip)
-        expect(warmup_ip.ip).to eq(ips[0].ip)
-        # delete the warmup ip
-        client.delete_warmup_ip(warmup_ip.ip)
-        expect do
-          client.get_warmup_ip(warmup_ip.ip)
-        end.to raise_error(RestClient::ResourceNotFound)
-      rescue => ex
-        puts ex.inspect
-        raise ex
       end
     end
   end
 
-  context 'abnormal' do
-    it 'raise forbidden for free account' do
-      client = SendGrid4r::Client.new(
-        ENV['SENDGRID_USERNAME'], ENV['SENDGRID_PASSWORD'])
-      expect { client.get_warmup_ips }.to raise_error(RestClient::Forbidden)
+  describe 'unit test' do
+    it 'creates warmup_ip instance' do
+      json =
+        '['\
+          '{'\
+            '"ip": "0.0.0.0",'\
+            '"start_date": 1409616000'\
+          '}'\
+        ']'
+      hash = JSON.parse(json)
+      actual = SendGrid4r::REST::Ips::Warmup.create_warmup_ips(hash)
+      expect(actual).to be_a(Array)
+      actual.each do |warmup_ip|
+        expect(warmup_ip).to be_a(SendGrid4r::REST::Ips::Warmup::WarmupIp)
+        expect(warmup_ip.ip).to eq('0.0.0.0')
+        expect(warmup_ip.start_date).to eq(Time.at(1409616000))
+      end
     end
   end
 end