sendgrid4r 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0db3013d7c882c2bcb1c3fac0f255e67f6643003
-  data.tar.gz: e93b5ac5f804506349d97fe9a5eb302da2ca1248
+  metadata.gz: 9f0dc04ae5fecf0e518c08377aa8e12b3073eaa9
+  data.tar.gz: 522e99261f8f6f33632f5fe92864f2118631b8af
 SHA512:
-  metadata.gz: 4107cc159f95eea46b62c203719e35cbb75529622a02a337fe79ac01c292bbb3ddfe12eacd2e3706bbc2c305377defa28af503489e4af7ff49a4a633537aedcd
-  data.tar.gz: 74821591aa3c7c5a5d38b1364f3730ad1d148c865f5bb762e236914089aa04cbecbba015dfe47ab344ce7c84191d3c2c80d55afdeaa71a81de3636d6516eec87
+  metadata.gz: 28a8693931daa73ec378ee71da02bedb7b125db5fa6d200822de0e4b3a889ea913f02264fd2024ea4088e10297df90ad24765e735176997efcb53d2d74a23f05
+  data.tar.gz: ed1ca6766cb1af59c82b020d79513fa24b8a460012e313d02bf0a077c1a6c582943cc416836e54e89c81575209776085b646f66ebd5431dbc0e44547ac37c945

data/README.md

@@ -171,7 +171,7 @@ puts ip.pool_name     # => "new_test5"
 ##### DELETE
 Remove an IP address from a pool.
 ```Ruby
-client.delete_ip_from_pool("xxx.xxx.xxx.xxx")
+client.delete_ip_from_pool("pool_name", "xxx.xxx.xxx.xxx")
 ```
 
 #### IP Pools

data/lib/sendgrid4r/rest/addresses.rb

@@ -30,10 +30,8 @@ module SendGrid4r
           Address.create(post(@auth, "#{SendGrid4r::Client::BASE_URL}/ips/pools/#{pool_name}/ips", params))
         end
 
-        def delete_ip_from_pool(ip)
-          params = Hash.new
-          params["ip"] = ip
-          delete(@auth,"#{SendGrid4r::Client::BASE_URL}/ips/pools/#{pool_name}/ips", params)
+        def delete_ip_from_pool(pool_name, ip)
+          delete(@auth,"#{SendGrid4r::Client::BASE_URL}/ips/pools/#{pool_name}/ips/#{ip}")
         end
 
       end
@@ -49,7 +47,7 @@ module SendGrid4r
           value["pools"].each{|pool|
             ver = Pool.create(pool)
             obj.pools.push(ver)
-          }
+          } if value["pools"] != nil
           obj.warmup = value["warmup"]
           obj.start_date = value["start_date"]
           obj.pool_name = value["pool_name"]

data/lib/sendgrid4r/rest/enforced_tls.rb

@@ -41,7 +41,6 @@ module SendGrid4r
         end
 
       end
-
     end
   end
 end

data/lib/sendgrid4r/rest/groups.rb

@@ -62,9 +62,7 @@ module SendGrid4r
           }
           hash
         end
-
       end
-
     end
   end
 end

data/lib/sendgrid4r/version.rb

@@ -1,3 +1,3 @@
 module SendGrid4r
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/addresses_spec.rb

@@ -7,41 +7,74 @@ describe "SendGrid4r::REST::Ips::Addresses" do
     Dotenv.load
   end
 
-  context "free account" do
-    it "raise error for get_ips" do
-
-      begin
-        client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
-        # get the ips
-        expect{client.get_ips}.to raise_error(RestClient::Forbidden)
-        # get the ip
-        expect{client.get_ip("10.10.10.10").to raise_error(RestClient::Forbidden)}
-      rescue => ex
-        puts ex.inspect
-        raise ex
-      end
+  context "if account is free" do
+    before :all do
+      @client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
+    end
 
+    describe "#get_ips" do
+      it "raise error" do
+        expect{@client.get_ips}.to raise_error(RestClient::Forbidden)
+      end
     end
 
+    describe "#get_ip" do
+      it "raise error" do
+        expect{@client.get_ip("10.10.10.10").to raise_error(RestClient::Forbidden)}
+      end
+    end
   end
 
