sendgrid4r 0.0.4 → 0.0.5

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 0db3013d7c882c2bcb1c3fac0f255e67f6643003
4
- data.tar.gz: e93b5ac5f804506349d97fe9a5eb302da2ca1248
3
+ metadata.gz: 9f0dc04ae5fecf0e518c08377aa8e12b3073eaa9
4
+ data.tar.gz: 522e99261f8f6f33632f5fe92864f2118631b8af
5
5
  SHA512:
6
- metadata.gz: 4107cc159f95eea46b62c203719e35cbb75529622a02a337fe79ac01c292bbb3ddfe12eacd2e3706bbc2c305377defa28af503489e4af7ff49a4a633537aedcd
7
- data.tar.gz: 74821591aa3c7c5a5d38b1364f3730ad1d148c865f5bb762e236914089aa04cbecbba015dfe47ab344ce7c84191d3c2c80d55afdeaa71a81de3636d6516eec87
6
+ metadata.gz: 28a8693931daa73ec378ee71da02bedb7b125db5fa6d200822de0e4b3a889ea913f02264fd2024ea4088e10297df90ad24765e735176997efcb53d2d74a23f05
7
+ data.tar.gz: ed1ca6766cb1af59c82b020d79513fa24b8a460012e313d02bf0a077c1a6c582943cc416836e54e89c81575209776085b646f66ebd5431dbc0e44547ac37c945
data/README.md CHANGED
@@ -171,7 +171,7 @@ puts ip.pool_name # => "new_test5"
171
171
  ##### DELETE
172
172
  Remove an IP address from a pool.
173
173
  ```Ruby
174
- client.delete_ip_from_pool("xxx.xxx.xxx.xxx")
174
+ client.delete_ip_from_pool("pool_name", "xxx.xxx.xxx.xxx")
175
175
  ```
176
176
 
177
177
  #### IP Pools
@@ -30,10 +30,8 @@ module SendGrid4r
30
30
  Address.create(post(@auth, "#{SendGrid4r::Client::BASE_URL}/ips/pools/#{pool_name}/ips", params))
31
31
  end
32
32
 
33
- def delete_ip_from_pool(ip)
34
- params = Hash.new
35
- params["ip"] = ip
36
- delete(@auth,"#{SendGrid4r::Client::BASE_URL}/ips/pools/#{pool_name}/ips", params)
33
+ def delete_ip_from_pool(pool_name, ip)
34
+ delete(@auth,"#{SendGrid4r::Client::BASE_URL}/ips/pools/#{pool_name}/ips/#{ip}")
37
35
  end
38
36
 
39
37
  end
@@ -49,7 +47,7 @@ module SendGrid4r
49
47
  value["pools"].each{|pool|
50
48
  ver = Pool.create(pool)
51
49
  obj.pools.push(ver)
52
- }
50
+ } if value["pools"] != nil
53
51
  obj.warmup = value["warmup"]
54
52
  obj.start_date = value["start_date"]
55
53
  obj.pool_name = value["pool_name"]
@@ -41,7 +41,6 @@ module SendGrid4r
41
41
  end
42
42
 
43
43
  end
44
-
45
44
  end
46
45
  end
47
46
  end
@@ -62,9 +62,7 @@ module SendGrid4r
62
62
  }
63
63
  hash
64
64
  end
65
-
66
65
  end
67
-
68
66
  end
69
67
  end
70
68
  end
@@ -1,3 +1,3 @@
1
1
  module SendGrid4r
2
- VERSION = "0.0.4"
2
+ VERSION = "0.0.5"
3
3
  end
@@ -7,41 +7,74 @@ describe "SendGrid4r::REST::Ips::Addresses" do
7
7
  Dotenv.load
8
8
  end
9
9
 
10
- context "free account" do
11
- it "raise error for get_ips" do
12
-
13
- begin
14
- client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
15
- # get the ips
16
- expect{client.get_ips}.to raise_error(RestClient::Forbidden)
17
- # get the ip
18
- expect{client.get_ip("10.10.10.10").to raise_error(RestClient::Forbidden)}
19
- rescue => ex
20
- puts ex.inspect
21
- raise ex
22
- end
10
+ context "if account is free" do
11
+ before :all do
12
+ @client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
13
+ end
23
14
 
15
+ describe "#get_ips" do
16
+ it "raise error" do
17
+ expect{@client.get_ips}.to raise_error(RestClient::Forbidden)
18
+ end
24
19
  end
25
20
 
21
+ describe "#get_ip" do
22
+ it "raise error" do
23
+ expect{@client.get_ip("10.10.10.10").to raise_error(RestClient::Forbidden)}
24
+ end
25
+ end
26
26
  end
27
27
 
28
- context "silver account" do
29
- it "returns Array of Address instance" do
28
+ context "if account is silver" do
29
+ TEST_POOL = "test_pool"
30
+ before :all do
31
+ @client = SendGrid4r::Client.new(ENV["SILVER_SENDGRID_USERNAME"], ENV["SILVER_SENDGRID_PASSWORD"])
32
+ # refresh the pool
33
+ pools = @client.get_pools
34
+ pools.each {|pool|
35
+ @client.delete_pool(TEST_POOL) if pool == TEST_POOL
36
+ }
37
+ @client.post_pool(TEST_POOL)
38
+ #ips = @client.get_ips
39
+ #@client.delete_ip_from_pool(TEST_POOL, ips[0].ip)
40
+ end
30
41
 
