sendgrid-ruby 4.0.3 → 4.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ef92c3e502bb4626c6e5ce0a7d9f2476e5f2b66
-  data.tar.gz: 5639c8038e93be999adef7442882d5cb909383a1
+  metadata.gz: 3b55be9596fe7e0909a03c49cb9e698d922a1a39
+  data.tar.gz: 06a368c6b3602362d1efd92570797f284c24fd7a
 SHA512:
-  metadata.gz: 624cbe2ff6f82eaf86dd6dcd7899ce677d747e8908814b6b96211b0a6eabe8e9e57be3bb492c585f1a0003bafe2bea58c490f899738421cb2ccd38076a21f517
-  data.tar.gz: 111671b61535cf1df87c493536f89949890fa870cec5ae31da16b03cc1278533480560f2592ce7e58e6b4dd00af9efedefc53136870ebca1b83a1bcdb90df5b7
+  metadata.gz: a03a6e57f9ba993d5ca038bb5a270821dde415188f4b0c38bb7454cda68c7b1136b49b8dec624eda22d389e12c2fa9ed7669b40f4c743022d6a6d34927f59702
+  data.tar.gz: ae5d547a542b5ca06b0086407f50ab67cd0b103a956ad77a4d4e9efb0a3e6344651420025db6bd2e8fcb53d293cbecb733d299b1ac201b657ad41e4356806a7e

data/CHANGELOG.md

