sendgrid4r 0.0.2

data/lib/sendgrid4r/rest/request.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.dirname(__FILE__)
+
+require "rest-client"
+require "uri"
+require "json"
+
+module SendGrid4r
+  module REST
+    module Request
+
+      def get(auth, endpoint)
+        resource = RestClient::Resource.new(endpoint, auth.get_username, auth.get_password)
+        body = resource.get.body
+        JSON.parse(body)
+      end
+
+      def post(auth, endpoint, params = nil)
+        resource = RestClient::Resource.new(endpoint, auth.get_username, auth.get_password)
+        if params == nil
+          body = resource.post(:content_type => :json).body
+        else
+          body = resource.post(params.to_json, :content_type => :json).body
+        end
+        JSON.parse(body)
+      end
+
+      def patch(auth, endpoint, params)
+        resource = RestClient::Resource.new(endpoint, auth.get_username, auth.get_password)
+        body = resource.patch(params.to_json, :content_type => :json).body
+        JSON.parse(body)
+      end
+
+      def delete(auth, endpoint)
+        resource = RestClient::Resource.new(endpoint, auth.get_username, auth.get_password)
+        resource.delete
+      end
+
+    end
+
+  end
+end

data/lib/sendgrid4r/rest/suppressions.rb

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.dirname(__FILE__)
+
+require "sendgrid4r/rest/request"
+
+module SendGrid4r
+  module REST
+    module Asm
+      module Suppressions
+
+        include SendGrid4r::REST::Request
+
+        def get_suppressions(email_address)
+          response = get(@auth, "#{SendGrid4r::Client::BASE_URL}/asm/suppressions/#{email_address}")
+          suppressions = Array.new
+          response["suppressions"].each{|spr|
+            suppression = Suppression.create(spr)
+            suppressions.push(suppression)
+          } if response["suppressions"] != nil
+          suppressions
+        end
+
+        def get_suppressed_emails(group_id)
+          get(@auth, "#{SendGrid4r::Client::BASE_URL}/asm/groups/#{group_id}/suppressions")
+        end
+
+        def post_suppressed_emails(group_id, recipient_emails)
+          params = Hash.new
+          params["recipient_emails"] = recipient_emails
+          response = post(@auth, "#{SendGrid4r::Client::BASE_URL}/asm/groups/#{group_id}/suppressions", params.to_hash)
+          recipient_emails = response["recipient_emails"]
+          recipient_emails
+        end
+
+        def delete_suppressed_email(group_id, email_address)
+          delete(@auth, "#{SendGrid4r::Client::BASE_URL}/asm/groups/#{group_id}/suppressions/#{email_address}")
+        end
+
+        class Suppression
+
+          attr_accessor :id, :name, :description, :suppressed
+
+          def self.create(value)
+            obj = Suppression.new
+            obj.id = value["id"]
+            obj.name = value["name"]
+            obj.description = value["description"]
+            obj.suppressed = value["suppressed"]
+            obj
+          end
+
+        end
+
+      end
+    end
+
+  end
+end

data/lib/sendgrid4r/rest/templates.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.dirname(__FILE__)
+
+require "sendgrid4r/rest/request"
+
+require "versions"
+
+module SendGrid4r
+  module REST
+    module Templates
+
+      include SendGrid4r::REST::Request
+
+      def get_templates
+        response = get(@auth, "#{SendGrid4r::Client::BASE_URL}/templates")
+        tmps = Array.new
+        response["templates"].each{|template|
+          tmp = Template.create(template)
+          tmps.push(tmp)
+        } if response["templates"] != nil
+        tmps
+      end
+
+      def get_template(template_id)
+        Template.create(get(@auth, "#{SendGrid4r::Client::BASE_URL}/templates/#{template_id}"))
+      end
+
+      def post_template(name)
+        params = Hash.new
+        params["name"] = name
+        Template.create(post(@auth, "#{SendGrid4r::Client::BASE_URL}/templates", params))
+      end
+
+      def patch_template(template_id, name)
+        params = Hash.new
+        params["name"] = name
+        Template.create(patch(@auth, "#{SendGrid4r::Client::BASE_URL}/templates/#{template_id}", params))
+      end
+
+      def delete_template(template_id)
+        delete(@auth, "#{SendGrid4r::Client::BASE_URL}/templates/#{template_id}")
+      end
+
+      class Template
+
+        attr_accessor :id, :name, :versions
+
+        def self.create(value)
+          obj = Template.new
+          obj.id = value["id"]
+          obj.name = value["name"]
+          obj.versions = []
+          value["versions"].each{|version|
+            ver = Version.create(version)
+            obj.versions.push(ver)
+          }
+          obj
+        end
+
+      end
+    end
+
+  end
+end