31
- begin
32
- client = SendGrid4r::Client.new(ENV["SILVER_SENDGRID_USERNAME"], ENV["SILVER_SENDGRID_PASSWORD"])
33
- # get the ips
34
- ips = client.get_ips
35
- expect(ips.length).to be(1)
42
+ describe "#get_ips" do
43
+ it "returns Array of Address instance" do
44
+ ips = @client.get_ips
45
+ expect(ips.length > 0).to be(true)
36
46
  expect(ips[0].class).to be(SendGrid4r::REST::Ips::Address)
37
- expect(client.get_ip(ips[0].ip).class).to be(SendGrid4r::REST::Ips::Address)
38
- rescue => ex
39
- puts ex.inspect
40
- raise ex
41
47
  end
48
+ end
42
49
 
50
+ describe "#get_ip" do
51
+ it "returns Address instance" do
52
+ ips = @client.get_ips
53
+ expect(@client.get_ip(ips[0].ip).class).to be(SendGrid4r::REST::Ips::Address)
54
+ end
43
55
  end
44
56
 
45
- end
57
+ describe "#post_ip_to_pool" do
58
+ it "add ip to pool successfully" do
59
+ ips = @client.get_ips
60
+ actual = @client.post_ip_to_pool(TEST_POOL, ips[0].ip)
61
+ expect(actual.ip).to eq(ips[0].ip)
62
+ expect(actual.pool_name).to eq(TEST_POOL)
63
+ end
64
+ end
46
65
 
66
+ # Could not test because POST an IP to a pool takes 60 sec
67
+ # describe "#delete_ip_from_pool" do
68
+ # it "delete ip from pool successfully" do
69
+ # begin
70
+ # ips = @client.get_ips
71
+ # @client.post_ip_to_pool(TEST_POOL, ips[0].ip)
72
+ # @client.delete_ip_from_pool(TEST_POOL, ips[0].ip)
73
+ # rescue => e
74
+ # puts e.inspect
75
+ # raise e
76
+ # end
77
+ # end
78
+ # end
79
+ end
47
80
  end
data/spec/client_spec.rb CHANGED
@@ -7,80 +7,78 @@ describe "SendGrid4r::Client" do
7
7
  Dotenv.load
8
8
  end
9
9
 
10
- describe "initialize" do
11
- it "create instance" do
12
- SendGrid4r::Client.new("username", "password")
13
- end
14
- end
15
-
16
- describe "available method" do
17
- it "is exist method" do
18
-
19
- client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
20
-
21
- # Advanced Suppression Manager
22
- # groups
23
- expect(client.respond_to?("get_groups")).to eq(true)
24
- expect(client.respond_to?("get_group")).to eq(true)
25
- expect(client.respond_to?("post_group")).to eq(true)
26
- expect(client.respond_to?("patch_group")).to eq(true)
27
- expect(client.respond_to?("delete_group")).to eq(true)
28
- # suppressions
29
- expect(client.respond_to?("post_suppressed_emails")).to eq(true)
30
- expect(client.respond_to?("get_suppressions")).to eq(true)
31
- expect(client.respond_to?("get_suppressed_emails")).to eq(true)
32
- expect(client.respond_to?("delete_suppressed_email")).to eq(true)
33
- # global suppressions
34
- expect(client.respond_to?("post_global_suppressed_emails")).to eq(true)
35
- expect(client.respond_to?("get_global_suppressed_email")).to eq(true)
36
- expect(client.respond_to?("delete_global_suppressed_email")).to eq(true)
37
-
38
- # IP Management
39
- # ip addresses
40
- expect(client.respond_to?("get_ips")).to eq(true)
41
- expect(client.respond_to?("get_ip")).to eq(true)
42
- expect(client.respond_to?("post_ip_to_pool")).to eq(true)
43
- expect(client.respond_to?("delete_ip_from_pool")).to eq(true)
44
- # pool
45
- expect(client.respond_to?("get_pools")).to eq(true)
46
- expect(client.respond_to?("post_pool")).to eq(true)
47
- expect(client.respond_to?("get_pool")).to eq(true)
48
- expect(client.respond_to?("put_pool")).to eq(true)
49
- expect(client.respond_to?("delete_pool")).to eq(true)
50
- # warmup
51
- expect(client.respond_to?("get_warmup_ips")).to eq(true)
52
- expect(client.respond_to?("get_warmup_ip")).to eq(true)
53
- expect(client.respond_to?("post_warmup_ip")).to eq(true)
54
- expect(client.respond_to?("delete_warmup_ip")).to eq(true)
10
+ context "always" do
55
11
 
56
- # Settings
57
- # enforced_tls
58
- expect(client.respond_to?("get_enforced_tls")).to eq(true)
59
- expect(client.respond_to?("patch_enforced_tls")).to eq(true)
60
-
61
- # Template Engine
62
- # templates
63
- expect(client.respond_to?("get_templates")).to eq(true)
64
- expect(client.respond_to?("get_template")).to eq(true)
65
- expect(client.respond_to?("post_template")).to eq(true)
66
- expect(client.respond_to?("patch_template")).to eq(true)
67
- expect(client.respond_to?("delete_template")).to eq(true)
68
- # versions
69
- expect(client.respond_to?("get_version")).to eq(true)
70
- expect(client.respond_to?("post_version")).to eq(true)
71
- expect(client.respond_to?("activate_version")).to eq(true)
72
- expect(client.respond_to?("patch_version")).to eq(true)
73
- expect(client.respond_to?("delete_version")).to eq(true)
12
+ before :all do
13
+ @client = SendGrid4r::Client.new("username", "password")
14
+ end
74
15
 
16
+ describe "#initialize" do
17
+ it "create instance" do
18
+ expect(@client.class).to eq(SendGrid4r::Client)
19
+ end
75
20
  end
76
- end
77
21
 