@@ -1,6 +1,11 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## [4.0.4] - 2016-09-15 ##
+### Fixed
+- Pull #72: [remove unnecessary ruby 2.2 requirement](https://github.com/sendgrid/sendgrid-ruby/pull/72)
+- Thanks to [Billy Watson](https://github.com/billywatson) for the pull request!
+
 ## [4.0.3] - 2016-08-24 ##
 ### Added
 - Table of Contents in the README

data/CONTRIBUTING.md

@@ -64,16 +64,37 @@ We welcome direct contributions to the sendgrid-ruby code base. Thank you!
 
 ##### Prerequisites #####
 
-- Ruby version 2.2
+- Ruby 2.1+
 - [ruby_http_client](https://github.com/sendgrid/ruby-http-client)
 
+
 ##### Initial setup: #####
 
-```bash
-git clone https://github.com/sendgrid/sendgrid-ruby.git
-cd sendgrid-ruby
-bundle install
-```
+1. Clone the project
+
+   ```bash
+   git clone https://github.com/sendgrid/sendgrid-ruby.git
+   cd sendgrid-ruby
+   ```
+
+1. Install bundler and bundle
+
+   ```bash
+   bundle install
+   ```
+
+1. Download [prism](https://stoplight.io/prism/) for your platform ([Mac OS X](https://github.com/stoplightio/prism/releases/download/v0.1.5/prism_darwin_amd64)) and save the binary to the sendgrid-ruby directory (or any directory you would like. The sendgrid-ruby directory is chosen mostly for convenience.)
+1. Add execute permissions
+
+   ```bash
+   chmod +x prism
+   ```
+1. Download the [prism spec for sendgrid](https://api.stoplight.io/v1/versions/563a5309daad691100fb05af/export/stoplight.json) and save it to the same directory
+1. In a separate terminal, cd into the directory you chose for prism and start the sendgrid local server which the tests will use. 
+
+   ```bash
+   ./prism run --mock --list --spec stoplight.json
+   ```
 
 ## Environment Variables
 
@@ -199,4 +220,4 @@ Please run your code through:
 7. [Open a Pull Request](https://help.github.com/articles/using-pull-requests/)
     with a clear title and description against the `master` branch. All tests must be passing before we will review the PR.
 
-If you have any additional questions, please feel free to [email](mailto:dx@sendgrid.com) us or create an issue in this repo.
+If you have any additional questions, please feel free to [email](mailto:dx@sendgrid.com) us or create an issue in this repo.

data/Gemfile

@@ -1,3 +1,3 @@
 source 'http://rubygems.org'
 
-gem 'ruby_http_client'
+gemspec 

data/README.md

@@ -1,5 +1,6 @@
 [![Travis Badge](https://travis-ci.org/sendgrid/sendgrid-ruby.svg?branch=master)](https://travis-ci.org/sendgrid/sendgrid-ruby)
 
+Please see our announcement regarding [breaking changes](https://github.com/sendgrid/sendgrid-ruby/issues/94). Your support is appreciated!
 
 **This library allows you to quickly and easily use the SendGrid Web API v3 via Ruby.**
 
@@ -11,11 +12,24 @@ Please browse the rest of this README for further detail.
 
 We appreciate your continued support, thank you!
 
+# Table of Contents
+
+* [Installation](#installation)
+* [Quick Start](#quick_start)
+* [Usage](#usage)
+* [Use Cases](#use_cases)
+* [Announcements](#announcements)
+* [Roadmap](#roadmap)
+* [How to Contribute](#contribute)
+* [Troubleshooting](#troubleshooting)
+* [About](#about)
+
+<a name="installation"></a>
 # Installation
 
 ## Prerequisites
 
-- Ruby version 2.2
+- Ruby version 2.1+
 - The SendGrid service, starting at the [free level](https://sendgrid.com/free?source=sendgrid-ruby)
 
 ## Setup Environment Variables
@@ -51,6 +65,7 @@ gem install sendgrid-ruby
 
 - [Ruby-HTTP-Client](https://github.com/sendgrid/ruby-http-client)
 
+<a name="quick_start"></a>
 # Quick Start
 
 ## Hello Email
@@ -83,6 +98,9 @@ For more complex scenarios, please do not use the above constructor and instead
 The following is the minimum needed code to send an email without the /mail/send Helper ([here](https://github.com/sendgrid/sendgrid-ruby/blob/master/examples/mail/mail.rb#L26) is a full example):
 
 ```ruby
+require 'sendgrid-ruby'
+include SendGrid
+
 data = JSON.parse('{
   "personalizations": [
     {
@@ -104,6 +122,7 @@ data = JSON.parse('{
     }
   ]
 }')
+sg = SendGrid::API.new(api_key: ENV['SENDGRID_API_KEY'])
 response = sg.client.mail._("send").post(request_body: data)
 puts response.status_code
 puts response.body
@@ -132,6 +151,7 @@ puts response.body
 puts response.headers
 ```
 
+<a name="usage"></a>
 # Usage
 
 - [SendGrid Docs](https://sendgrid.com/docs/API_Reference/index.html)
@@ -140,14 +160,24 @@ puts response.headers
 - [How-to: Migration from v2 to v3](https://sendgrid.com/docs/Classroom/Send/v3_Mail_Send/how_to_migrate_from_v2_to_v3_mail_send.html)
 - [v3 Web API Mail Send Helper](https://github.com/sendgrid/sendgrid-python/tree/master/sendgrid/helpers/mail) - build a request object payload for a v3 /mail/send API call.
 
+<a name="use_cases">
+# Use Cases
+
+[Examples of common API use cases](https://github.com/sendgrid/sendgrid-ruby/blob/master/USE_CASES.md), such as how to send an email with a transactional template.
+
+<a name="announcements"></a>
 # Announcements
 
+Please see our announcement regarding [breaking changes](https://github.com/sendgrid/sendgrid-ruby/issues/94). Your support is appreciated!
+
 All updates to this library is documented in our [CHANGELOG](https://github.com/sendgrid/sendgrid-ruby/blob/master/CHANGELOG.md) and [releases](https://github.com/sendgrid/sendgrid-ruby/releases).
 
+<a name="roadmap"></a>
 # Roadmap
 
 If you are interested in the future direction of this project, please take a look at our open [issues](https://github.com/sendgrid/sendgrid-ruby/issues) and [pull requests](https://github.com/sendgrid/sendgrid-ruby/pulls). We would love to hear your feedback.
 
+<a name="contribute"></a>
 # How to Contribute
 
 We encourage contribution to our libraries (you might even score some nifty swag), please see our [CONTRIBUTING](https://github.com/sendgrid/sendgrid-ruby/tree/master/CONTRIBUTING.md) guide for details.
@@ -157,10 +187,12 @@ We encourage contribution to our libraries (you might even score some nifty swag
 - [Sign the CLA to Create a Pull Request](https://github.com/sendgrid/sendgrid-ruby/tree/master/CONTRIBUTING.md#cla)
 - [Improvements to the Codebase](https://github.com/sendgrid/sendgrid-ruby/tree/master/CONTRIBUTING.md#improvements_to_the_codebase)
 
+<a name="troubleshooting"></a>
 # Troubleshooting
 
 Please see our [troubleshooting guide](https://github.com/sendgrid/sendgrid-ruby/blob/master/TROUBLESHOOTING.md) for common library issues.
 
+<a name="about"></a>
 # About
 
 sendgrid-ruby is guided and supported by the SendGrid [Developer Experience Team](mailto:dx@sendgrid.com).

data/USE_CASES.md

@@ -0,0 +1,113 @@
+This documentation provides examples for specific use cases. Please [open an issue](https://github.com/sendgrid/sendgrid-ruby/issues) or make a pull request for any use cases you would like us to document here. Thank you!
+
+# Table of Contents
+
+* [Transactional Templates](#transactional_templates)
+
+<a name="transactional_templates"></a>
+# Transactional Templates
+
+For this example, we assume you have created a [transactional template](https://sendgrid.com/docs/User_Guide/Transactional_Templates/index.html). Following is the template content we used for testing.
+
+Template ID (replace with your own):
+
+```text
+13b8f94f-bcae-4ec6-b752-70d6cb59f932
+```
+
+Email Subject:
+
+```text
+<%subject%>
+```
+
+Template Body:
+
+```html
+<html>
+<head>
+	<title></title>
+</head>
+<body>
+Hello -name-,
+<br /><br/>
+I'm glad you are trying out the template feature!
+<br /><br/>
+<%body%>
+<br /><br/>
+I hope you are having a great day in -city- :)
+<br /><br/>
+</body>
+</html>
+```
+
+## With Mail Helper Class
+
+```ruby
+require 'sendgrid-ruby'
+include SendGrid
+
+mail = Mail.new
+mail.from = Email.new(email: 'test@example.com')
+mail.subject = 'I\'m replacing the subject tag'
+personalization = Personalization.new
+personalization.to = Email.new(email: 'test@example.com')
+personalization.substitutions = Substitution.new(key: '-name-', value: 'Example User')
+personalization.substitutions = Substitution.new(key: '-city-', value: 'Denver')
+mail.personalizations = personalization
+mail.contents = Content.new(type: 'text/html', value: 'I\'m replacing the <strong>body tag</strong>')
+mail.template_id = '13b8f94f-bcae-4ec6-b752-70d6cb59f932'
+
+sg = SendGrid::API.new(api_key: ENV['SENDGRID_API_KEY'])
+begin
+    response = sg.client.mail._("send").post(request_body: mail.to_json)
+rescue Exception => e
+    puts e.message
+end
+puts response.status_code
+puts response.body
+puts response.headers
+```
+
+## Without Mail Helper Class
+
+```ruby
+require 'sendgrid-ruby'
+include SendGrid
+
+data = JSON.parse('{
+  "personalizations": [
+    {
+      "to": [
+        {
+          "email": "test@example.com"
+        }
+      ],
+      "substitutions": {
+        "-name-": "Example User",
+        "-city-": "Denver"
+      },
+      "subject": "I\'m replacing the subject tag"
+    }
+  ],
+  "from": {
+    "email": "test@example.com"
+  },
+  "content": [
+    {
+      "type": "text/html",
+      "value": "I\'m replacing the <strong>body tag</strong>"
+    }
+  ],
+  "template_id": "13b8f94f-bcae-4ec6-b752-70d6cb59f932"
+}')
+sg = SendGrid::API.new(api_key: ENV['SENDGRID_API_KEY'])
+begin
+    response = sg.client.mail._("send").post(request_body: data)
+rescue Exception => e
+    puts e.message
+end
+puts response.status_code
+puts response.body
+puts response.headers
+```

data/examples/helpers/mail/example.rb

@@ -29,7 +29,7 @@ def kitchen_sink
   personalization.cc = Email.new(email: 'test4@example.com', name: 'Example User')
   personalization.bcc = Email.new(email: 'test5@example.com', name: 'Example User')
   personalization.bcc = Email.new(email: 'test6@example.com', name: 'Example User')
-  personalization.subject = 'Hello World from the Personalized SendGrid Python Library'
+  personalization.subject = 'Hello World from the Personalized SendGrid Ruby Library'
   personalization.headers = Header.new(key: 'X-Test', value: 'True')
   personalization.headers = Header.new(key: 'X-Mock', value: 'False')
   personalization.substitutions = Substitution.new(key: '%name%', value: 'Example User')
@@ -46,7 +46,7 @@ def kitchen_sink
   personalization2.cc = Email.new(email: 'test4@example.com', name: 'Example User')
   personalization2.bcc = Email.new(email: 'test5@example.com', name: 'Example User')
   personalization2.bcc = Email.new(email: 'test6@example.com', name: 'Example User')
-  personalization2.subject = 'Hello World from the Personalized SendGrid Python Library'
+  personalization2.subject = 'Hello World from the Personalized SendGrid Ruby Library'
   personalization2.headers = Header.new(key: 'X-Test', value: 'True')
   personalization2.headers = Header.new(key: 'X-Mock', value: 'False')
   personalization2.substitutions = Substitution.new(key: '%name%', value: 'Example User')

data/lib/sendgrid/version.rb

@@ -1,3 +1,3 @@
 module SendGrid
-  VERSION = '4.0.3'
+  VERSION = '4.0.4'
 end

data/sendgrid-ruby.gemspec

@@ -12,7 +12,6 @@ Gem::Specification.new do |spec|
   spec.description = 'Interact with SendGrids API in native Ruby'
   spec.homepage    = 'http://github.com/sendgrid/sendgrid-ruby'
   spec.license     = 'MIT'
-  spec.required_ruby_version = '>= 2.2'
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(/^bin/) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(/^(test|spec|features)/)
@@ -20,4 +19,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'ruby_http_client', '~> 3.0.0'
   spec.add_development_dependency 'rake', '~> 0'
+  spec.add_development_dependency 'minitest'
 end

data/test/sendgrid/test_sendgrid-ruby.rb

@@ -1,8 +1,9 @@
 require_relative '../../lib/sendgrid-ruby.rb'
 require 'ruby_http_client'
 require 'minitest/autorun'
+require 'minitest/unit'
 
-class TestAPI < Minitest::Test
+class TestAPI < MiniTest::Test
     def setup
         if ENV['TRAVIS']
             host = ENV['MOCK_HOST']
@@ -30,15 +31,17 @@ class TestAPI < Minitest::Test
             ')
         assert_equal(test_headers, sg.request_headers)
         assert_equal("v3", sg.version)
-        assert_equal("4.0.3", SendGrid::VERSION)
+        assert_equal("4.0.4", SendGrid::VERSION)
         assert_instance_of(SendGrid::Client, sg.client)
     end
 
     def test_access_settings_activity_get
         params = JSON.parse('{"limit": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.access_settings.activity.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_access_settings_whitelist_post
@@ -56,14 +59,18 @@ class TestAPI < Minitest::Test
   ]
 }')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.access_settings.whitelist.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_access_settings_whitelist_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.access_settings.whitelist.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_access_settings_whitelist_delete
@@ -75,22 +82,28 @@ class TestAPI < Minitest::Test
   ]
 }')
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.access_settings.whitelist.delete(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_access_settings_whitelist__rule_id__get
         rule_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.access_settings.whitelist._(rule_id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_access_settings_whitelist__rule_id__delete
         rule_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.access_settings.whitelist._(rule_id).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_alerts_post
@@ -100,14 +113,18 @@ class TestAPI < Minitest::Test
   "type": "stats_notification"
 }')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.alerts.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_alerts_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.alerts.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_alerts__alert_id__patch
@@ -116,22 +133,28 @@ class TestAPI < Minitest::Test
 }')
         alert_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.alerts._(alert_id).patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_alerts__alert_id__get
         alert_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.alerts._(alert_id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_alerts__alert_id__delete
         alert_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.alerts._(alert_id).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_api_keys_post
@@ -145,15 +168,19 @@ class TestAPI < Minitest::Test
   ]
 }')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.api_keys.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_api_keys_get
         params = JSON.parse('{"limit": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.api_keys.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_api_keys__api_key_id__put
@@ -166,8 +193,10 @@ class TestAPI < Minitest::Test
 }')
         api_key_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.api_keys._(api_key_id).put(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_api_keys__api_key_id__patch
@@ -176,22 +205,28 @@ class TestAPI < Minitest::Test
 }')
         api_key_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.api_keys._(api_key_id).patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_api_keys__api_key_id__get
         api_key_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.api_keys._(api_key_id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_api_keys__api_key_id__delete
         api_key_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.api_keys._(api_key_id).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_asm_groups_post
@@ -201,15 +236,19 @@ class TestAPI < Minitest::Test
   "name": "Product Suggestions"
 }')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.asm.groups.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_asm_groups_get
         params = JSON.parse('{"id": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.asm.groups.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_asm_groups__group_id__patch
@@ -220,22 +259,28 @@ class TestAPI < Minitest::Test
 }')
         group_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.asm.groups._(group_id).patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_asm_groups__group_id__get
         group_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.asm.groups._(group_id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_asm_groups__group_id__delete
         group_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.asm.groups._(group_id).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_asm_groups__group_id__suppressions_post
@@ -247,15 +292,19 @@ class TestAPI < Minitest::Test
 }')
         group_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.asm.groups._(group_id).suppressions.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_asm_groups__group_id__suppressions_get
         group_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.asm.groups._(group_id).suppressions.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_asm_groups__group_id__suppressions_search_post
@@ -268,22 +317,28 @@ class TestAPI < Minitest::Test
 }')
         group_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.asm.groups._(group_id).suppressions.search.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_asm_groups__group_id__suppressions__email__delete
         group_id = "test_url_param"
         email = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.asm.groups._(group_id).suppressions._(email).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_asm_suppressions_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.asm.suppressions.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_asm_suppressions_global_post
@@ -294,36 +349,46 @@ class TestAPI < Minitest::Test
   ]
 }')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.asm.suppressions.global.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_asm_suppressions_global__email__get
         email = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.asm.suppressions.global._(email).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_asm_suppressions_global__email__delete
         email = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.asm.suppressions.global._(email).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_asm_suppressions__email__get
         email = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.asm.suppressions._(email).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_browsers_stats_get
         params = JSON.parse('{"end_date": "2016-04-01", "aggregated_by": "day", "browsers": "test_string", "limit": "test_string", "offset": "test_string", "start_date": "2016-01-01"}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.browsers.stats.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_campaigns_post
@@ -348,15 +413,19 @@ class TestAPI < Minitest::Test
   "title": "March Newsletter"
 }')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.campaigns.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_campaigns_get
         params = JSON.parse('{"limit": 1, "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.campaigns.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_campaigns__campaign_id__patch
@@ -371,22 +440,28 @@ class TestAPI < Minitest::Test
 }')
         campaign_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.campaigns._(campaign_id).patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_campaigns__campaign_id__get
         campaign_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.campaigns._(campaign_id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_campaigns__campaign_id__delete
         campaign_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.campaigns._(campaign_id).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_campaigns__campaign_id__schedules_patch
@@ -395,8 +470,10 @@ class TestAPI < Minitest::Test
 }')
         campaign_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.campaigns._(campaign_id).schedules.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_campaigns__campaign_id__schedules_post
@@ -405,29 +482,37 @@ class TestAPI < Minitest::Test
 }')
         campaign_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.campaigns._(campaign_id).schedules.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_campaigns__campaign_id__schedules_get
         campaign_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.campaigns._(campaign_id).schedules.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_campaigns__campaign_id__schedules_delete
         campaign_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.campaigns._(campaign_id).schedules.delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_campaigns__campaign_id__schedules_now_post
         campaign_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.campaigns._(campaign_id).schedules.now.post(request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_campaigns__campaign_id__schedules_test_post
@@ -436,44 +521,56 @@ class TestAPI < Minitest::Test
 }')
         campaign_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.campaigns._(campaign_id).schedules.test.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_categories_get
         params = JSON.parse('{"category": "test_string", "limit": 1, "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.categories.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_categories_stats_get
         params = JSON.parse('{"end_date": "2016-04-01", "aggregated_by": "day", "limit": 1, "offset": 1, "start_date": "2016-01-01", "categories": "test_string"}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.categories.stats.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_categories_stats_sums_get
         params = JSON.parse('{"end_date": "2016-04-01", "aggregated_by": "day", "limit": 1, "sort_by_metric": "test_string", "offset": 1, "start_date": "2016-01-01", "sort_by_direction": "asc"}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.categories.stats.sums.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_clients_stats_get
         params = JSON.parse('{"aggregated_by": "day", "start_date": "2016-01-01", "end_date": "2016-04-01"}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.clients.stats.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_clients__client_type__stats_get
         params = JSON.parse('{"aggregated_by": "day", "start_date": "2016-01-01", "end_date": "2016-04-01"}')
         client_type = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.clients._(client_type).stats.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_custom_fields_post
@@ -482,28 +579,36 @@ class TestAPI < Minitest::Test
   "type": "text"
 }')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.contactdb.custom_fields.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_contactdb_custom_fields_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.custom_fields.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_custom_fields__custom_field_id__get
         custom_field_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.custom_fields._(custom_field_id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_custom_fields__custom_field_id__delete
         custom_field_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 202}')
+
         response = @sg.client.contactdb.custom_fields._(custom_field_id).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "202")
+
+        self.assert_equal('202', response.status_code)
     end
 
     def test_contactdb_lists_post
@@ -511,14 +616,18 @@ class TestAPI < Minitest::Test
   "name": "your list name"
 }')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.contactdb.lists.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_contactdb_lists_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.lists.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_lists_delete
@@ -529,8 +638,10 @@ class TestAPI < Minitest::Test
   4
 ]')
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.contactdb.lists.delete(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_contactdb_lists__list_id__patch
@@ -540,24 +651,30 @@ class TestAPI < Minitest::Test
         params = JSON.parse('{"list_id": 1}')
         list_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.lists._(list_id).patch(request_body: data, query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_lists__list_id__get
         params = JSON.parse('{"list_id": 1}')
         list_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.lists._(list_id).get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_lists__list_id__delete
         params = JSON.parse('{"delete_contacts": "true"}')
         list_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 202}')
+
         response = @sg.client.contactdb.lists._(list_id).delete(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "202")
+
+        self.assert_equal('202', response.status_code)
     end
 
     def test_contactdb_lists__list_id__recipients_post
@@ -567,24 +684,30 @@ class TestAPI < Minitest::Test
 ]')
         list_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.contactdb.lists._(list_id).recipients.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_contactdb_lists__list_id__recipients_get
         params = JSON.parse('{"page": 1, "page_size": 1, "list_id": 1}')
         list_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.lists._(list_id).recipients.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_lists__list_id__recipients__recipient_id__post
         list_id = "test_url_param"
         recipient_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.contactdb.lists._(list_id).recipients._(recipient_id).post(request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_contactdb_lists__list_id__recipients__recipient_id__delete
@@ -592,8 +715,10 @@ class TestAPI < Minitest::Test
         list_id = "test_url_param"
         recipient_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.contactdb.lists._(list_id).recipients._(recipient_id).delete(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_contactdb_recipients_patch
@@ -605,8 +730,10 @@ class TestAPI < Minitest::Test
   }
 ]')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.contactdb.recipients.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_contactdb_recipients_post
@@ -625,15 +752,19 @@ class TestAPI < Minitest::Test
   }
 ]')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.contactdb.recipients.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_contactdb_recipients_get
         params = JSON.parse('{"page": 1, "page_size": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.recipients.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_recipients_delete
@@ -642,54 +773,70 @@ class TestAPI < Minitest::Test
   "recipient_id2"
 ]')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.recipients.delete(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_recipients_billable_count_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.recipients.billable_count.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_recipients_count_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.recipients.count.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_recipients_search_get
-        params = JSON.parse('{"{field_name}": "test_string"}')
+        params = { field_name: "test_string" }
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.recipients.search.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_recipients__recipient_id__get
         recipient_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.recipients._(recipient_id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_recipients__recipient_id__delete
         recipient_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.contactdb.recipients._(recipient_id).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_contactdb_recipients__recipient_id__lists_get
         recipient_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.recipients._(recipient_id).lists.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_reserved_fields_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.reserved_fields.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_segments_post
@@ -718,14 +865,18 @@ class TestAPI < Minitest::Test
   "name": "Last Name Miller"
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.segments.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_segments_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.segments.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_segments__segment_id__patch
@@ -744,59 +895,75 @@ class TestAPI < Minitest::Test
         params = JSON.parse('{"segment_id": "test_string"}')
         segment_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.segments._(segment_id).patch(request_body: data, query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_segments__segment_id__get
         params = JSON.parse('{"segment_id": 1}')
         segment_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.segments._(segment_id).get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_contactdb_segments__segment_id__delete
         params = JSON.parse('{"delete_contacts": "true"}')
         segment_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.contactdb.segments._(segment_id).delete(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_contactdb_segments__segment_id__recipients_get
         params = JSON.parse('{"page": 1, "page_size": 1}')
         segment_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.contactdb.segments._(segment_id).recipients.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_devices_stats_get
         params = JSON.parse('{"aggregated_by": "day", "limit": 1, "start_date": "2016-01-01", "end_date": "2016-04-01", "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.devices.stats.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_geo_stats_get
         params = JSON.parse('{"end_date": "2016-04-01", "country": "US", "aggregated_by": "day", "limit": 1, "offset": 1, "start_date": "2016-01-01"}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.geo.stats.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_ips_get
         params = JSON.parse('{"subuser": "test_string", "ip": "test_string", "limit": 1, "exclude_whitelabels": "true", "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.ips.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_ips_assigned_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.ips.assigned.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_ips_pools_post
@@ -804,14 +971,18 @@ class TestAPI < Minitest::Test
   "name": "marketing"
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.ips.pools.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_ips_pools_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.ips.pools.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_ips_pools__pool_name__put
@@ -820,22 +991,28 @@ class TestAPI < Minitest::Test
 }')
         pool_name = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.ips.pools._(pool_name).put(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_ips_pools__pool_name__get
         pool_name = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.ips.pools._(pool_name).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_ips_pools__pool_name__delete
         pool_name = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.ips.pools._(pool_name).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_ips_pools__pool_name__ips_post
@@ -844,16 +1021,20 @@ class TestAPI < Minitest::Test
 }')
         pool_name = "test_url_param"
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.ips.pools._(pool_name).ips.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_ips_pools__pool_name__ips__ip__delete
         pool_name = "test_url_param"
         ip = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.ips.pools._(pool_name).ips._(ip).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_ips_warmup_post
@@ -861,48 +1042,62 @@ class TestAPI < Minitest::Test
   "ip": "0.0.0.0"
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.ips.warmup.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_ips_warmup_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.ips.warmup.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_ips_warmup__ip_address__get
         ip_address = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.ips.warmup._(ip_address).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_ips_warmup__ip_address__delete
         ip_address = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.ips.warmup._(ip_address).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_ips__ip_address__get
         ip_address = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.ips._(ip_address).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_batch_post
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.mail.batch.post(request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_mail_batch__batch_id__get
         batch_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail.batch._(batch_id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_send_post
@@ -1045,15 +1240,19 @@ class TestAPI < Minitest::Test
   }
 }')
         headers = JSON.parse('{"X-Mock": 202}')
+
         response = @sg.client.mail._("send").post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "202")
+
+        self.assert_equal('202', response.status_code)
     end
 
     def test_mail_settings_get
         params = JSON.parse('{"limit": 1, "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_address_whitelist_patch
@@ -1065,14 +1264,18 @@ class TestAPI < Minitest::Test
   ]
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.address_whitelist.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_address_whitelist_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.address_whitelist.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_bcc_patch
@@ -1081,14 +1284,18 @@ class TestAPI < Minitest::Test
   "enabled": false
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.bcc.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_bcc_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.bcc.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_bounce_purge_patch
@@ -1098,14 +1305,18 @@ class TestAPI < Minitest::Test
   "soft_bounces": 5
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.bounce_purge.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_bounce_purge_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.bounce_purge.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_footer_patch
@@ -1115,14 +1326,18 @@ class TestAPI < Minitest::Test
   "plain_content": "..."
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.footer.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_footer_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.footer.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_forward_bounce_patch
@@ -1131,14 +1346,18 @@ class TestAPI < Minitest::Test
   "enabled": true
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.forward_bounce.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_forward_bounce_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.forward_bounce.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_forward_spam_patch
@@ -1147,14 +1366,18 @@ class TestAPI < Minitest::Test
   "enabled": false
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.forward_spam.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_forward_spam_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.forward_spam.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_plain_content_patch
@@ -1162,14 +1385,18 @@ class TestAPI < Minitest::Test
   "enabled": false
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.plain_content.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_plain_content_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.plain_content.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_spam_check_patch
@@ -1179,14 +1406,18 @@ class TestAPI < Minitest::Test
   "url": "url"
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.spam_check.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_spam_check_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.spam_check.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_template_patch
@@ -1195,28 +1426,36 @@ class TestAPI < Minitest::Test
   "html_content": "<% body %>"
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.template.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mail_settings_template_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mail_settings.template.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_mailbox_providers_stats_get
         params = JSON.parse('{"end_date": "2016-04-01", "mailbox_providers": "test_string", "aggregated_by": "day", "limit": 1, "offset": 1, "start_date": "2016-01-01"}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.mailbox_providers.stats.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_partner_settings_get
         params = JSON.parse('{"limit": 1, "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.partner_settings.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_partner_settings_new_relic_patch
@@ -1226,20 +1465,26 @@ class TestAPI < Minitest::Test
   "license_key": ""
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.partner_settings.new_relic.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_partner_settings_new_relic_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.partner_settings.new_relic.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_scopes_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.scopes.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_senders_post
@@ -1319,8 +1564,10 @@ class TestAPI < Minitest::Test
     def test_stats_get
         params = JSON.parse('{"aggregated_by": "day", "limit": 1, "start_date": "2016-01-01", "end_date": "2016-04-01", "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.stats.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_subusers_post
@@ -1334,43 +1581,55 @@ class TestAPI < Minitest::Test
   "username": "John@example.com"
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.subusers.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_subusers_get
         params = JSON.parse('{"username": "test_string", "limit": 1, "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.subusers.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_subusers_reputations_get
         params = JSON.parse('{"usernames": "test_string"}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.subusers.reputations.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_subusers_stats_get
         params = JSON.parse('{"end_date": "2016-04-01", "aggregated_by": "day", "limit": 1, "offset": 1, "start_date": "2016-01-01", "subusers": "test_string"}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.subusers.stats.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_subusers_stats_monthly_get
         params = JSON.parse('{"subuser": "test_string", "limit": 1, "sort_by_metric": "test_string", "offset": 1, "date": "test_string", "sort_by_direction": "asc"}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.subusers.stats.monthly.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_subusers_stats_sums_get
         params = JSON.parse('{"end_date": "2016-04-01", "aggregated_by": "day", "limit": 1, "sort_by_metric": "test_string", "offset": 1, "start_date": "2016-01-01", "sort_by_direction": "asc"}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.subusers.stats.sums.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_subusers__subuser_name__patch
@@ -1379,15 +1638,19 @@ class TestAPI < Minitest::Test
 }')
         subuser_name = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.subusers._(subuser_name).patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_subusers__subuser_name__delete
         subuser_name = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.subusers._(subuser_name).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_subusers__subuser_name__ips_put
@@ -1396,8 +1659,10 @@ class TestAPI < Minitest::Test
 ]')
         subuser_name = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.subusers._(subuser_name).ips.put(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_subusers__subuser_name__monitor_put
@@ -1407,8 +1672,10 @@ class TestAPI < Minitest::Test
 }')
         subuser_name = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.subusers._(subuser_name).monitor.put(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_subusers__subuser_name__monitor_post
@@ -1418,37 +1685,47 @@ class TestAPI < Minitest::Test
 }')
         subuser_name = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.subusers._(subuser_name).monitor.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_subusers__subuser_name__monitor_get
         subuser_name = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.subusers._(subuser_name).monitor.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_subusers__subuser_name__monitor_delete
         subuser_name = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.subusers._(subuser_name).monitor.delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_subusers__subuser_name__stats_monthly_get
         params = JSON.parse('{"date": "test_string", "sort_by_direction": "asc", "limit": 1, "sort_by_metric": "test_string", "offset": 1}')
         subuser_name = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.subusers._(subuser_name).stats.monthly.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_suppression_blocks_get
         params = JSON.parse('{"start_time": 1, "limit": 1, "end_time": 1, "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.suppression.blocks.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_suppression_blocks_delete
@@ -1460,29 +1737,37 @@ class TestAPI < Minitest::Test
   ]
 }')
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.suppression.blocks.delete(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_suppression_blocks__email__get
         email = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.suppression.blocks._(email).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_suppression_blocks__email__delete
         email = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.suppression.blocks._(email).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_suppression_bounces_get
         params = JSON.parse('{"start_time": 1, "end_time": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.suppression.bounces.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_suppression_bounces_delete
@@ -1494,30 +1779,38 @@ class TestAPI < Minitest::Test
   ]
 }')
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.suppression.bounces.delete(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_suppression_bounces__email__get
         email = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.suppression.bounces._(email).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_suppression_bounces__email__delete
         params = JSON.parse('{"email_address": "example@example.com"}')
         email = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.suppression.bounces._(email).delete(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_suppression_invalid_emails_get
         params = JSON.parse('{"start_time": 1, "limit": 1, "end_time": 1, "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.suppression.invalid_emails.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_suppression_invalid_emails_delete
@@ -1529,43 +1822,55 @@ class TestAPI < Minitest::Test
   ]
 }')
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.suppression.invalid_emails.delete(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_suppression_invalid_emails__email__get
         email = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.suppression.invalid_emails._(email).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_suppression_invalid_emails__email__delete
         email = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.suppression.invalid_emails._(email).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_suppression_spam_report__email__get
         email = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.suppression.spam_report._(email).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_suppression_spam_report__email__delete
         email = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.suppression.spam_report._(email).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_suppression_spam_reports_get
         params = JSON.parse('{"start_time": 1, "limit": 1, "end_time": 1, "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.suppression.spam_reports.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_suppression_spam_reports_delete
@@ -1577,15 +1882,19 @@ class TestAPI < Minitest::Test
   ]
 }')
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.suppression.spam_reports.delete(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_suppression_unsubscribes_get
         params = JSON.parse('{"start_time": 1, "limit": 1, "end_time": 1, "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.suppression.unsubscribes.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_templates_post
@@ -1593,14 +1902,18 @@ class TestAPI < Minitest::Test
   "name": "example_name"
 }')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.templates.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_templates_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.templates.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_templates__template_id__patch
@@ -1609,22 +1922,28 @@ class TestAPI < Minitest::Test
 }')
         template_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.templates._(template_id).patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_templates__template_id__get
         template_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.templates._(template_id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_templates__template_id__delete
         template_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.templates._(template_id).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_templates__template_id__versions_post
@@ -1638,8 +1957,10 @@ class TestAPI < Minitest::Test
 }')
         template_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.templates._(template_id).versions.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_templates__template_id__versions__version_id__patch
@@ -1653,39 +1974,49 @@ class TestAPI < Minitest::Test
         template_id = "test_url_param"
         version_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.templates._(template_id).versions._(version_id).patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_templates__template_id__versions__version_id__get
         template_id = "test_url_param"
         version_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.templates._(template_id).versions._(version_id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_templates__template_id__versions__version_id__delete
         template_id = "test_url_param"
         version_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.templates._(template_id).versions._(version_id).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_templates__template_id__versions__version_id__activate_post
         template_id = "test_url_param"
         version_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.templates._(template_id).versions._(version_id).activate.post(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_tracking_settings_get
         params = JSON.parse('{"limit": 1, "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.tracking_settings.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_tracking_settings_click_patch
@@ -1693,14 +2024,18 @@ class TestAPI < Minitest::Test
   "enabled": true
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.tracking_settings.click.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_tracking_settings_click_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.tracking_settings.click.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_tracking_settings_google_analytics_patch
@@ -1713,14 +2048,18 @@ class TestAPI < Minitest::Test
   "utm_term": ""
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.tracking_settings.google_analytics.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_tracking_settings_google_analytics_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.tracking_settings.google_analytics.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_tracking_settings_open_patch
@@ -1728,14 +2067,18 @@ class TestAPI < Minitest::Test
   "enabled": true
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.tracking_settings.open.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_tracking_settings_open_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.tracking_settings.open.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_tracking_settings_subscription_patch
@@ -1748,26 +2091,34 @@ class TestAPI < Minitest::Test
   "url": "url"
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.tracking_settings.subscription.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_tracking_settings_subscription_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.tracking_settings.subscription.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_account_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.account.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_credits_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.credits.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_email_put
@@ -1775,14 +2126,18 @@ class TestAPI < Minitest::Test
   "email": "example@example.com"
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.email.put(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_email_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.email.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_password_put
@@ -1791,8 +2146,10 @@ class TestAPI < Minitest::Test
   "old_password": "old_password"
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.password.put(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_profile_patch
@@ -1802,14 +2159,18 @@ class TestAPI < Minitest::Test
   "last_name": "User"
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.profile.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_profile_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.profile.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_scheduled_sends_post
@@ -1818,14 +2179,18 @@ class TestAPI < Minitest::Test
   "status": "pause"
 }')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.user.scheduled_sends.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_user_scheduled_sends_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.scheduled_sends.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_scheduled_sends__batch_id__patch
@@ -1834,22 +2199,28 @@ class TestAPI < Minitest::Test
 }')
         batch_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.user.scheduled_sends._(batch_id).patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_user_scheduled_sends__batch_id__get
         batch_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.scheduled_sends._(batch_id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_scheduled_sends__batch_id__delete
         batch_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.user.scheduled_sends._(batch_id).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_user_settings_enforced_tls_patch
@@ -1858,14 +2229,18 @@ class TestAPI < Minitest::Test
   "require_valid_cert": false
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.settings.enforced_tls.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_settings_enforced_tls_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.settings.enforced_tls.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_username_put
@@ -1873,14 +2248,18 @@ class TestAPI < Minitest::Test
   "username": "test_username"
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.username.put(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_username_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.username.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_webhooks_event_settings_patch
@@ -1900,14 +2279,18 @@ class TestAPI < Minitest::Test
   "url": "url"
 }')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.webhooks.event.settings.patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_webhooks_event_settings_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.webhooks.event.settings.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_webhooks_event_test_post
@@ -1915,8 +2298,10 @@ class TestAPI < Minitest::Test
   "url": "url"
 }')
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.user.webhooks.event.test.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_user_webhooks_parse_settings_post
@@ -1927,14 +2312,18 @@ class TestAPI < Minitest::Test
   "url": "http://email.myhosthame.com"
 }')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.user.webhooks.parse.settings.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_user_webhooks_parse_settings_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.webhooks.parse.settings.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_webhooks_parse_settings__hostname__patch
@@ -1945,29 +2334,37 @@ class TestAPI < Minitest::Test
 }')
         hostname = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.webhooks.parse.settings._(hostname).patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_webhooks_parse_settings__hostname__get
         hostname = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.webhooks.parse.settings._(hostname).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_user_webhooks_parse_settings__hostname__delete
         hostname = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.user.webhooks.parse.settings._(hostname).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_user_webhooks_parse_stats_get
         params = JSON.parse('{"aggregated_by": "day", "limit": "test_string", "start_date": "2016-01-01", "end_date": "2016-04-01", "offset": "test_string"}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.user.webhooks.parse.stats.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_domains_post
@@ -1984,33 +2381,43 @@ class TestAPI < Minitest::Test
   "username": "john@example.com"
 }')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.whitelabel.domains.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_whitelabel_domains_get
         params = JSON.parse('{"username": "test_string", "domain": "test_string", "exclude_subusers": "true", "limit": 1, "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.domains.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_domains_default_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.domains.default.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_domains_subuser_get
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.domains.subuser.get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_domains_subuser_delete
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.whitelabel.domains.subuser.delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_whitelabel_domains__domain_id__patch
@@ -2020,22 +2427,28 @@ class TestAPI < Minitest::Test
 }')
         domain_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.domains._(domain_id).patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_domains__domain_id__get
         domain_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.domains._(domain_id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_domains__domain_id__delete
         domain_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.whitelabel.domains._(domain_id).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_whitelabel_domains__domain_id__subuser_post
@@ -2044,8 +2457,10 @@ class TestAPI < Minitest::Test
 }')
         domain_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.whitelabel.domains._(domain_id).subuser.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_whitelabel_domains__id__ips_post
@@ -2054,23 +2469,29 @@ class TestAPI < Minitest::Test
 }')
         id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.domains._(id).ips.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_domains__id__ips__ip__delete
         id = "test_url_param"
         ip = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.domains._(id).ips._(ip).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_domains__id__validate_post
         id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.domains._(id).validate.post(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_ips_post
@@ -2080,36 +2501,46 @@ class TestAPI < Minitest::Test
   "subdomain": "email"
 }')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.whitelabel.ips.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_whitelabel_ips_get
         params = JSON.parse('{"ip": "test_string", "limit": 1, "offset": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.ips.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_ips__id__get
         id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.ips._(id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_ips__id__delete
         id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.whitelabel.ips._(id).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_whitelabel_ips__id__validate_post
         id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.ips._(id).validate.post(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_links_post
@@ -2120,36 +2551,46 @@ class TestAPI < Minitest::Test
 }')
         params = JSON.parse('{"limit": 1, "offset": 1}')
         headers = JSON.parse('{"X-Mock": 201}')
+
         response = @sg.client.whitelabel.links.post(request_body: data, query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "201")
+
+        self.assert_equal('201', response.status_code)
     end
 
     def test_whitelabel_links_get
         params = JSON.parse('{"limit": 1}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.links.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_links_default_get
         params = JSON.parse('{"domain": "test_string"}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.links.default.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_links_subuser_get
         params = JSON.parse('{"username": "test_string"}')
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.links.subuser.get(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_links_subuser_delete
         params = JSON.parse('{"username": "test_string"}')
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.whitelabel.links.subuser.delete(query_params: params, request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_whitelabel_links__id__patch
@@ -2158,29 +2599,37 @@ class TestAPI < Minitest::Test
 }')
         id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.links._(id).patch(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_links__id__get
         id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.links._(id).get(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_links__id__delete
         id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 204}')
+
         response = @sg.client.whitelabel.links._(id).delete(request_headers: headers)
-        self.assert_equal(response.status_code, "204")
+
+        self.assert_equal('204', response.status_code)
     end
 
     def test_whitelabel_links__id__validate_post
         id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.links._(id).validate.post(request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 
     def test_whitelabel_links__link_id__subuser_post
@@ -2189,7 +2638,9 @@ class TestAPI < Minitest::Test
 }')
         link_id = "test_url_param"
         headers = JSON.parse('{"X-Mock": 200}')
+
         response = @sg.client.whitelabel.links._(link_id).subuser.post(request_body: data, request_headers: headers)
-        self.assert_equal(response.status_code, "200")
+
+        self.assert_equal('200', response.status_code)
     end
 end