sendgrid4r 1.8.1 → 1.10.0

data/spec/rest/ips/addresses_spec.rb

@@ -1,35 +1,30 @@
 # encoding: utf-8
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe SendGrid4r::REST::Ips::Addresses do
-  describe 'integration test', :it do
-    before do
-      Dotenv.load
-      @client = SendGrid4r::Client.new(api_key: ENV['API_KEY'])
-    end
+module SendGrid4r::REST::Ips
+  describe Addresses do
+    describe 'integration test', :it do
+      before do
+        Dotenv.load
+        @client = SendGrid4r::Client.new(api_key: ENV['SILVER_API_KEY'])
+      end
 
-    context 'account is free' do
-      describe '#get_ip' do
-        it 'raise error' do
-          begin
+      context 'account is free' do
+        describe '#get_ip' do
+          it 'raise error' do
             expect do
               @client.get_ip(ip: '10.10.10.10').to raise_error(
                 RestClient::Forbidden
               )
             end
-          rescue RestClient::ExceptionWithResponse => e
-            puts e.inspect
-            raise e
           end
         end
       end
-    end
 
-    context 'account is silver' do
-      TEST_POOL = 'test_pool'
+      context 'account is silver' do
+        TEST_POOL = 'test_pool'
 
-      before do
-        begin
+        before do
           @client = SendGrid4r::Client.new(api_key: ENV['SILVER_API_KEY'])
           # refresh the pool
           pools = @client.get_pools
@@ -37,53 +32,33 @@ describe SendGrid4r::REST::Ips::Addresses do
             @client.delete_pool(name: TEST_POOL) if pool.name == TEST_POOL
           end
           @client.post_pool(name: TEST_POOL)
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
         end
-      end
 
-      context 'without block call' do
-        it '#get_ips' do
-          begin
+        context 'without block call' do
+          it '#get_ips' do
             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).to be_a(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 RestClient::ExceptionWithResponse => e
-            puts e.inspect
-            raise e
           end
-        end
 
-        it '#get_ips_assigned' do
-          begin
+          it '#get_ips_assigned' do
             ips = @client.get_ips_assigned
             expect(ips.length).to be > 0
-            expect(ips[0]).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
-          rescue RestClient::ExceptionWithResponse => e
-            puts e.inspect
-            raise e
+            expect(ips[0]).to be_a(Addresses::Address)
           end
-        end
 
-        it '#get_ip' do
-          begin
+          it '#get_ip' do
             ips = @client.get_ips_assigned
             expect(
               @client.get_ip(ip: ips[0].ip)
-            ).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
-          rescue RestClient::ExceptionWithResponse => e
-            puts e.inspect
-            raise e
+            ).to be_a(Addresses::Address)
           end
-        end
 