78
- describe "Version" do
22
+ describe "methods" do
23
+ it "available" do
24
+ # Advanced Suppression Manager
25
+ # groups
26
+ expect(@client.respond_to?("get_groups")).to eq(true)
27
+ expect(@client.respond_to?("get_group")).to eq(true)
28
+ expect(@client.respond_to?("post_group")).to eq(true)
29
+ expect(@client.respond_to?("patch_group")).to eq(true)
30
+ expect(@client.respond_to?("delete_group")).to eq(true)
31
+ # suppressions
32
+ expect(@client.respond_to?("post_suppressed_emails")).to eq(true)
33
+ expect(@client.respond_to?("get_suppressions")).to eq(true)
34
+ expect(@client.respond_to?("get_suppressed_emails")).to eq(true)
35
+ expect(@client.respond_to?("delete_suppressed_email")).to eq(true)
36
+ # global suppressions
37
+ expect(@client.respond_to?("post_global_suppressed_emails")).to eq(true)
38
+ expect(@client.respond_to?("get_global_suppressed_email")).to eq(true)
39
+ expect(@client.respond_to?("delete_global_suppressed_email")).to eq(true)
40
+ # IP Management
41
+ # ip addresses
42
+ expect(@client.respond_to?("get_ips")).to eq(true)
43
+ expect(@client.respond_to?("get_ip")).to eq(true)
44
+ expect(@client.respond_to?("post_ip_to_pool")).to eq(true)
45
+ expect(@client.respond_to?("delete_ip_from_pool")).to eq(true)
46
+ # pool
47
+ expect(@client.respond_to?("get_pools")).to eq(true)
48
+ expect(@client.respond_to?("post_pool")).to eq(true)
49
+ expect(@client.respond_to?("get_pool")).to eq(true)
50
+ expect(@client.respond_to?("put_pool")).to eq(true)
51
+ expect(@client.respond_to?("delete_pool")).to eq(true)
52
+ # warmup
53
+ expect(@client.respond_to?("get_warmup_ips")).to eq(true)
54
+ expect(@client.respond_to?("get_warmup_ip")).to eq(true)
55
+ expect(@client.respond_to?("post_warmup_ip")).to eq(true)
56
+ expect(@client.respond_to?("delete_warmup_ip")).to eq(true)
57
+ # Settings
58
+ # enforced_tls
59
+ expect(@client.respond_to?("get_enforced_tls")).to eq(true)
60
+ expect(@client.respond_to?("patch_enforced_tls")).to eq(true)
61
+ # Template Engine
62
+ # templates
63
+ expect(@client.respond_to?("get_templates")).to eq(true)
64
+ expect(@client.respond_to?("get_template")).to eq(true)
65
+ expect(@client.respond_to?("post_template")).to eq(true)
66
+ expect(@client.respond_to?("patch_template")).to eq(true)
67
+ expect(@client.respond_to?("delete_template")).to eq(true)
68
+ # versions
69
+ expect(@client.respond_to?("get_version")).to eq(true)
70
+ expect(@client.respond_to?("post_version")).to eq(true)
71
+ expect(@client.respond_to?("activate_version")).to eq(true)
72
+ expect(@client.respond_to?("patch_version")).to eq(true)
73
+ expect(@client.respond_to?("delete_version")).to eq(true)
74
+ end
75
+ end
79
76
 
80
- it "Validate version" do
81
- expect(SendGrid4r::VERSION).to eq("0.0.4")
77
+ describe "VERSION" do
78
+ it "returns VERSION value" do
79
+ expect(SendGrid4r::VERSION).to eq("0.0.5")
80
+ end
82
81
  end
83
82
 
84
83
  end
85
-
86
84
  end
@@ -5,34 +5,29 @@ describe "SendGrid4r::REST::Settings::EnforcedTls" do
5
5
 
6
6
  before :all do
7
7
  Dotenv.load
8
+ @client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
8
9
  end
9
10
 
10
- context "normal" do
11
- it "is normal" do
11
+ context "always" do
12
12
 
13
- begin
14
- client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
13
+ describe "#get_enforced_tls" do
14
+ it "returns EnforcedTls instance" do
15
+ actual = @client.get_enforced_tls
16
+ expect(actual.class).to be(SendGrid4r::REST::Settings::EnforcedTls::EnforcedTls)
17
+ end
18
+ end
19
+
20
+ describe "#patch_enforced_tls" do
21
+ it "update EnforcedTls values" do
15
22
  # get original enforced_tls settings
16
- original = client.get_enforced_tls
17
- # patch a value
18
- edit_params = original.dup
19
- edit_params.require_tls = true
20
- actual_params = client.patch_enforced_tls(edit_params)
21
- expect(actual_params.require_tls).to eq(edit_params.require_tls)
23
+ actual = @client.get_enforced_tls
22
24
  # patch both value
23
- edit_params.require_tls = false
24
- edit_params.require_valid_cert = false
25
- actual_params = client.patch_enforced_tls(edit_params)
26
- expect(actual_params.require_tls).to eq(edit_params.require_tls)
27
- expect(actual_params.require_valid_cert).to eq(edit_params.require_valid_cert)
28
- # revert
29
- client.patch_enforced_tls(original)
30
- rescue => ex
31
- puts ex.inspect
32
- raise ex
25
+ actual.require_tls = false
26
+ actual.require_valid_cert = false
27
+ edit = @client.patch_enforced_tls(actual)
28
+ expect(actual.require_tls).to eq(edit.require_tls)
29
+ expect(actual.require_valid_cert).to eq(edit.require_valid_cert)
33
30
  end
34
-
35
31
  end
36
32
  end
37
-
38
33
  end
@@ -5,45 +5,40 @@ describe "SendGrid4r::REST::Asm::GlobalSuppressions" do
5
5
 
6
6
  before :all do
7
7
  Dotenv.load
