RubyGems - sendgrid-ruby - Versions diffs - 4.0.3 → 4.0.4 - Mend

sendgrid-ruby 4.0.3 → 4.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +5 -0
data/CONTRIBUTING.md +28 -7
data/Gemfile +1 -1
data/README.md +33 -1
data/USE_CASES.md +113 -0
data/examples/helpers/mail/example.rb +2 -2
data/lib/sendgrid/version.rb +1 -1
data/sendgrid-ruby.gemspec +1 -1
data/test/sendgrid/test_sendgrid-ruby.rb +679 -228
metadata +18 -3

checksums.yaml CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

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

data/README.md CHANGED

@@ -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 ADDED

@@ -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 CHANGED

@@ -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 CHANGED

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

data/sendgrid-ruby.gemspec CHANGED

@@ -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 CHANGED

@@ -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