-        it '#post_ip_to_pool' do
-          begin
+          it '#post_ip_to_pool' do
             ips = @client.get_ips_assigned
             actual = @client.post_ip_to_pool(
               pool_name: TEST_POOL, ip: ips[0].ip
@@ -92,98 +67,95 @@ describe SendGrid4r::REST::Ips::Addresses do
             expect(actual.pools).to include(TEST_POOL)
             expect(actual.pools).to be_a(Array)
             @client.delete_ip_from_pool(pool_name: TEST_POOL, ip: ips[0].ip)
-          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(:address) do
-        JSON.parse(
-          '{'\
-            '"ip": "000.00.00.0",'\
-            '"pools": ['\
-              '"test1"'\
-            '],'\
-            '"start_date": 1409616000,'\
-            '"warmup": true'\
-          '}'
-        )
-      end
+      describe 'unit test', :ut do
+        let(:client) do
+          SendGrid4r::Client.new(api_key: '')
+        end
 
-      let(:addresses) do
-        JSON.parse(
-          '['\
+        let(:address) do
+          JSON.parse(
             '{'\
-              '"ip":"000.00.00.0",'\
-              '"pools":["new_test5"],'\
-              '"warmup":true,'\
-              '"start_date":1409616000,'\
-              '"subusers": ["username1", "username2"],'\
-              '"rdns": "01.email.test.com",'\
-              '"pools": ["pool1", "pool2"]'\
-            '}'\
-          ']'
-        )
-      end
+              '"ip": "000.00.00.0",'\
+              '"pools": ['\
+                '"test1"'\
+              '],'\
+              '"start_date": 1409616000,'\
+              '"warmup": true'\
+            '}'
+          )
+        end
 
-      it '#get_ips' do
-        allow(client).to receive(:execute).and_return(addresses)
-        actual = client.get_ips
-        expect(actual).to be_a(Array)
-        actual.each do |address|
-          expect(address).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
+        let(:addresses) do
+          JSON.parse(
+            '['\
+              '{'\
+                '"ip":"000.00.00.0",'\
+                '"pools":["new_test5"],'\
+                '"warmup":true,'\
+                '"start_date":1409616000,'\
+                '"subusers": ["username1", "username2"],'\
+                '"rdns": "01.email.test.com",'\
+                '"pools": ["pool1", "pool2"]'\
+              '}'\
+            ']'
+          )
         end
-      end
 
-      it '#get_ips_assigned' do
-        allow(client).to receive(:execute).and_return(addresses)
-        actual = client.get_ips_assigned
-        expect(actual).to be_a(Array)
-        actual.each do |address|
-          expect(address).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
+        it '#get_ips' do
+          allow(client).to receive(:execute).and_return(addresses)
+          actual = client.get_ips
+          expect(actual).to be_a(Array)
+          actual.each do |address|
+            expect(address).to be_a(Addresses::Address)
+          end
         end
-      end
 
-      it '#get_ip' do
-        allow(client).to receive(:execute).and_return(address)
-        actual = client.get_ip(ip: '')
-        expect(actual).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
-      end
+        it '#get_ips_assigned' do
+          allow(client).to receive(:execute).and_return(addresses)
+          actual = client.get_ips_assigned
+          expect(actual).to be_a(Array)
+          actual.each do |address|
+            expect(address).to be_a(Addresses::Address)
+          end
+        end
 
-      it '#post_ip_to_pool' do
-        allow(client).to receive(:execute).and_return(address)
-        actual = client.post_ip_to_pool(pool_name: '', ip: '')
-        expect(actual).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
-      end
+        it '#get_ip' do
+          allow(client).to receive(:execute).and_return(address)
+          actual = client.get_ip(ip: '')
+          expect(actual).to be_a(Addresses::Address)
+        end
 
-      it 'creates addresses instance' do
-        actual = SendGrid4r::REST::Ips::Addresses.create_addresses(addresses)
-        expect(actual).to be_a(Array)
-        actual.each do |address|
-          expect(
-            address
-          ).to be_a(SendGrid4r::REST::Ips::Addresses::Address)
+        it '#post_ip_to_pool' do
+          allow(client).to receive(:execute).and_return(address)
+          actual = client.post_ip_to_pool(pool_name: '', ip: '')
+          expect(actual).to be_a(Addresses::Address)
         end
-      end
 
-      it 'creates address instance' do
-        actual = SendGrid4r::REST::Ips::Addresses.create_address(address)
-        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')
+        it 'creates addresses instance' do
+          actual = Addresses.create_addresses(addresses)
+          expect(actual).to be_a(Array)
+          actual.each do |address|
+            expect(
+              address
+            ).to be_a(Addresses::Address)
+          end
+        end
+
+        it 'creates address instance' do
+          actual = Addresses.create_address(address)
+          expect(actual).to be_a(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
-        expect(actual.start_date).to eq(Time.at(1409616000))
-        expect(actual.warmup).to eq(true)
       end
     end
   end

data/spec/rest/ips/pools_spec.rb

@@ -1,10 +1,10 @@
 # encoding: utf-8
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe SendGrid4r::REST::Ips::Pools do
-  describe 'integration test', :it do
-    before do
-      begin
+module SendGrid4r::REST::Ips
+  describe Pools do
+    describe 'integration test', :it do
+      before do
         Dotenv.load
         @client = SendGrid4r::Client.new(api_key: ENV['SILVER_API_KEY'])
         @pool_name1 = 'pool_test1'
@@ -20,155 +20,127 @@ describe SendGrid4r::REST::Ips::Pools do
         end
         # post a pool
         @client.post_pool(name: @pool_name1)
-      rescue RestClient::ExceptionWithResponse => e
-        puts e.inspect
-        raise e
       end
-    end
 
-    context 'account is silver' do
-      context 'without block call' do
-        it '#post_pool' do
-          begin
+      context 'account is silver' do
+        context 'without block call' do
+          it '#post_pool' do
             new_pool = @client.post_pool(name: @pool_name2)
             expect(new_pool.name).to eq(@pool_name2)
-          rescue RestClient::ExceptionWithResponse => e
-            puts e.inspect
-            raise e
           end
-        end
 
-        it '#get_pools' do
-          begin
+          it '#get_pools' do
             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).to be_a(Pools::Pool)
               expect(pool.name).to be_a(String)
             end
-          rescue RestClient::ExceptionWithResponse => e
-            puts e.inspect
-            raise e
           end
-        end
 
-        it '#get_pool' do
-          begin
+          it '#get_pool' do
             pool = @client.get_pool(name: @pool_name1)
-            expect(pool).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
+            expect(pool).to be_a(Pools::Pool)
             expect(pool.pool_name).to eq(@pool_name1)
             expect(pool.ips).to be_a(Array)
-          rescue RestClient::ExceptionWithResponse => e
-            puts e.inspect
-            raise e
           end
-        end
 
-        it '#put_pool' do
-          begin
+          it '#put_pool' do
             edit_pool = @client.put_pool(
               name: @pool_name1, new_name: @pool_edit1
             )
             expect(edit_pool.name).to eq(@pool_edit1)
-          rescue RestClient::ExceptionWithResponse => e
-            puts e.inspect
-            raise e
           end
-        end
 
-        it '#delete_pool' do
-          begin
+          it '#delete_pool' do
             @client.delete_pool(name: @pool_name1)
-          rescue RestClient::ExceptionWithResponse => e
-            puts e.inspect
-            raise e
           end
         end
       end
     end
-  end
-
-  describe 'unit test', :ut do
-    let(:client) do
-      SendGrid4r::Client.new(api_key: '')
-    end
 
-    let(:pool) do
-      JSON.parse(
-        '{'\
-          '"ips":["167.89.21.3"],'\
-          '"name":"new_test5"'\
-        '}'
-      )
-    end
+    describe 'unit test', :ut do
+      let(:client) do
+        SendGrid4r::Client.new(api_key: '')
+      end
 
-    let(:pools) do
-      JSON.parse(
-        '['\
-          '{'\
-            '"name": "test1"'\
-          '},'\
-          '{'\
-            '"name": "test2"'\
-          '},'\
+      let(:pool) do
+        JSON.parse(
           '{'\
-            '"name": "test3"'\
-          '},'\
-          '{'\
-            '"name": "new_test3"'\
-          '}'\
-        ']'
-      )
-    end
+            '"ips":["167.89.21.3"],'\
+            '"name":"new_test5"'\
+          '}'
+        )
+      end
 
-    it '#post_pool' do
-      allow(client).to receive(:execute).and_return(pool)
-      actual = client.post_pool(name: '')
-      expect(actual).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
-    end
+      let(:pools) do
+        JSON.parse(
+          '['\
+            '{'\
+              '"name": "test1"'\
+            '},'\
+            '{'\
+              '"name": "test2"'\
+            '},'\
+            '{'\
+              '"name": "test3"'\
+            '},'\
+            '{'\
+              '"name": "new_test3"'\
+            '}'\
+          ']'
+        )
+      end
 
-    it '#get_pools' do
-      allow(client).to receive(:execute).and_return(pools)
-      actual = client.get_pools
-      expect(actual).to be_a(Array)
-      actual.each do |pool|
-        expect(pool).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
+      it '#post_pool' do
+        allow(client).to receive(:execute).and_return(pool)
+        actual = client.post_pool(name: '')
+        expect(actual).to be_a(Pools::Pool)
       end
-    end
 
-    it '#get_pool' do
-      allow(client).to receive(:execute).and_return(pool)
-      actual = client.get_pool(name: '')
-      expect(actual).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
-    end
+      it '#get_pools' do
+        allow(client).to receive(:execute).and_return(pools)
+        actual = client.get_pools
+        expect(actual).to be_a(Array)
+        actual.each do |pool|
+          expect(pool).to be_a(Pools::Pool)
+        end
+      end
 
-    it '#put_pool' do
-      allow(client).to receive(:execute).and_return(pool)
-      actual = client.put_pool(name: '', new_name: '')
-      expect(actual).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
-    end
+      it '#get_pool' do
+        allow(client).to receive(:execute).and_return(pool)
+        actual = client.get_pool(name: '')
+        expect(actual).to be_a(Pools::Pool)
+      end
 
-    it '#delete_pool' do
-      allow(client).to receive(:execute).and_return('')
-      actual = client.delete_pool(name: '')
-      expect(actual).to eq('')
-    end
+      it '#put_pool' do
+        allow(client).to receive(:execute).and_return(pool)
+        actual = client.put_pool(name: '', new_name: '')
+        expect(actual).to be_a(Pools::Pool)
+      end
 
-    it 'creates pool instance with ips' do
-      actual = SendGrid4r::REST::Ips::Pools.create_pool(pool)
-      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')
+      it '#delete_pool' do
+        allow(client).to receive(:execute).and_return('')
+        actual = client.delete_pool(name: '')
+        expect(actual).to eq('')
       end
-      expect(actual.name).to eq('new_test5')
-    end
 
-    it 'creates pools instances' do
-      actual = SendGrid4r::REST::Ips::Pools.create_pools(pools)
-      expect(actual).to be_a(Array)
-      actual.each do |pool|
-        expect(pool).to be_a(SendGrid4r::REST::Ips::Pools::Pool)
+      it 'creates pool instance with ips' do
+        actual = Pools.create_pool(pool)
+        expect(actual).to be_a(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
+
+      it 'creates pools instances' do
+        actual = Pools.create_pools(pools)
+        expect(actual).to be_a(Array)
+        actual.each do |pool|
+          expect(pool).to be_a(Pools::Pool)
+        end
       end
     end
   end