8
+ @client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
8
9
  @email1 = "test1@test.com"
9
10
  @email2 = "test2@test.com"
10
11
  @email3 = "test3@test.com"
11
12
  end
12
13
 
13
- context "normal" do
14
+ context "always" do
14
15
  it "is normal" do
15
-
16
- begin
17
- client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
18
- # celan up test env
19
- client.delete_global_suppressed_email(@email1)
20
- client.delete_global_suppressed_email(@email2)
21
- client.delete_global_suppressed_email(@email3)
22
- # post recipient emails to the global suppression group
23
- suppressed_emails = client.post_global_suppressed_emails([@email1, @email2, @email3])
24
- expect(suppressed_emails.length).to eq(3)
25
- expect(suppressed_emails[0]).to eq(@email1)
26
- expect(suppressed_emails[1]).to eq(@email2)
27
- expect(suppressed_emails[2]).to eq(@email3)
28
- # get the recipient emails
29
- actual_email1 = client.get_global_suppressed_email(@email1)
30
- actual_email2 = client.get_global_suppressed_email(@email2)
31
- actual_email3 = client.get_global_suppressed_email(@email3)
32
- actual_notexist = client.get_global_suppressed_email("notexist")
33
- expect(actual_email1).to eq(@email1)
34
- expect(actual_email2).to eq(@email2)
35
- expect(actual_email3).to eq(@email3)
36
- expect(actual_notexist).to eq(nil)
37
- # delete the suppressed email
38
- expect(client.delete_global_suppressed_email(@email1)).to eq("")
39
- expect(client.delete_global_suppressed_email(@email2)).to eq("")
40
- expect(client.delete_global_suppressed_email(@email3)).to eq("")
41
- rescue => ex
42
- puts ex.inspect
43
- raise ex
44
- end
45
-
16
+ # celan up test env
17
+ actual_email1 = @client.get_global_suppressed_email(@email1)
18
+ actual_email2 = @client.get_global_suppressed_email(@email2)
19
+ actual_email3 = @client.get_global_suppressed_email(@email3)
20
+ @client.delete_global_suppressed_email(@email1) if actual_email1 == @email1
21
+ @client.delete_global_suppressed_email(@email2) if actual_email2 == @email2
22
+ @client.delete_global_suppressed_email(@email3) if actual_email3 == @email3
23
+ # post_global_suppressed_emails
24
+ suppressed_emails = @client.post_global_suppressed_emails([@email1, @email2, @email3])
25
+ expect(suppressed_emails.length).to eq(3)
26
+ expect(suppressed_emails.include? @email1).to eq(true)
27
+ expect(suppressed_emails.include? @email2).to eq(true)
28
+ expect(suppressed_emails.include? @email3).to eq(true)
29
+ # get_global_suppressed_email
30
+ actual_email1 = @client.get_global_suppressed_email(@email1)
31
+ actual_email2 = @client.get_global_suppressed_email(@email2)
32
+ actual_email3 = @client.get_global_suppressed_email(@email3)
33
+ actual_notexist = @client.get_global_suppressed_email("notexist")
34
+ expect(actual_email1).to eq(@email1)
35
+ expect(actual_email2).to eq(@email2)
36
+ expect(actual_email3).to eq(@email3)
37
+ expect(actual_notexist).to eq(nil)
38
+ # delete_global_suppressed_email
39
+ expect(@client.delete_global_suppressed_email(@email1)).to eq("")
40
+ expect(@client.delete_global_suppressed_email(@email2)).to eq("")
41
+ expect(@client.delete_global_suppressed_email(@email3)).to eq("")
46
42
  end
47
43
  end
48
-
49
44
  end
data/spec/groups_spec.rb CHANGED
@@ -5,59 +5,50 @@ describe "SendGrid4r::REST::Asm::Groups" do
5
5
 
6
6
  before :all do
7
7
  Dotenv.load
8
+ @client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
8
9
  @group_name = "group_test"
9
10
  @group_edit = "group_edit"
10
11
  @group_desc = "group_desc"
11
12
  @group_desc_edit = "group_desc_edit"
12
13
  end
13
14
 
14
- context "normal" do
15
+ context "always" do
15
16
  it "is normal" do