-  context "silver account" do
-    it "returns Array of Address instance" do
+  context "if account is silver" do
+    TEST_POOL = "test_pool"
+    before :all do
+      @client = SendGrid4r::Client.new(ENV["SILVER_SENDGRID_USERNAME"], ENV["SILVER_SENDGRID_PASSWORD"])
+      # refresh the pool
+      pools = @client.get_pools
+      pools.each {|pool|
+        @client.delete_pool(TEST_POOL) if pool == TEST_POOL
+      }
+      @client.post_pool(TEST_POOL)
+      #ips = @client.get_ips
+      #@client.delete_ip_from_pool(TEST_POOL, ips[0].ip)
+    end
 
-      begin
-        client = SendGrid4r::Client.new(ENV["SILVER_SENDGRID_USERNAME"], ENV["SILVER_SENDGRID_PASSWORD"])
-        # get the ips
-        ips = client.get_ips
-        expect(ips.length).to be(1)
+    describe "#get_ips" do
+      it "returns Array of Address instance" do
+        ips = @client.get_ips
+        expect(ips.length > 0).to be(true)
         expect(ips[0].class).to be(SendGrid4r::REST::Ips::Address)
-        expect(client.get_ip(ips[0].ip).class).to be(SendGrid4r::REST::Ips::Address)
-      rescue => ex
-        puts ex.inspect
-        raise ex
       end
+    end
 
+    describe "#get_ip" do
+      it "returns Address instance" do
+        ips = @client.get_ips
+        expect(@client.get_ip(ips[0].ip).class).to be(SendGrid4r::REST::Ips::Address)
+      end
     end
 
-  end
+    describe "#post_ip_to_pool" do
+      it "add ip to pool successfully" do
+        ips = @client.get_ips
+        actual = @client.post_ip_to_pool(TEST_POOL, ips[0].ip)
+        expect(actual.ip).to eq(ips[0].ip)
+        expect(actual.pool_name).to eq(TEST_POOL)
+      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/client_spec.rb

@@ -7,80 +7,78 @@ describe "SendGrid4r::Client" do
     Dotenv.load
   end
 
-  describe "initialize" do
-    it "create instance" do
-      SendGrid4r::Client.new("username", "password")
-    end
-  end
-
-  describe "available method" do
-    it "is exist method" do
-
-      client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
-
-      # Advanced Suppression Manager
-      # groups
-      expect(client.respond_to?("get_groups")).to eq(true)
-      expect(client.respond_to?("get_group")).to eq(true)
-      expect(client.respond_to?("post_group")).to eq(true)
-      expect(client.respond_to?("patch_group")).to eq(true)
-      expect(client.respond_to?("delete_group")).to eq(true)
-      # suppressions
-      expect(client.respond_to?("post_suppressed_emails")).to eq(true)
-      expect(client.respond_to?("get_suppressions")).to eq(true)
-      expect(client.respond_to?("get_suppressed_emails")).to eq(true)
-      expect(client.respond_to?("delete_suppressed_email")).to eq(true)
-      # global suppressions
-      expect(client.respond_to?("post_global_suppressed_emails")).to eq(true)
-      expect(client.respond_to?("get_global_suppressed_email")).to eq(true)
-      expect(client.respond_to?("delete_global_suppressed_email")).to eq(true)
-
-      # IP Management
-      # ip addresses
-      expect(client.respond_to?("get_ips")).to eq(true)
-      expect(client.respond_to?("get_ip")).to eq(true)
-      expect(client.respond_to?("post_ip_to_pool")).to eq(true)
-      expect(client.respond_to?("delete_ip_from_pool")).to eq(true)
-      # pool
-      expect(client.respond_to?("get_pools")).to eq(true)
-      expect(client.respond_to?("post_pool")).to eq(true)
-      expect(client.respond_to?("get_pool")).to eq(true)
-      expect(client.respond_to?("put_pool")).to eq(true)
-      expect(client.respond_to?("delete_pool")).to eq(true)
-      # warmup
-      expect(client.respond_to?("get_warmup_ips")).to eq(true)
-      expect(client.respond_to?("get_warmup_ip")).to eq(true)
-      expect(client.respond_to?("post_warmup_ip")).to eq(true)
-      expect(client.respond_to?("delete_warmup_ip")).to eq(true)
+  context "always" do
 