data/lib/sendgrid4r/rest/versions.rb

@@ -0,0 +1,66 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.dirname(__FILE__)
+
+require "sendgrid4r/rest/request"
+
+module SendGrid4r
+  module REST
+    module Templates
+      module Versions
+
+        include SendGrid4r::REST::Request
+
+        def get_version(template_id, version_id)
+          Version.create(get(@auth, "#{SendGrid4r::Client::BASE_URL}/templates/#{template_id}/versions/#{version_id}"))
+        end
+
+        def post_version(template_id, version)
+          Version.create(post(@auth, "#{SendGrid4r::Client::BASE_URL}/templates/#{template_id}/versions", version.to_hash))
+        end
+
+        def activate_version(template_id, version_id)
+          Version.create(post(@auth, "#{SendGrid4r::Client::BASE_URL}/templates/#{template_id}/versions/#{version_id}/activate"))
+        end
+
+        def patch_version(template_id, version_id, version)
+          Version.create(patch(@auth, "#{SendGrid4r::Client::BASE_URL}/templates/#{template_id}/versions/#{version_id}", version.to_hash))
+        end
+
+        def delete_version(template_id, version_id)
+          delete(@auth, "#{SendGrid4r::Client::BASE_URL}/templates/#{template_id}/versions/#{version_id}")
+        end
+
+      end
+
+      class Version
+
+        attr_accessor :id, :template_id, :active, :name, :html_content, :plain_content, :subject, :updated_at
+
+        def self.create(value)
+          obj = Version.new
+          obj.id = value["id"]
+          obj.template_id = value["template_id"]
+          obj.active = value["active"]
+          obj.name = value["name"]
+          obj.html_content = value["html_content"]
+          obj.plain_content = value["plain_content"]
+          obj.subject = value["subject"]
+          obj.updated_at = value["updated_at"]
+          obj
+        end
+
+        def to_hash
+          hash = {
+            "active" => @active,
+            "name" => @name,
+            "html_content" => @html_content,
+            "plain_content" => @plain_content,
+            "subject" => @subject,
+          }
+          hash
+        end
+
+      end
+    end
+  end
+end

data/lib/sendgrid4r/rest/warmup.rb

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.dirname(__FILE__)
+
+require "sendgrid4r/rest/request"
+
+module SendGrid4r
+  module REST
+    module Ips
+      module Warmup
+
+        include SendGrid4r::REST::Request
+
+        def get_warmup_ips
+          response = get(@auth, "#{SendGrid4r::Client::BASE_URL}/ips/warmup")
+          ips = Array.new
+          response.each{|ip|
+            ip_address = WarmupIp.create(ip)
+            ips.push(ip_address)
+          } if response.length > 0
+          ips
+        end
+
+        def get_warmup_ip(ip_address)
+          WarmupIp.create(get(@auth, "#{SendGrid4r::Client::BASE_URL}/ips/warmup/#{ip_address}"))
+        end
+
+        def post_warmup_ip(ip_address)
+          params = Hash.new
+          params["ip"] = ip_address
+          WarmupIp.create(post(@auth, "#{SendGrid4r::Client::BASE_URL}/ips/warmup", params))
+        end
+
+        def delete_warmup_ip(ip_address)
+          delete(@auth, "#{SendGrid4r::Client::BASE_URL}/ips/warmup/#{ip_address}")
+        end
+
+        class WarmupIp
+
+          attr_accessor :ip, :start_date
+
+          def self.create(value)
+            obj = WarmupIp.new
+            obj.ip = value["ip"]
+            obj.start_date = value["start_date"]
+            obj
+          end
+
+        end
+      end
+    end
+
+  end
+end