16
-
17
- begin
18
- client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
19
- # celan up test env
20
- grps = client.get_groups
21
- expect(grps.length >= 0).to eq(true)
22
- grps.each{|grp|
23
- if grp.name == @group_name || grp.name == @group_edit then
24
- client.delete_group(grp.id)
25
- end
26
- }
27
- # post a group
28
- new_group = client.post_group(@group_name, @group_desc)
29
- expect(@group_name).to eq(new_group.name)
30
- expect(@group_desc).to eq(new_group.description)
31
- # pach the group
32
- new_group.name = @group_edit
33
- new_group.description = @group_desc_edit
34
- client.patch_group(new_group.id, new_group)
35
- # get the group
36
- edit_group = client.get_group(new_group.id)
37
- expect(edit_group.respond_to?("id")).to eq(true)
38
- expect(edit_group.respond_to?("name")).to eq(true)
39
- expect(edit_group.respond_to?("description")).to eq(true)
40
- expect(edit_group.respond_to?("last_email_sent_at")).to eq(true)
41
- expect(edit_group.respond_to?("unsubscribes")).to eq(true)
42
- expect(new_group.id).to eq(edit_group.id)
43
- expect(@group_edit).to eq(edit_group.name)
44
- expect(@group_desc_edit).to eq(edit_group.description)
45
- # delete the group
46
- client.delete_group(edit_group.id)
47
- expect{client.get_group(edit_group.id)}.to raise_error(RestClient::ResourceNotFound)
48
- rescue => ex
49
- puts ex.inspect
50
- raise ex
51
- end
52
-
17
+ # celan up test env
18
+ grps = @client.get_groups
19
+ expect(grps.length >= 0).to eq(true)
20
+ grps.each{|grp|
21
+ if grp.name == @group_name || grp.name == @group_edit then
22
+ @client.delete_group(grp.id)
23
+ end
24
+ }
25
+ # post a group
26
+ new_group = @client.post_group(@group_name, @group_desc)
27
+ expect(@group_name).to eq(new_group.name)
28
+ expect(@group_desc).to eq(new_group.description)
29
+ # patch the group
30
+ new_group.name = @group_edit
31
+ new_group.description = @group_desc_edit
32
+ @client.patch_group(new_group.id, new_group)
33
+ # get the group
34
+ edit_group = @client.get_group(new_group.id)
35
+ expect(edit_group.respond_to?("id")).to eq(true)
36
+ expect(edit_group.respond_to?("name")).to eq(true)
37
+ expect(edit_group.respond_to?("description")).to eq(true)
38
+ expect(edit_group.respond_to?("last_email_sent_at")).to eq(true)
39
+ expect(edit_group.respond_to?("unsubscribes")).to eq(true)
40
+ expect(new_group.id).to eq(edit_group.id)
41
+ expect(@group_edit).to eq(edit_group.name)
42
+ expect(@group_desc_edit).to eq(edit_group.description)
43
+ # delete the group
44
+ @client.delete_group(edit_group.id)
45
+ expect{@client.get_group(edit_group.id)}.to raise_error(RestClient::ResourceNotFound)
53
46
  end
54
47
  end
55
48
 
56
49
  context "abnormal" do
57
50
  it "raise resource not found for none existance id" do
58
- client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
59
- expect{client.get_group("notexistid")}.to raise_error(RestClient::ResourceNotFound)
51
+ expect{@client.get_group("notexistid")}.to raise_error(RestClient::ResourceNotFound)
60
52
  end
61
53
  end
62
-
63
54
  end
data/spec/pools_spec.rb CHANGED
@@ -5,13 +5,13 @@ describe "SendGrid4r::REST::Ips::Pools" do
5
5
 
6
6
  before :all do
7
7
  Dotenv.load
8
+ @client = SendGrid4r::Client.new(ENV["SILVER_SENDGRID_USERNAME"], ENV["SILVER_SENDGRID_PASSWORD"])
8
9
  @pool_name = "pool_test"
9
10
  @pool_edit = "pool_edit"
10
11
  end
11
12
 
12
- context "free account" do
13
+ context "if account is free" do
13
14
  it "raise error" do
14
-
15
15
  begin
16
16
  #client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
17
17
  # get ip pools
@@ -28,48 +28,35 @@ describe "SendGrid4r::REST::Ips::Pools" do
28
28
  puts ex.inspect
29
29
  raise ex
30
30
  end
31
-
32
31
  end
33
-
34
32
  end
35
33
 
36
- context "silver account" do
34
+ context "if account is silver" do
37
35
  it "is normal" do
38
-
39
- begin
40
- client = SendGrid4r::Client.new(ENV["SILVER_SENDGRID_USERNAME"], ENV["SILVER_SENDGRID_PASSWORD"])
41
- # clean up test env
42
- pools = client.get_pools
43
- expect(pools.length >= 0).to eq(true)
44
- pools.each{|pool|
45
- if pool == @pool_name || pool == @pool_edit then
46
- client.delete_pool(pool)
47
- end
48
- }
49
- # post a pool
50
- new_pool = client.post_pool(@pool_name)
51
- expect(@pool_name).to eq(new_pool.name)
52
- # put the pool
53
- edit_pool = client.put_pool(@pool_name, @pool_edit)
54
- expect(@pool_edit).to eq(edit_pool.name)
55
- # get the pool
56
- pool = client.get_pool(@pool_edit)
57
- expect(SendGrid4r::REST::Ips::Pool).to be(pool.class)
58
- # delete the pool
59
- client.delete_pool(pool.name)
60
- expect{client.get_pool(pool.name)}
61
- ips = client.get_ips
62
- expect(ips.length).to be(1)
63
- expect(ips[0].class).to be(SendGrid4r::REST::Ips::Address)
64
- expect(client.get_ip(ips[0].ip).class).to be(SendGrid4r::REST::Ips::Address)
65
-
66
- rescue => ex
67
- puts ex.inspect
68
- raise ex
69
- end
70
-
36
+ # clean up test env
37
+ pools = @client.get_pools
38
+ expect(pools.length >= 0).to eq(true)
39
+ pools.each{|pool|
40
+ if pool == @pool_name || pool == @pool_edit then
41
+ @client.delete_pool(pool)
42
+ end
43
+ }
44
+ # post a pool
45
+ new_pool = @client.post_pool(@pool_name)
46
+ expect(@pool_name).to eq(new_pool.name)
47
+ # put the pool
48
+ edit_pool = @client.put_pool(@pool_name, @pool_edit)
49
+ expect(@pool_edit).to eq(edit_pool.name)
50
+ # get the pool
51
+ pool = @client.get_pool(@pool_edit)
52
+ expect(SendGrid4r::REST::Ips::Pool).to be(pool.class)
53
+ # delete the pool
54
+ @client.delete_pool(pool.name)
55
+ expect{@client.get_pool(pool.name)}
56
+ ips = @client.get_ips
57
+ expect(ips.length).to be(1)
58
+ expect(ips[0].class).to be(SendGrid4r::REST::Ips::Address)
59
+ expect(@client.get_ip(ips[0].ip).class).to be(SendGrid4r::REST::Ips::Address)
71
60
  end
72
-
73
61
  end