-      # Settings
-      # enforced_tls
-      expect(client.respond_to?("get_enforced_tls")).to eq(true)
-      expect(client.respond_to?("patch_enforced_tls")).to eq(true)
-
-      # Template Engine
-      # templates
-      expect(client.respond_to?("get_templates")).to eq(true)
-      expect(client.respond_to?("get_template")).to eq(true)
-      expect(client.respond_to?("post_template")).to eq(true)
-      expect(client.respond_to?("patch_template")).to eq(true)
-      expect(client.respond_to?("delete_template")).to eq(true)
-      # versions
-      expect(client.respond_to?("get_version")).to eq(true)
-      expect(client.respond_to?("post_version")).to eq(true)
-      expect(client.respond_to?("activate_version")).to eq(true)
-      expect(client.respond_to?("patch_version")).to eq(true)
-      expect(client.respond_to?("delete_version")).to eq(true)
+    before :all do
+      @client = SendGrid4r::Client.new("username", "password")
+    end
 
+    describe "#initialize" do
+      it "create instance" do
+        expect(@client.class).to eq(SendGrid4r::Client)
+      end
     end
-  end
 
-  describe "Version" do
+    describe "methods" do
+      it "available" do
+        # Advanced Suppression Manager
+        # groups
+        expect(@client.respond_to?("get_groups")).to eq(true)
+        expect(@client.respond_to?("get_group")).to eq(true)
+        expect(@client.respond_to?("post_group")).to eq(true)
+        expect(@client.respond_to?("patch_group")).to eq(true)
+        expect(@client.respond_to?("delete_group")).to eq(true)
+        # suppressions
+        expect(@client.respond_to?("post_suppressed_emails")).to eq(true)
+        expect(@client.respond_to?("get_suppressions")).to eq(true)
+        expect(@client.respond_to?("get_suppressed_emails")).to eq(true)
+        expect(@client.respond_to?("delete_suppressed_email")).to eq(true)
+        # global suppressions
+        expect(@client.respond_to?("post_global_suppressed_emails")).to eq(true)
+        expect(@client.respond_to?("get_global_suppressed_email")).to eq(true)
+        expect(@client.respond_to?("delete_global_suppressed_email")).to eq(true)
+        # IP Management
+        # ip addresses
+        expect(@client.respond_to?("get_ips")).to eq(true)
+        expect(@client.respond_to?("get_ip")).to eq(true)
+        expect(@client.respond_to?("post_ip_to_pool")).to eq(true)
+        expect(@client.respond_to?("delete_ip_from_pool")).to eq(true)
+        # pool
+        expect(@client.respond_to?("get_pools")).to eq(true)
+        expect(@client.respond_to?("post_pool")).to eq(true)
+        expect(@client.respond_to?("get_pool")).to eq(true)
+        expect(@client.respond_to?("put_pool")).to eq(true)
+        expect(@client.respond_to?("delete_pool")).to eq(true)
+        # warmup
+        expect(@client.respond_to?("get_warmup_ips")).to eq(true)
+        expect(@client.respond_to?("get_warmup_ip")).to eq(true)
+        expect(@client.respond_to?("post_warmup_ip")).to eq(true)
+        expect(@client.respond_to?("delete_warmup_ip")).to eq(true)
+        # Settings
+        # enforced_tls
+        expect(@client.respond_to?("get_enforced_tls")).to eq(true)
+        expect(@client.respond_to?("patch_enforced_tls")).to eq(true)
+        # Template Engine
+        # templates
+        expect(@client.respond_to?("get_templates")).to eq(true)
+        expect(@client.respond_to?("get_template")).to eq(true)
+        expect(@client.respond_to?("post_template")).to eq(true)
+        expect(@client.respond_to?("patch_template")).to eq(true)
+        expect(@client.respond_to?("delete_template")).to eq(true)
+        # versions
+        expect(@client.respond_to?("get_version")).to eq(true)
+        expect(@client.respond_to?("post_version")).to eq(true)
+        expect(@client.respond_to?("activate_version")).to eq(true)
+        expect(@client.respond_to?("patch_version")).to eq(true)
+        expect(@client.respond_to?("delete_version")).to eq(true)
+      end
+    end
 
-    it "Validate version" do
-      expect(SendGrid4r::VERSION).to eq("0.0.4")
+    describe "VERSION" do
+      it "returns VERSION value" do
+        expect(SendGrid4r::VERSION).to eq("0.0.5")
+      end
     end
 
   end
-
 end

data/spec/enforced_tls_spec.rb

@@ -5,34 +5,29 @@ describe "SendGrid4r::REST::Settings::EnforcedTls" do
 
   before :all do
     Dotenv.load
+    @client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
   end
 