data/lib/sendgrid4r/version.rb

@@ -0,0 +1,3 @@
+module SendGrid4r
+  VERSION = "0.0.2"
+end

data/lib/sendgrid4r.rb

@@ -0,0 +1,2 @@
+require "client"
+require "sendgrid4r/version"

data/sendgrid4r.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+src = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(src) unless $LOAD_PATH.include?(src)
+require 'sendgrid4r/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sendgrid4r"
+  spec.version       = SendGrid4r::VERSION
+  spec.authors       = ["awwa500@gmail.com"]
+  spec.email         = ["awwa500@gmail.com"]
+  spec.summary       = "SendGrid Web API v3 module"
+  spec.description   = "SendGrid Web API v3 module"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rest-client"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "dotenv"
+end

data/spec/client_spec.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "SendGrid4r::Client" do
+
+  before :all 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"])
+      # enforced_tls
+      expect(client.respond_to?("get_enforced_tls")).to eq(true)
+      expect(client.respond_to?("patch_enforced_tls")).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)
+      # 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)
+      # ip addresses
+      expect(client.respond_to?("get_ips")).to eq(true)
+      # suppressions
+      expect(client.respond_to?("get_suppressions")).to eq(true)
+      expect(client.respond_to?("get_suppressed_emails")).to eq(true)
+      expect(client.respond_to?("post_suppressed_emails")).to eq(true)
+      expect(client.respond_to?("delete_suppressed_email")).to eq(true)
+      # 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)
+      # 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)
+    end
+  end
+
+  describe "Version" do
+
+    it "Validate version" do
+      expect(SendGrid4r::VERSION).to eq("0.0.2")
+    end
+
+  end
+
+end

data/spec/enforced_tls_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "SendGrid4r::REST::Settings::EnforcedTls" do
+
+  before :all do
+    Dotenv.load
+  end
+
+  context "normal" do
+    it "is normal" do
+
+      begin
+        client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
+        # 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)
+        # 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
+      end
+
+    end
+  end
+
+end

data/spec/global_suppressions_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "SendGrid4r::REST::Asm::GlobalSuppressions" do
+
+  before :all do
+    Dotenv.load
+    @email1 = "test1@test.com"
+    @email2 = "test2@test.com"
+    @email3 = "test3@test.com"
+  end
+
+  context "normal" 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
+
+    end
+  end
+
+end

data/spec/groups_spec.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "SendGrid4r::REST::Asm::Groups" do
+
+  before :all do
+    Dotenv.load
+    @group_name = "group_test"
+    @group_edit = "group_edit"
+    @group_desc = "group_desc"
+    @group_desc_edit = "group_desc_edit"
+  end
+
+  context "normal" 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
+
+    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)
+    end
+  end
+
+end

data/spec/ip_addresses_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "SendGrid4r::REST::Ips::IpAddresses" do
+
+  before :all do
+    Dotenv.load
+  end
+
+  context "normal" do
+    it "is normal" do
+
+      begin
+        client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
+        # get the ips
+        expect{client.get_ips}.to raise_error(RestClient::Forbidden)
+      rescue => ex
+        puts ex.inspect
+        raise ex
+      end
+
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), '../lib', 'sendgrid4r.rb')
+
+require 'rubygems'
+require 'rspec'
+require 'dotenv'

data/spec/suppressions_spec.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "SendGrid4r::REST::Asm::Groups::Suppressions" do
+
+  before :all do
+    Dotenv.load
+    @group_name = "suppressions_test"
+    @email1 = "test1@test.com"
+    @email2 = "test2@test.com"
+    @email3 = "test3@test.com"
+
+    @group_desc = "group_desc"
+  end
+
+  context "normal" 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
+
+    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