74
-
75
62
  end
@@ -5,71 +5,55 @@ describe "SendGrid4r::REST::Asm::Groups::Suppressions" do
5
5
 
6
6
  before :all do
7
7
  Dotenv.load
8
- @group_name = "suppressions_test"
8
+ @client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
9
9
  @email1 = "test1@test.com"
10
10
  @email2 = "test2@test.com"
11
11
  @email3 = "test3@test.com"
12
-
12
+ @group_name = "suppressions_test"
13
13
  @group_desc = "group_desc"
14
14
  end
15
15
 
16
- context "normal" do
16
+ context "always" do
17
17
  it "is normal" do
18
-
19
- begin
20
- client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
21
- # celan up test env
22
- grps = client.get_groups
23
- expect(grps.length >= 0).to eq(true)
24
- grps.each{|grp|
25
- if grp.name == @group_name then
26
- emails = client.get_suppressed_emails(grp.id)
27
- emails.each{|email|
28
- client.delete_suppressed_email(grp.id, email)
29
- }
30
- client.delete_group(grp.id)
31
- end
32
- }
33
- # post a group
34
- new_group = client.post_group(@group_name, @group_desc)
35
- # post recipient emails to the suppression group
36
- suppressed_emails = client.post_suppressed_emails(new_group.id, [@email1, @email2, @email3])
37
- expect(suppressed_emails.length).to eq(3)
38
- expect(suppressed_emails[0]).to eq(@email1)
39
- expect(suppressed_emails[1]).to eq(@email2)
40
- expect(suppressed_emails[2]).to eq(@email3)
41
- # get the suppressions
42
- suppressions = client.get_suppressions(@email1)
43
- expect(suppressions.length).to eq(1)
44
- expect(suppressions[0].name).to eq(@group_name)
45
- expect(suppressions[0].description).to eq(@group_desc)
46
- expect(suppressions[0].suppressed).to eq(true)
47
- # get the recipient emails
48
- actual_emails = client.get_suppressed_emails(new_group.id)
49
- expect(actual_emails.length).to eq(suppressed_emails.length)
50
- expect(actual_emails[0]).to eq(suppressed_emails[0])
51
- expect(actual_emails[1]).to eq(suppressed_emails[1])
52
- expect(actual_emails[2]).to eq(suppressed_emails[2])
53
- # delete the suppressed email
54
- client.delete_suppressed_email(new_group.id, @email1)
55
- client.delete_suppressed_email(new_group.id, @email2)
56
- client.delete_suppressed_email(new_group.id, @email3)
57
- # delete the group
58
- client.delete_group(new_group.id)
59
- expect{client.get_group(new_group.id)}.to raise_error(RestClient::ResourceNotFound)
60
- rescue => ex
61
- puts ex.inspect
62
- raise ex
63
- end
64
-
18
+ # celan up test env
19
+ grps = @client.get_groups
20
+ expect(grps.length >= 0).to eq(true)
21
+ grps.each{|grp|
22
+ if grp.name == @group_name then
23
+ emails = @client.get_suppressed_emails(grp.id)
24
+ emails.each{|email|
25
+ @client.delete_suppressed_email(grp.id, email)
26
+ }
27
+ @client.delete_group(grp.id)
28
+ end
29
+ }
30
+ # post a group
31
+ new_group = @client.post_group(@group_name, @group_desc)
32
+ # post recipient emails to the suppression group
33
+ suppressed_emails = @client.post_suppressed_emails(new_group.id, [@email1, @email2, @email3])
34
+ expect(suppressed_emails.length).to eq(3)
35
+ expect(suppressed_emails[0]).to eq(@email1)
36
+ expect(suppressed_emails[1]).to eq(@email2)
37
+ expect(suppressed_emails[2]).to eq(@email3)
38
+ # get the suppressions
39
+ suppressions = @client.get_suppressions(@email1)
40
+ expect(suppressions.length>=1).to eq(true)
41
+ expect(suppressions[0].name).to eq(@group_name)
42
+ expect(suppressions[0].description).to eq(@group_desc)
43
+ expect(suppressions[0].suppressed).to eq(true)
44
+ # get the recipient emails
45
+ actual_emails = @client.get_suppressed_emails(new_group.id)
46
+ expect(actual_emails.length).to eq(suppressed_emails.length)
47
+ expect(actual_emails[0]).to eq(suppressed_emails[0])
48
+ expect(actual_emails[1]).to eq(suppressed_emails[1])
49
+ expect(actual_emails[2]).to eq(suppressed_emails[2])
50
+ # delete the suppressed email
51
+ @client.delete_suppressed_email(new_group.id, @email1)
52
+ @client.delete_suppressed_email(new_group.id, @email2)
53
+ @client.delete_suppressed_email(new_group.id, @email3)
54
+ # delete the group
55
+ @client.delete_group(new_group.id)
56
+ expect{@client.get_group(new_group.id)}.to raise_error(RestClient::ResourceNotFound)
65
57
  end
66
58
  end
67
-
68
- context "abnormal" do
69
- it "raise resource not found for none existance id" do
70
- client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
71
- expect{client.post_suppressed_emails("notexistid", [@email1, @email2, @email3])}.to raise_error(RestClient::ResourceNotFound)
72
- end
73
- end
74
-
75
59
  end
@@ -5,49 +5,34 @@ describe "SendGrid4r::REST::Templates" do
5
5
 
6
6
  before :all do
7
7
  Dotenv.load
8
+ @client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
8
9
  @template_name = "template_test"
9
10
  @template_edit = "template_edit"
10
11
  end
11
12
 
12
- context "normal" do
13
+ context "always" do
13
14
  it "is normal" do