-  context "normal" do
-    it "is normal" do
+  context "always" do
 
-      begin
-        client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
+    describe "#get_enforced_tls" do
+      it "returns EnforcedTls instance" do
+        actual = @client.get_enforced_tls
+        expect(actual.class).to be(SendGrid4r::REST::Settings::EnforcedTls::EnforcedTls)
+      end
+    end
+
+    describe "#patch_enforced_tls" do
+      it "update EnforcedTls values" do
         # get original enforced_tls settings
-        original = client.get_enforced_tls
-        # patch a value
-        edit_params = original.dup
-        edit_params.require_tls = true
-        actual_params = client.patch_enforced_tls(edit_params)
-        expect(actual_params.require_tls).to eq(edit_params.require_tls)
+        actual = @client.get_enforced_tls
         # patch both value
-        edit_params.require_tls = false
-        edit_params.require_valid_cert = false
-        actual_params = client.patch_enforced_tls(edit_params)
-        expect(actual_params.require_tls).to eq(edit_params.require_tls)
-        expect(actual_params.require_valid_cert).to eq(edit_params.require_valid_cert)
-        # revert
-        client.patch_enforced_tls(original)
-      rescue => ex
-        puts ex.inspect
-        raise ex
+        actual.require_tls = false
+        actual.require_valid_cert = false
+        edit = @client.patch_enforced_tls(actual)
+        expect(actual.require_tls).to eq(edit.require_tls)
+        expect(actual.require_valid_cert).to eq(edit.require_valid_cert)
       end
-
     end
   end
-
 end

data/spec/global_suppressions_spec.rb

@@ -5,45 +5,40 @@ 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
 
-  context "normal" do
+  context "always" do
     it "is normal" do