14
-
15
- begin
16
- client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
17
- # celan up test env
18
- tmps = client.get_templates
19
- expect(tmps.length >= 0).to eq(true)
20
- tmps.each{|tmp|
21
- if tmp.name == @template_name || tmp.name == @template_edit then
22
- client.delete_template(tmp.id)
23
- end
24
- }
25
- # post a template
26
- new_template = client.post_template(@template_name)
27
- expect(@template_name).to eq(new_template.name)
28
- # pach the template
29
- client.patch_template(new_template.id, @template_edit)
30
- # get the template
31
- edit_template = client.get_template(new_template.id)
32
- expect(new_template.id).to eq(edit_template.id)
33
- expect(@template_edit).to eq(edit_template.name)
34
- expect(new_template.versions).to eq(edit_template.versions)
35
- # delete the template
36
- client.delete_template(edit_template.id)
37
- expect{client.get_template(edit_template.id)}.to raise_error(RestClient::ResourceNotFound)
38
- rescue => ex
39
- puts ex.inspect
40
- raise ex
41
- end
42
-
43
- end
44
- end
45
-
46
- context "abnormal" do
47
- it "raise resource not found for none existance id" do
48
- client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
49
- expect{client.get_template("notexistid")}.to raise_error(RestClient::ResourceNotFound)
15
+ # celan up test env
16
+ tmps = @client.get_templates
17
+ expect(tmps.length >= 0).to eq(true)
18
+ tmps.each{|tmp|
19
+ if tmp.name == @template_name || tmp.name == @template_edit then
20
+ @client.delete_template(tmp.id)
21
+ end
22
+ }
23
+ # post a template
24
+ new_template = @client.post_template(@template_name)
25
+ expect(@template_name).to eq(new_template.name)
26
+ # pach the template
27
+ @client.patch_template(new_template.id, @template_edit)
28
+ # get the template
29
+ edit_template = @client.get_template(new_template.id)
30
+ expect(new_template.id).to eq(edit_template.id)
31
+ expect(@template_edit).to eq(edit_template.name)
32
+ expect(new_template.versions).to eq(edit_template.versions)
33
+ # delete the template
34
+ @client.delete_template(edit_template.id)
35
+ expect{@client.get_template(edit_template.id)}.to raise_error(RestClient::ResourceNotFound)
50
36
  end
51
37
  end
52
-
53
38
  end
@@ -5,33 +5,26 @@ describe "SendGrid4r::VersionFactory" do
5
5
 
6
6
  before :all do
7
7
  Dotenv.load
8
+ @factory = SendGrid4r::VersionFactory.new
8
9
  end
9
10
 
10
- context "normal" do
11
+ context "always" do
11
12
  it "is simple case" do
12
-
13
- factory = SendGrid4r::VersionFactory.new
14
- version = factory.create("version_name")
13
+ version = @factory.create("version_name")
15
14
  expect(version.name).to eq("version_name")
16
15
  expect(version.subject).to eq("<%subject%>")
17
16
  expect(version.html_content).to eq("<%body%>")
18
17
  expect(version.plain_content).to eq("<%body%>")
19
18
  expect(version.active).to eq(1)
20
-
21
19
  end
22
20
 
23
21
  it "is full params case" do
24
-
25
- factory = SendGrid4r::VersionFactory.new
26
- version = factory.create("version_name", "This is subject <%subject%>", "This is html content <%body%>", "This is plain content <%body%>", 0)
22
+ version = @factory.create("version_name", "This is subject <%subject%>", "This is html content <%body%>", "This is plain content <%body%>", 0)
27
23
  expect(version.name).to eq("version_name")
28
24
  expect(version.subject).to eq("This is subject <%subject%>")
29
25
  expect(version.html_content).to eq("This is html content <%body%>")
30
26
  expect(version.plain_content).to eq("This is plain content <%body%>")
31
27
  expect(version.active).to eq(0)
32
-
33
28
  end
34
-
35
29
  end
36
-
37
30
  end
@@ -5,86 +5,71 @@ describe "SendGrid4r::REST::Templates::Versions" do
5
5
 
6
6
  before :all do
7
7
  Dotenv.load
8
- @template_name = "version_test"
8
+ @client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
9
+ @template_edit = "version_test"
9
10
  @version1_name = "version1_test"
10
11
  @version2_name = "version2_test"
11
12
  end
12
13
 
13
- context "normal" do
14
-
14
+ context "always" do
15
15
  it "is normal" do
16
- begin
17
- client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
18
- # celan up test env
19
- tmps = client.get_templates
20
- tmps.each{|tmp|
21
- if tmp.name == @template_name then
22
- tmp.versions.each{|ver|
23
- client.delete_version(tmp.id, ver.id)
24
- }
25
- client.delete_template(tmp.id)
26
- end
27
- }
28
- # post a template
29
- new_template = client.post_template(@template_name)
30
- expect(@template_name).to eq(new_template.name)
31
- # post a version
32
- factory = SendGrid4r::VersionFactory.new
33
- ver1 = factory.create(@version1_name)
34
- ver1 = client.post_version(new_template.id, ver1)
35
- # get the version
36
- actual = client.get_version(new_template.id, ver1.id)
37
- expect(ver1.template_id).to eq(actual.template_id)
38
- expect(ver1.active).to eq(actual.active)
39
- expect(ver1.name).to eq(actual.name)
40
- expect(ver1.html_content).to eq(actual.html_content)
41
- expect(ver1.plain_content).to eq(actual.plain_content)
42
- expect(ver1.subject).to eq(actual.subject)
43
- # edit the version
44
- edit_ver1 = actual.dup
45
- edit_ver1.name = "edit_version"
46
- edit_ver1.subject = "edit<%subject%>edit"
47
- edit_ver1.html_content = "edit<%body%>edit"
48
- edit_ver1.plain_content = "edit<%body%>edit"
49
- edit_ver1.active = 0
50
- client.patch_version(new_template.id, ver1.id, edit_ver1)
51
- # get the version
52
- actual = client.get_version(new_template.id, ver1.id)
53
- expect(new_template.id).to eq(actual.template_id)
54
- expect(edit_ver1.active).to eq(actual.active)
55
- expect(edit_ver1.name).to eq(actual.name)
56
- expect(edit_ver1.html_content).to eq(actual.html_content)
57
- expect(edit_ver1.plain_content).to eq(actual.plain_content)
58
- expect(edit_ver1.subject).to eq(actual.subject)
59
- # post a version 2
60
- ver2 = factory.create(@version2_name, "<%subject%>", "<%body%>", "<%body%>")
61
- ver2 = client.post_version(new_template.id, ver2)
62
- # activate version 2
63
- client.activate_version(new_template.id, ver2.id)
64
- actual_ver1 = client.get_version(new_template.id, ver1.id)
65
- actual_ver2 = client.get_version(new_template.id, ver2.id)
66
- expect(0).to eq(actual_ver1.active)
67
- expect(1).to eq(actual_ver2.active)
68
- # delete the version
69
- client.delete_version(new_template.id, actual_ver1.id)
70
- client.delete_version(new_template.id, actual_ver2.id)
71
- expect{client.get_version(new_template.id, actual_ver1.id)}.to raise_error(RestClient::ResourceNotFound)
72
- expect{client.get_version(new_template.id, actual_ver2.id)}.to raise_error(RestClient::ResourceNotFound)
73
- # delete the template
74
- client.delete_template(new_template.id)
75
- rescue => ex
76
- puts ex.inspect
77
- raise ex
78
- end
79
- end
80
- end
81
-
82
- context "abnormal" do
83
-
84
- it "raise resource not found for none existance id" do
85
- client = SendGrid4r::Client.new(ENV["SENDGRID_USERNAME"], ENV["SENDGRID_PASSWORD"])
86
- expect{client.get_version("notexistid", "notexistid")}.to raise_error(RestClient::ResourceNotFound)
16
+ # celan up test env
17
+ tmps = @client.get_templates
18
+ tmps.each{|tmp|
19
+ if tmp.name == @template_edit then
20
+ tmp.versions.each{|ver|
21
+ @client.delete_version(tmp.id, ver.id)
22
+ }
23
+ @client.delete_template(tmp.id)
24
+ end
25
+ }
26
+ # post a template
27
+ new_template = @client.post_template(@template_edit)
28
+ expect(@template_edit).to eq(new_template.name)
29
+ # post a version
30
+ factory = SendGrid4r::VersionFactory.new
31
+ ver1 = factory.create(@version1_name)
32
+ ver1 = @client.post_version(new_template.id, ver1)
33
+ # get the version
34
+ actual = @client.get_version(new_template.id, ver1.id)
35
+ expect(ver1.template_id).to eq(actual.template_id)
36
+ expect(ver1.active).to eq(actual.active)
37
+ expect(ver1.name).to eq(actual.name)
38
+ expect(ver1.html_content).to eq(actual.html_content)
39
+ expect(ver1.plain_content).to eq(actual.plain_content)
40
+ expect(ver1.subject).to eq(actual.subject)
41
+ # edit the version
42
+ edit_ver1 = actual.dup
43
+ edit_ver1.name = "edit_version"
44
+ edit_ver1.subject = "edit<%subject%>edit"
45
+ edit_ver1.html_content = "edit<%body%>edit"
46
+ edit_ver1.plain_content = "edit<%body%>edit"
47
+ edit_ver1.active = 0
48
+ @client.patch_version(new_template.id, ver1.id, edit_ver1)
49
+ # get the version
50
+ actual = @client.get_version(new_template.id, ver1.id)
51
+ expect(new_template.id).to eq(actual.template_id)
52
+ expect(edit_ver1.active).to eq(actual.active)
53
+ expect(edit_ver1.name).to eq(actual.name)
54
+ expect(edit_ver1.html_content).to eq(actual.html_content)
55
+ expect(edit_ver1.plain_content).to eq(actual.plain_content)
56
+ expect(edit_ver1.subject).to eq(actual.subject)
57
+ # post a version 2
58
+ ver2 = factory.create(@version2_name, "<%subject%>", "<%body%>", "<%body%>")
59
+ ver2 = @client.post_version(new_template.id, ver2)
60
+ # activate version 2
61
+ @client.activate_version(new_template.id, ver2.id)
62
+ actual_ver1 = @client.get_version(new_template.id, ver1.id)
63
+ actual_ver2 = @client.get_version(new_template.id, ver2.id)
64
+ expect(0).to eq(actual_ver1.active)
65
+ expect(1).to eq(actual_ver2.active)
66
+ # delete the version
67
+ @client.delete_version(new_template.id, actual_ver1.id)
68
+ @client.delete_version(new_template.id, actual_ver2.id)
69
+ expect{@client.get_version(new_template.id, actual_ver1.id)}.to raise_error(RestClient::ResourceNotFound)
70
+ expect{@client.get_version(new_template.id, actual_ver2.id)}.to raise_error(RestClient::ResourceNotFound)
71
+ # delete the template
72
+ @client.delete_template(new_template.id)
87
73
  end
88
74
  end
89
-
90
75
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: sendgrid4r
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.0.4
4
+ version: 0.0.5
5
5
  platform: ruby
6
6
  authors:
7
7
  - awwa500@gmail.com
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2014-10-23 00:00:00.000000000 Z
11
+ date: 2014-10-26 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: rest-client