-
-      begin
-        client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
-        # celan up test env
-        client.delete_global_suppressed_email(@email1)
-        client.delete_global_suppressed_email(@email2)
-        client.delete_global_suppressed_email(@email3)
-        # post recipient emails to the global suppression group
-        suppressed_emails = client.post_global_suppressed_emails([@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 recipient emails
-        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 the 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("")
-      rescue => ex
-        puts ex.inspect
-        raise ex
-      end
-
+      # 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("")
     end
   end
-
 end

data/spec/groups_spec.rb

@@ -5,59 +5,50 @@ 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
 
-  context "normal" do
+  context "always" do
     it "is normal" do
-
-      begin
-        client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
-        # celan up test env
-        grps = client.get_groups
-        expect(grps.length >= 0).to eq(true)
-        grps.each{|grp|
-          if grp.name == @group_name || grp.name == @group_edit then
-            client.delete_group(grp.id)
-          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)
-        # pach 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{client.get_group(edit_group.id)}.to raise_error(RestClient::ResourceNotFound)
-      rescue => ex
-        puts ex.inspect
-        raise ex
-      end
-
+      # celan up test env
+      grps = @client.get_groups
+      expect(grps.length >= 0).to eq(true)
+      grps.each{|grp|
+        if grp.name == @group_name || grp.name == @group_edit then
+          @client.delete_group(grp.id)
+        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{@client.get_group(edit_group.id)}.to raise_error(RestClient::ResourceNotFound)
     end
   end
 
   context "abnormal" do
     it "raise resource not found for none existance id" do
-      client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
-      expect{client.get_group("notexistid")}.to raise_error(RestClient::ResourceNotFound)
+      expect{@client.get_group("notexistid")}.to raise_error(RestClient::ResourceNotFound)
     end
   end
-
 end

data/spec/pools_spec.rb

@@ -5,13 +5,13 @@ 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
 
-  context "free account" do
+  context "if account is free" do
     it "raise error" do
-
       begin
         #client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
         # get ip pools
@@ -28,48 +28,35 @@ describe "SendGrid4r::REST::Ips::Pools" do
         puts ex.inspect
         raise ex
       end
-
     end
-
   end
 
-  context "silver account" do
+  context "if account is silver" do
     it "is normal" do
-
-      begin
-        client = SendGrid4r::Client.new(ENV["SILVER_SENDGRID_USERNAME"], ENV["SILVER_SENDGRID_PASSWORD"])
-        # clean up test env
-        pools = client.get_pools
-        expect(pools.length >= 0).to eq(true)
-        pools.each{|pool|
-          if pool == @pool_name || pool == @pool_edit then
-            client.delete_pool(pool)
-          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::Pool).to be(pool.class)
-        # delete the pool
-        client.delete_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::Address)
-        expect(client.get_ip(ips[0].ip).class).to be(SendGrid4r::REST::Ips::Address)
-
-      rescue => ex
-        puts ex.inspect
-        raise ex
-      end
-
+      # clean up test env
+      pools = @client.get_pools
+      expect(pools.length >= 0).to eq(true)
+      pools.each{|pool|
+        if pool == @pool_name || pool == @pool_edit then
+          @client.delete_pool(pool)
+        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::Pool).to be(pool.class)
+      # delete the pool
+      @client.delete_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::Address)
+      expect(@client.get_ip(ips[0].ip).class).to be(SendGrid4r::REST::Ips::Address)
     end
-
   end
-
 end

data/spec/suppressions_spec.rb

@@ -5,71 +5,55 @@ describe "SendGrid4r::REST::Asm::Groups::Suppressions" do
 
   before :all do
     Dotenv.load
-    @group_name = "suppressions_test"
+    @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
 
-  context "normal" do
+  context "always" do
     it "is normal" do
-
-      begin
-        client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
-        # celan up test env
-        grps = client.get_groups
-        expect(grps.length >= 0).to eq(true)
-        grps.each{|grp|
-          if grp.name == @group_name then
-            emails = client.get_suppressed_emails(grp.id)
-            emails.each{|email|
-              client.delete_suppressed_email(grp.id, email)
-            }
-            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).to eq(1)
-        expect(suppressions[0].name).to eq(@group_name)
-        expect(suppressions[0].description).to eq(@group_desc)
-        expect(suppressions[0].suppressed).to eq(true)
-        # 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{client.get_group(new_group.id)}.to raise_error(RestClient::ResourceNotFound)
-      rescue => ex
-        puts ex.inspect
-        raise ex
-      end
-
+      # celan up test env
+      grps = @client.get_groups
+      expect(grps.length >= 0).to eq(true)
+      grps.each{|grp|
+        if grp.name == @group_name then
+          emails = @client.get_suppressed_emails(grp.id)
+          emails.each{|email|
+            @client.delete_suppressed_email(grp.id, email)
+          }
+          @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)
+      expect(suppressions[0].name).to eq(@group_name)
+      expect(suppressions[0].description).to eq(@group_desc)
+      expect(suppressions[0].suppressed).to eq(true)
+      # 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{@client.get_group(new_group.id)}.to raise_error(RestClient::ResourceNotFound)
     end
   end
-
-  context "abnormal" do
-    it "raise resource not found for none existance id" do
-      client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
-      expect{client.post_suppressed_emails("notexistid", [@email1, @email2, @email3])}.to raise_error(RestClient::ResourceNotFound)
-    end
-  end
-
 end

data/spec/templates_spec.rb

@@ -5,49 +5,34 @@ describe "SendGrid4r::REST::Templates" do
 
   before :all do
     Dotenv.load
+    @client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
     @template_name = "template_test"
     @template_edit = "template_edit"
   end
 
-  context "normal" do
+  context "always" do
     it "is normal" do
-
-      begin
-        client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
-        # celan up test env
-        tmps = client.get_templates
-        expect(tmps.length >= 0).to eq(true)
-        tmps.each{|tmp|
-          if tmp.name == @template_name || tmp.name == @template_edit then
-            client.delete_template(tmp.id)
-          end
-        }
-        # post a template
-        new_template = client.post_template(@template_name)
-        expect(@template_name).to eq(new_template.name)
-        # pach the template
-        client.patch_template(new_template.id, @template_edit)
-        # get the template
-        edit_template = client.get_template(new_template.id)
-        expect(new_template.id).to eq(edit_template.id)
-        expect(@template_edit).to eq(edit_template.name)
-        expect(new_template.versions).to eq(edit_template.versions)
-        # delete the template
-        client.delete_template(edit_template.id)
-        expect{client.get_template(edit_template.id)}.to raise_error(RestClient::ResourceNotFound)
-      rescue => ex
-        puts ex.inspect
-        raise ex
-      end
-
-    end
-  end
-
-  context "abnormal" do
-    it "raise resource not found for none existance id" do
-      client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
-      expect{client.get_template("notexistid")}.to raise_error(RestClient::ResourceNotFound)
+      # celan up test env
+      tmps = @client.get_templates
+      expect(tmps.length >= 0).to eq(true)
+      tmps.each{|tmp|
+        if tmp.name == @template_name || tmp.name == @template_edit then
+          @client.delete_template(tmp.id)
+        end
+      }
+      # post a template
+      new_template = @client.post_template(@template_name)
+      expect(@template_name).to eq(new_template.name)
+      # pach the template
+      @client.patch_template(new_template.id, @template_edit)
+      # get the template
+      edit_template = @client.get_template(new_template.id)
+      expect(new_template.id).to eq(edit_template.id)
+      expect(@template_edit).to eq(edit_template.name)
+      expect(new_template.versions).to eq(edit_template.versions)
+      # delete the template
+      @client.delete_template(edit_template.id)
+      expect{@client.get_template(edit_template.id)}.to raise_error(RestClient::ResourceNotFound)
     end
   end
-
 end

data/spec/version_factory_spec.rb

@@ -5,33 +5,26 @@ describe "SendGrid4r::VersionFactory" do
 
   before :all do
     Dotenv.load
+    @factory = SendGrid4r::VersionFactory.new
   end
 
-  context "normal" do
+  context "always" do
     it "is simple case" do
-
-      factory = SendGrid4r::VersionFactory.new
-      version = factory.create("version_name")
+      version = @factory.create("version_name")
       expect(version.name).to eq("version_name")
       expect(version.subject).to eq("<%subject%>")
       expect(version.html_content).to eq("<%body%>")
       expect(version.plain_content).to eq("<%body%>")
       expect(version.active).to eq(1)
-
     end
 
     it "is full params case" do
-
-      factory = SendGrid4r::VersionFactory.new
-      version = factory.create("version_name", "This is subject <%subject%>", "This is html content <%body%>", "This is plain content <%body%>", 0)
+      version = @factory.create("version_name", "This is subject <%subject%>", "This is html content <%body%>", "This is plain content <%body%>", 0)
       expect(version.name).to eq("version_name")
       expect(version.subject).to eq("This is subject <%subject%>")
       expect(version.html_content).to eq("This is html content <%body%>")
       expect(version.plain_content).to eq("This is plain content <%body%>")
       expect(version.active).to eq(0)
-
     end
-
   end
-
 end

data/spec/versions_spec.rb

@@ -5,86 +5,71 @@ describe "SendGrid4r::REST::Templates::Versions" do
 
   before :all do
     Dotenv.load
-    @template_name = "version_test"
+    @client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
+    @template_edit = "version_test"
     @version1_name = "version1_test"
     @version2_name = "version2_test"
   end
 
-  context "normal" do
-
+  context "always" do
     it "is normal" do
-      begin
-        client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
-        # celan up test env
-        tmps = client.get_templates
-        tmps.each{|tmp|
-          if tmp.name == @template_name then
-            tmp.versions.each{|ver|
-              client.delete_version(tmp.id, ver.id)
-            }
-            client.delete_template(tmp.id)
-          end
-        }
-        # post a template
-        new_template = client.post_template(@template_name)
-        expect(@template_name).to eq(new_template.name)
-        # post a version
-        factory = SendGrid4r::VersionFactory.new
-        ver1 = factory.create(@version1_name)
-        ver1 = client.post_version(new_template.id, ver1)
-        # get the version
-        actual = client.get_version(new_template.id, ver1.id)
-        expect(ver1.template_id).to eq(actual.template_id)
-        expect(ver1.active).to eq(actual.active)
-        expect(ver1.name).to eq(actual.name)
-        expect(ver1.html_content).to eq(actual.html_content)
-        expect(ver1.plain_content).to eq(actual.plain_content)
-        expect(ver1.subject).to eq(actual.subject)
-        # edit the version
-        edit_ver1 = actual.dup
-        edit_ver1.name = "edit_version"
-        edit_ver1.subject = "edit<%subject%>edit"
-        edit_ver1.html_content = "edit<%body%>edit"
-        edit_ver1.plain_content = "edit<%body%>edit"
-        edit_ver1.active = 0
-        client.patch_version(new_template.id, ver1.id, edit_ver1)
-        # get the version
-        actual = client.get_version(new_template.id, ver1.id)
-        expect(new_template.id).to eq(actual.template_id)
-        expect(edit_ver1.active).to eq(actual.active)
-        expect(edit_ver1.name).to eq(actual.name)
-        expect(edit_ver1.html_content).to eq(actual.html_content)
-        expect(edit_ver1.plain_content).to eq(actual.plain_content)
-        expect(edit_ver1.subject).to eq(actual.subject)
-        # post a version 2
-        ver2 = factory.create(@version2_name, "<%subject%>", "<%body%>", "<%body%>")
-        ver2 = client.post_version(new_template.id, ver2)
-        # activate version 2
-        client.activate_version(new_template.id, ver2.id)
-        actual_ver1 = client.get_version(new_template.id, ver1.id)
-        actual_ver2 = client.get_version(new_template.id, ver2.id)
-        expect(0).to eq(actual_ver1.active)
-        expect(1).to eq(actual_ver2.active)
-        # delete the version
-        client.delete_version(new_template.id, actual_ver1.id)
-        client.delete_version(new_template.id, actual_ver2.id)
-        expect{client.get_version(new_template.id, actual_ver1.id)}.to raise_error(RestClient::ResourceNotFound)
-        expect{client.get_version(new_template.id, actual_ver2.id)}.to raise_error(RestClient::ResourceNotFound)
-        # delete the template
-        client.delete_template(new_template.id)
-      rescue => ex
-        puts ex.inspect
-        raise ex
-      end
-    end
-  end
-
-  context "abnormal" do
-
-    it "raise resource not found for none existance id" do
-      client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
-      expect{client.get_version("notexistid", "notexistid")}.to raise_error(RestClient::ResourceNotFound)
+      # celan up test env
+      tmps = @client.get_templates
+      tmps.each{|tmp|
+        if tmp.name == @template_edit then
+          tmp.versions.each{|ver|
+            @client.delete_version(tmp.id, ver.id)
+          }
+          @client.delete_template(tmp.id)
+        end
+      }
+      # post a template
+      new_template = @client.post_template(@template_edit)
+      expect(@template_edit).to eq(new_template.name)
+      # post a version
+      factory = SendGrid4r::VersionFactory.new
+      ver1 = factory.create(@version1_name)
+      ver1 = @client.post_version(new_template.id, ver1)
+      # get the version
+      actual = @client.get_version(new_template.id, ver1.id)
+      expect(ver1.template_id).to eq(actual.template_id)
+      expect(ver1.active).to eq(actual.active)
+      expect(ver1.name).to eq(actual.name)
+      expect(ver1.html_content).to eq(actual.html_content)
+      expect(ver1.plain_content).to eq(actual.plain_content)
+      expect(ver1.subject).to eq(actual.subject)
+      # edit the version
+      edit_ver1 = actual.dup
+      edit_ver1.name = "edit_version"
+      edit_ver1.subject = "edit<%subject%>edit"
+      edit_ver1.html_content = "edit<%body%>edit"
+      edit_ver1.plain_content = "edit<%body%>edit"
+      edit_ver1.active = 0
+      @client.patch_version(new_template.id, ver1.id, edit_ver1)
+      # get the version
+      actual = @client.get_version(new_template.id, ver1.id)
+      expect(new_template.id).to eq(actual.template_id)
+      expect(edit_ver1.active).to eq(actual.active)
+      expect(edit_ver1.name).to eq(actual.name)
+      expect(edit_ver1.html_content).to eq(actual.html_content)
+      expect(edit_ver1.plain_content).to eq(actual.plain_content)
+      expect(edit_ver1.subject).to eq(actual.subject)
+      # post a version 2
+      ver2 = factory.create(@version2_name, "<%subject%>", "<%body%>", "<%body%>")
+      ver2 = @client.post_version(new_template.id, ver2)
+      # activate version 2
+      @client.activate_version(new_template.id, ver2.id)
+      actual_ver1 = @client.get_version(new_template.id, ver1.id)
+      actual_ver2 = @client.get_version(new_template.id, ver2.id)
+      expect(0).to eq(actual_ver1.active)
+      expect(1).to eq(actual_ver2.active)
+      # delete the version
+      @client.delete_version(new_template.id, actual_ver1.id)
+      @client.delete_version(new_template.id, actual_ver2.id)
+      expect{@client.get_version(new_template.id, actual_ver1.id)}.to raise_error(RestClient::ResourceNotFound)
+      expect{@client.get_version(new_template.id, actual_ver2.id)}.to raise_error(RestClient::ResourceNotFound)
+      # delete the template
+      @client.delete_template(new_template.id)
     end
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sendgrid4r
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - awwa500@gmail.com
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-23 00:00:00.000000000 Z
+date: 2014-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client