postmark 1.21.5 → 1.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f37af7becb4542a52b09dac6ddbf4f8dd9a0e8865f58c09d09d589a4df99d52
-  data.tar.gz: b1f0853ddb0d5df6ed028b73f838cc23ed4438955280c3374b94bb4d4dd1d002
+  metadata.gz: b214577bda32a36ea3de8910d8ef1bf7929e090e513a30d32ae891219134234b
+  data.tar.gz: 7379520e17f6e9afda7e7157e4e118ccd1b171298e211555e112e5963433880c
 SHA512:
-  metadata.gz: 5fff0cb52f3fa2368e7e930b480cc020a5f7783c5b946be06b39537f4c4673c191b7861083ddadfdbed395767377ad885c8ef218f8af6801cb3d9e84fdf94826
-  data.tar.gz: e649bf1192c4669f22622427cf986f6b53369f0a0c1c0bf3e97b6e782b6c4400d53b2d2e06f87cf2c24d853317c601c8b72c3a607f6b23ac7142fa517c566799
+  metadata.gz: 9bf13b2db7d0818a8f69286b4ece4ad1675b8e546a9677f23f9827915c80795b5118a16a9a32860dfab3b35b5b694791ef3e48bc8d2eca13dd05228fe634f3a2
+  data.tar.gz: a4ce846c304fea9a62ffd3bcc4802675a435009b6536741ad3b32c9dd98780925f57d0e32fa1c40c1d45c0b8ca5096d626140c4fd78268a072231a7fc4dc4fdc

data/.ruby-gemset

@@ -0,0 +1 @@
+postmark-gem

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.6

data/CHANGELOG.rdoc

@@ -1,5 +1,21 @@
 = Changelog
 
+== 1.22.0
+
+* Disabled automatic retries of failed requests by default. You can enabled it by passing `max_retries` option to the client constructor.
+
+== 1.21.8
+
+* Fixed passing and receiving SubscriptionManagementConfiguration when creating/updating message streams (#94).
+
+== 1.21.7
+
+* Improved parsing recipients with Postmark::InactiveRecipientError.parse_recipients method
+
+== 1.21.6
+
+* Improved error handling for email sending related to invalid email addresses
+
 == 1.21.5
 
 * Added support for archiving/unarchiving message streams

data/RELEASE.md

@@ -1,5 +1,6 @@
 New versions of the gem are cut by the Postmark team, this is a quick guide to ensuring a smooth release.
 
+1. Determine the next version of the gem by following the [SemVer](https://semver.org/) guidelines.
 1. Verify all builds are passing on CircleCI for your branch.
 1. Merge in your branch to master.
 1. Update VERSION and lib/postmark/version.rb with the new version.

data/VERSION

@@ -1 +1 @@
-1.21.4
+1.22.0

data/lib/postmark/api_client.rb

@@ -38,7 +38,7 @@ module Postmark
         response, error = take_response_of { http_client.post("email", data) }
         update_message(message, response)
         raise error if error
-        format_response(response, true)
+        format_response(response, :compatible => true)
       end
     end
 
@@ -51,7 +51,7 @@ module Postmark
         response, error = take_response_of { http_client.post("email/withTemplate", data) }
         update_message(message, response)
         raise error if error
-        format_response(response, true)
+        format_response(response, :compatible => true)
       end
     end
 
@@ -95,7 +95,7 @@ module Postmark
     end
 
     def delivery_stats
-      response = format_response(http_client.get("deliverystats"), true)
+      response = format_response(http_client.get("deliverystats"), :compatible => true)
 
       if response[:bounces]
         response[:bounces] = format_response(response[:bounces])
@@ -343,13 +343,13 @@ module Postmark
     end
 
     def create_message_stream(attributes = {})
-      data = serialize(HashHelper.to_postmark(attributes))
-      format_response(http_client.post('message-streams', data))
+      data = serialize(HashHelper.to_postmark(attributes, :deep => true))
+      format_response(http_client.post('message-streams', data), :deep => true)
     end
 
     def update_message_stream(id, attributes)
-      data = serialize(HashHelper.to_postmark(attributes))
-      format_response(http_client.patch("message-streams/#{id}", data))
+      data = serialize(HashHelper.to_postmark(attributes, :deep => true))
+      format_response(http_client.patch("message-streams/#{id}", data), :deep => true)
     end
 
     def archive_message_stream(id)

data/lib/postmark/client.rb

@@ -6,7 +6,7 @@ module Postmark
 
     def initialize(api_token, options = {})
       options = options.dup
-      @max_retries = options.delete(:max_retries) || 3
+      @max_retries = options.delete(:max_retries) || 0
       @http_client = HttpClient.new(api_token, options)
     end
 
@@ -60,13 +60,16 @@ module Postmark
       [e.full_response || {}, e]
     end
 
-    def format_response(response, compatible = false)
+    def format_response(response, options = {})
       return {} unless response
 
+      compatible = options.fetch(:compatible, false)
+      deep = options.fetch(:deep, false)
+
       if response.kind_of? Array
-        response.map { |entry| Postmark::HashHelper.to_ruby(entry, compatible) }
+        response.map { |entry| Postmark::HashHelper.to_ruby(entry, :compatible => compatible, :deep => deep) }
       else
-        Postmark::HashHelper.to_ruby(response, compatible)
+        Postmark::HashHelper.to_ruby(response, :compatible => compatible, :deep => deep)
       end
     end
 

data/lib/postmark/error.rb

@@ -30,9 +30,8 @@ module Postmark
     def initialize(status_code = 500, body = '', parsed_body = {})
       self.parsed_body = parsed_body
       self.status_code = status_code.to_i
-      message = parsed_body.fetch(
-        'Message',
-        "The Postmark API responded with HTTP status #{status_code}.")
+      self.body = body
+      message = parsed_body.fetch('Message', "The Postmark API responded with HTTP status #{status_code}.")
 
       super(message)
     end
@@ -44,6 +43,7 @@ module Postmark
 
   class ApiInputError < HttpServerError
     INACTIVE_RECIPIENT = 406
+    INVALID_EMAIL_ADDRESS = 300
 
     attr_accessor :error_code
 
@@ -52,7 +52,9 @@ module Postmark
 
       case error_code
       when INACTIVE_RECIPIENT
-        InactiveRecipientError.new(INACTIVE_RECIPIENT, body, parsed_body)
+        InactiveRecipientError.new(error_code, body, parsed_body)
+      when INVALID_EMAIL_ADDRESS
+        InvalidEmailAddressError.new(error_code, body, parsed_body)
       else
         new(error_code, body, parsed_body)
       end
@@ -68,12 +70,14 @@ module Postmark
     end
   end
 
+  class InvalidEmailAddressError < ApiInputError; end
+
   class InactiveRecipientError < ApiInputError
     attr_reader :recipients
 
     PATTERNS = [/^Found inactive addresses: (.+?)\.$/.freeze,
-                /^Found inactive addresses: (.+?)\.$/.freeze,
-                /these inactive addresses: (.+?)\. Inactive/.freeze].freeze
+                /these inactive addresses: (.+?)\. Inactive/.freeze,
+                /these inactive addresses: (.+?)\.?$/].freeze
 
     def self.parse_recipients(message)
       PATTERNS.each do |p|

data/lib/postmark/helpers/hash_helper.rb

@@ -3,22 +3,47 @@ module Postmark
 
     extend self
 
-    def to_postmark(hash)
-      hash.inject({}) { |m, (k,v)| m[Inflector.to_postmark(k)] = v; m }
+    def to_postmark(object, options = {})
+      deep = options.fetch(:deep, false)
+
+      case object
+      when Hash
+        object.reduce({}) do |m, (k, v)|
+          m.tap do |h|
+            h[Inflector.to_postmark(k)] = deep ? to_postmark(v, options) : v
+          end
+        end
+      when Array
+        deep ? object.map { |v| to_postmark(v, options) } : object
+      else
+        object
+      end
     end
 
-    def to_ruby(hash, compatible = false)
-      formatted = hash.inject({}) { |m, (k,v)| m[Inflector.to_ruby(k)] = v; m }
-
-      if compatible
-        formatted.merge!(hash)
-        enhance_with_compatibility_warning(formatted)
+    def to_ruby(object, options = {})
+      compatible = options.fetch(:compatible, false)
+      deep = options.fetch(:deep, false)
+
+      case object
+      when Hash
+        object.reduce({}) do |m, (k, v)|
+          m.tap do |h|
+            h[Inflector.to_ruby(k)] = deep ? to_ruby(v, options) : v
+          end
+        end.tap do |result|
+          if compatible
+            result.merge!(object)
+            enhance_with_compatibility_warning(result)
+          end
+        end
+      when Array
+        deep ? object.map { |v| to_ruby(v, options) } : object
+      else
+        object
       end
-
-      formatted
     end
 
-    protected
+    private
 
     def enhance_with_compatibility_warning(hash)
       def hash.[](key)

data/lib/postmark/version.rb

@@ -1,3 +1,3 @@
 module Postmark
-  VERSION = '1.21.5'
+  VERSION = '1.22.0'
 end

data/spec/unit/postmark/api_client_spec.rb

@@ -1,15 +1,15 @@
 require 'spec_helper'
 
 describe Postmark::ApiClient do
+  let(:api_client) {Postmark::ApiClient.new(api_token)}
   let(:api_token) {"provided-api-token"}
-  let(:max_retries) {42}
   let(:message_hash) {{:from => "support@postmarkapp.com"}}
-  let(:message) {
+  let(:message) do
     Mail.new do
       from "support@postmarkapp.com"
       delivery_method Mail::Postmark
     end
-  }
+  end
   let(:templated_message) do
     Mail.new do
       from            "sheldon@bigbangtheory.com"
@@ -20,28 +20,68 @@ describe Postmark::ApiClient do
   end
   let(:http_client) {api_client.http_client}
 
-  subject(:api_client) {Postmark::ApiClient.new(api_token)}
+  shared_examples "retryable" do |response|
+    let(:api_client) do
+      Postmark::ApiClient.new(
+        api_token,
+        max_retries.nil? ? {} : {:max_retries => max_retries}
+      )
+    end
+    let(:max_retries) {nil}
+
+    context 'with no retries' do
+      let(:max_retries) {nil}
+
+      it "doesn't retry failed requests" do
+        expect(http_client).to receive(:post).once.and_raise(Postmark::InternalServerError)
+        expect {subject}.to raise_error(Postmark::InternalServerError)
+      end
+    end
+
+    context 'with 3 retries' do
+      let(:max_retries) {3}
+
+      it 'retries 3 times' do
+        expect(http_client).to receive(:post).twice.and_raise(Postmark::InternalServerError)
+        expect(http_client).to receive(:post).and_return(response)
+        expect {subject}.not_to raise_error
+      end
+
+      it 'gives up after 3 retries' do
+        expect(http_client).to receive(:post).thrice.and_raise(Postmark::InternalServerError)
+        expect {subject}.to raise_error(Postmark::InternalServerError)
+      end
+
+      it "retries on timeout" do
+        expect(http_client).to receive(:post).and_raise(Postmark::TimeoutError)
+        expect(http_client).to receive(:post).and_return(response)
+        expect {subject}.not_to raise_error
+      end
+    end
+  end
 
-  context "attr readers" do
-    it { expect(subject).to respond_to(:http_client) }
-    it { expect(subject).to respond_to(:max_retries) }
+  describe "attr readers" do
+    it { expect(api_client).to respond_to(:http_client) }
+    it { expect(api_client).to respond_to(:max_retries) }
   end
 
   context "when it's created without options" do
-    it "max retries" do
-      expect(subject.max_retries).to eq 3
-    end
+    let(:api_client) {Postmark::ApiClient.new(api_token)}
+
+    specify { expect(api_client.max_retries).to eq 0 }
   end
 
   context "when it's created with user options" do
-    subject {Postmark::ApiClient.new(api_token, :max_retries => max_retries, :foo => :bar)}
-    it "max_retries" do
-      expect(subject.max_retries).to eq max_retries
+    let(:api_client) {Postmark::ApiClient.new(api_token, options)}
+    let(:options) { {:max_retries => 42, :foo => :bar} }
+
+    it "sets max_retries" do
+      expect(api_client.max_retries).to eq 42
     end
 
     it 'passes other options to HttpClient instance' do
-      allow(Postmark::HttpClient).to receive(:new).with(api_token, :foo => :bar)
-      expect(subject).to be
+      expect(Postmark::HttpClient).to receive(:new).with(api_token, :foo => :bar)
+      api_client
     end
   end
 
@@ -49,185 +89,159 @@ describe Postmark::ApiClient do
     let(:api_token) {"new-api-token-value"}
 
     it 'assigns the api token to the http client instance' do
-      subject.api_token = api_token
-      expect(subject.http_client.api_token).to eq api_token
+      api_client.api_token = api_token
+      expect(api_client.http_client.api_token).to eq api_token
     end
 
     it 'is aliased as api_key=' do
-      subject.api_key = api_token
-      expect(subject.http_client.api_token).to eq api_token
+      api_client.api_key = api_token
+      expect(api_client.http_client.api_token).to eq api_token
     end
   end
 
   describe "#deliver" do
+    subject {api_client.deliver(message_hash)}
+
     let(:email) {Postmark::MessageHelper.to_postmark(message_hash)}
     let(:email_json) {Postmark::Json.encode(email)}
     let(:response) {{"MessageID" => 42}}
 
-    it 'converts message hash to Postmark format and posts it to /email' do
-      allow(http_client).to receive(:post).with('email', email_json) {response}
-      subject.deliver(message_hash)
-    end
-
-    it 'retries 3 times' do
-      expect(http_client).to receive(:post).twice.and_raise(Postmark::InternalServerError)
-      expect(http_client).to receive(:post) {response}
-      expect {subject.deliver(message_hash)}.not_to raise_error
+    it 'converts message hash to Postmark format and posts it to expected enpoint' do
+      expect(http_client).to receive(:post).with('email', email_json) {response}
+      subject
     end
 
     it 'converts response to ruby format' do
       expect(http_client).to receive(:post).with('email', email_json) {response}
-      expect(subject.deliver(message_hash)).to have_key(:message_id)
+      expect(subject).to have_key(:message_id)
     end
+
+    it_should_behave_like "retryable"
   end
 
   describe "#deliver_in_batches" do
+    subject {api_client.deliver_in_batches([message_hash, message_hash, message_hash])}
+
     let(:email) {Postmark::MessageHelper.to_postmark(message_hash)}
     let(:emails) {[email, email, email]}
     let(:emails_json) {Postmark::Json.encode(emails)}
     let(:response) {[{'ErrorCode' => 0}, {'ErrorCode' => 0}, {'ErrorCode' => 0}]}
 
-    it 'turns array of messages into a JSON document and posts it to /email/batch' do
+    it 'turns array of messages into a JSON document and posts it to expected endpoint' do
       expect(http_client).to receive(:post).with('email/batch', emails_json) {response}
-      subject.deliver_in_batches([message_hash, message_hash, message_hash])
+      subject
     end
 
     it 'converts response to ruby format' do
       expect(http_client).to receive(:post).with('email/batch', emails_json) {response}
-      response = subject.deliver_in_batches([message_hash, message_hash, message_hash])
+      response = subject
       expect(response.first).to have_key(:error_code)
     end
+
+    it_should_behave_like "retryable"
   end
 
   describe "#deliver_message" do
+    subject {api_client.deliver_message(message)}
+
     let(:email) {message.to_postmark_hash}
     let(:email_json) {Postmark::Json.encode(email)}
 
-    it 'raises an error when given a templated message' do
-      expect { subject.deliver_message(templated_message) }.
-        to raise_error(ArgumentError, /Please use Postmark::ApiClient\#deliver_message_with_template/)
-    end
+    context 'when given a templated message' do
+      let(:message) {templated_message}
 
-    it 'turns message into a JSON document and posts it to /email' do
-      expect(http_client).to receive(:post).with('email', email_json)
-      subject.deliver_message(message)
-    end
-
-    it "retries 3 times" do
-      2.times do
-        expect(http_client).to receive(:post).and_raise(Postmark::InternalServerError)
+      specify do
+        expect { subject }.to raise_error(ArgumentError, /Please use Postmark::ApiClient\#deliver_message_with_template/)
       end
-      expect(http_client).to receive(:post)
-      expect {subject.deliver_message(message)}.not_to raise_error
     end
 
-    it "retries on timeout" do
-      expect(http_client).to receive(:post).and_raise(Postmark::TimeoutError)
-      expect(http_client).to receive(:post)
-      expect {subject.deliver_message(message)}.not_to raise_error
+    it 'turns message into a JSON document and posts it to /email' do
+      expect(http_client).to receive(:post).with('email', email_json)
+      subject
     end
 
     it "proxies errors" do
       allow(http_client).to receive(:post).and_raise(Postmark::TimeoutError)
-      expect {subject.deliver_message(message)}.to raise_error(Postmark::TimeoutError)
+      expect {subject}.to raise_error(Postmark::TimeoutError)
     end
+
+    it_should_behave_like "retryable"
   end
 
   describe "#deliver_message_with_template" do
+    subject {api_client.deliver_message_with_template(templated_message)}
+
     let(:email) {templated_message.to_postmark_hash}
     let(:email_json) {Postmark::Json.encode(email)}
 
-    it 'raises an error when given a non-templated message' do
-      expect { subject.deliver_message_with_template(message) }.
-        to raise_error(ArgumentError, 'Templated delivery requested, but the template is missing.')
-    end
+    context 'when given a non-templated message' do
+      let(:templated_message) {message}
 
-    it 'turns message into a JSON document and posts it to /email' do
-      expect(http_client).to receive(:post).with('email/withTemplate', email_json)
-      subject.deliver_message_with_template(templated_message)
-    end
-
-    it "retries 3 times" do
-      2.times do
-        expect(http_client).to receive(:post).and_raise(Postmark::InternalServerError)
+      specify do
+        expect { subject }.to raise_error(ArgumentError, 'Templated delivery requested, but the template is missing.')
       end
-      expect(http_client).to receive(:post)
-      expect {subject.deliver_message_with_template(templated_message)}.not_to raise_error
     end
 
-    it "retries on timeout" do
-      expect(http_client).to receive(:post).and_raise(Postmark::TimeoutError)
-      expect(http_client).to receive(:post)
-      expect {subject.deliver_message_with_template(templated_message)}.not_to raise_error
+    it 'turns message into a JSON document and posts it to expected endpoint' do
+      expect(http_client).to receive(:post).with('email/withTemplate', email_json)
+      subject
     end
 
     it "proxies errors" do
       allow(http_client).to receive(:post).and_raise(Postmark::TimeoutError)
-      expect {subject.deliver_message_with_template(templated_message)}.to raise_error(Postmark::TimeoutError)
+      expect {subject}.to raise_error(Postmark::TimeoutError)
     end
+
+    it_should_behave_like "retryable"
   end
 
   describe "#deliver_messages" do
+    subject {api_client.deliver_messages(messages)}
+
+    let(:messages) {[message, message, message]}
     let(:email) {message.to_postmark_hash}
-    let(:emails) {[email, email, email]}
-    let(:emails_json) {Postmark::Json.encode(emails)}
+    let(:emails_json) {Postmark::Json.encode(Array.new(3) { email })}
     let(:response) {[{}, {}, {}]}
 
-    it 'raises an error when given a templated message' do
-      expect { subject.deliver_messages([templated_message]) }.
-        to raise_error(ArgumentError, /Please use Postmark::ApiClient\#deliver_messages_with_templates/)
+    context 'when given templated messages' do
+      let(:messages) {[templated_message]}
+
+      specify do
+        expect { subject }.to raise_error(ArgumentError, /Please use Postmark::ApiClient\#deliver_messages_with_templates/)
+      end
     end
 
     it 'turns array of messages into a JSON document and posts it to /email/batch' do
       expect(http_client).to receive(:post).with('email/batch', emails_json) {response}
-      subject.deliver_messages([message, message, message])
-    end
-
-    it "retry 3 times" do
-      2.times do
-        expect(http_client).to receive(:post).and_raise(Postmark::InternalServerError)
-      end
-      expect(http_client).to receive(:post) {response}
-      expect {subject.deliver_messages([message, message, message])}.not_to raise_error
+      subject
     end
 
-    it "retry on timeout" do
-      expect(http_client).to receive(:post).and_raise(Postmark::TimeoutError)
-      expect(http_client).to receive(:post) {response}
-      expect {subject.deliver_messages([message, message, message])}.not_to raise_error
-    end
+    it_should_behave_like 'retryable', []
   end
 
   describe "#deliver_messages_with_templates" do
+    subject {api_client.deliver_messages_with_templates(messages)}
+
     let(:email) {templated_message.to_postmark_hash}
-    let(:emails) {[email, email, email]}
-    let(:emails_json) {Postmark::Json.encode(:Messages => emails)}
+    let(:emails_json) {Postmark::Json.encode(:Messages => Array.new(3) { email })}
     let(:response) {[{}, {}, {}]}
     let(:messages) { Array.new(3) { templated_message } }
 
-    it 'raises an error when given a templated message' do
-      expect { subject.deliver_messages_with_templates([message]) }.
-        to raise_error(ArgumentError, 'Templated delivery requested, but one or more messages lack templates.')
-    end
-
-    it 'turns array of messages into a JSON document and posts it to /email/batch' do
-      expect(http_client).to receive(:post).with('email/batchWithTemplates', emails_json) {response}
-      subject.deliver_messages_with_templates(messages)
-    end
+    context 'when given a non-templated message' do
+      let(:messages) {[message]}
 
-    it "retry 3 times" do
-      2.times do
-        expect(http_client).to receive(:post).and_raise(Postmark::InternalServerError)
+      it 'raises an error ' do
+        expect { subject }.
+          to raise_error(ArgumentError, 'Templated delivery requested, but one or more messages lack templates.')
       end
-      expect(http_client).to receive(:post) {response}
-      expect {subject.deliver_messages_with_templates(messages)}.not_to raise_error
     end
 
-    it "retry on timeout" do
-      expect(http_client).to receive(:post).and_raise(Postmark::TimeoutError)
-      expect(http_client).to receive(:post) {response}
-      expect {subject.deliver_messages_with_templates(messages)}.not_to raise_error
+    it 'turns array of messages into a JSON document and posts it to expected endpoint' do
+      expect(http_client).to receive(:post).with('email/batchWithTemplates', emails_json) {response}
+      subject
     end
+
+    it_should_behave_like 'retryable', []
   end
 
   describe "#delivery_stats" do
@@ -235,7 +249,7 @@ describe Postmark::ApiClient do
 
     it 'requests data at /deliverystats' do
       expect(http_client).to receive(:get).with("deliverystats") {response}
-      expect(subject.delivery_stats).to have_key(:bounces)
+      expect(api_client.delivery_stats).to have_key(:bounces)
     end
   end
 
@@ -244,13 +258,13 @@ describe Postmark::ApiClient do
       let(:response) {{'TotalCount' => 5, 'Messages' => [{}].cycle(5).to_a}}
 
       it 'returns an enumerator' do
-        expect(subject.messages).to be_kind_of(Enumerable)
+        expect(api_client.messages).to be_kind_of(Enumerable)
       end
 
       it 'loads outbound messages' do
-        allow(subject.http_client).to receive(:get).
+        allow(api_client.http_client).to receive(:get).
             with('messages/outbound', an_instance_of(Hash)).and_return(response)
-        expect(subject.messages.count).to eq(5)
+        expect(api_client.messages.count).to eq(5)
       end
     end
 
@@ -258,12 +272,12 @@ describe Postmark::ApiClient do
       let(:response) {{'TotalCount' => 5, 'InboundMessages' => [{}].cycle(5).to_a}}
 
       it 'returns an enumerator' do
-        expect(subject.messages(:inbound => true)).to be_kind_of(Enumerable)
+        expect(api_client.messages(:inbound => true)).to be_kind_of(Enumerable)
       end
 
       it 'loads inbound messages' do
-        allow(subject.http_client).to receive(:get).with('messages/inbound', an_instance_of(Hash)).and_return(response)
-        expect(subject.messages(:inbound => true).count).to eq(5)
+        allow(api_client.http_client).to receive(:get).with('messages/inbound', an_instance_of(Hash)).and_return(response)
+        expect(api_client.messages(:inbound => true).count).to eq(5)
       end
     end
   end
@@ -276,7 +290,7 @@ describe Postmark::ApiClient do
         expect(http_client).to receive(:get).
             with('messages/outbound', :offset => 50, :count => 50).
             and_return(response)
-        subject.get_messages(:offset => 50, :count => 50)
+        api_client.get_messages(:offset => 50, :count => 50)
       end
     end
 
@@ -285,7 +299,7 @@ describe Postmark::ApiClient do
 
       it 'requests data at /messages/inbound' do
         expect(http_client).to receive(:get).with('messages/inbound', :offset => 50, :count => 50).and_return(response)
-        expect(subject.get_messages(:inbound => true, :offset => 50, :count => 50)).to be_an(Array)
+        expect(api_client.get_messages(:inbound => true, :offset => 50, :count => 50)).to be_an(Array)
       end
     end
   end
@@ -296,19 +310,19 @@ describe Postmark::ApiClient do
     context 'given outbound' do
 
       it 'requests and returns outbound messages count' do
-        allow(subject.http_client).to receive(:get).
+        allow(api_client.http_client).to receive(:get).
             with('messages/outbound', an_instance_of(Hash)).and_return(response)
-        expect(subject.get_messages_count).to eq(42)
-        expect(subject.get_messages_count(:inbound => false)).to eq(42)
+        expect(api_client.get_messages_count).to eq(42)
+        expect(api_client.get_messages_count(:inbound => false)).to eq(42)
       end
 
     end
 
     context 'given inbound' do
       it 'requests and returns inbound messages count' do
-        allow(subject.http_client).to receive(:get).
+        allow(api_client.http_client).to receive(:get).
             with('messages/inbound', an_instance_of(Hash)).and_return(response)
-        expect(subject.get_messages_count(:inbound => true)).to eq(42)
+        expect(api_client.get_messages_count(:inbound => true)).to eq(42)
       end
     end
 
@@ -323,7 +337,7 @@ describe Postmark::ApiClient do
         expect(http_client).to receive(:get).
             with("messages/outbound/#{id}/details", {}).
             and_return(response)
-        expect(subject.get_message(id)).to have_key(:to)
+        expect(api_client.get_message(id)).to have_key(:to)
       end
     end
 
@@ -332,7 +346,7 @@ describe Postmark::ApiClient do
         expect(http_client).to receive(:get).
             with("messages/inbound/#{id}/details", {}).
             and_return(response)
-        expect(subject.get_message(id, :inbound => true)).to have_key(:to)
+        expect(api_client.get_message(id, :inbound => true)).to have_key(:to)
       end
     end
   end
@@ -347,7 +361,7 @@ describe Postmark::ApiClient do
         expect(http_client).to receive(:get).
             with("messages/outbound/#{id}/dump", {}).
             and_return(response)
-        expect(subject.dump_message(id)).to have_key(:body)
+        expect(api_client.dump_message(id)).to have_key(:body)
       end
 
     end
@@ -357,21 +371,21 @@ describe Postmark::ApiClient do
         expect(http_client).to receive(:get).
             with("messages/inbound/#{id}/dump", {}).
             and_return(response)
-        expect(subject.dump_message(id, :inbound => true)).to have_key(:body)
+        expect(api_client.dump_message(id, :inbound => true)).to have_key(:body)
       end
     end
   end
 
   describe '#bounces' do
     it 'returns an Enumerator' do
-      expect(subject.bounces).to be_kind_of(Enumerable)
+      expect(api_client.bounces).to be_kind_of(Enumerable)
     end
 
     it 'requests data at /bounces' do
-      allow(subject.http_client).to receive(:get).
+      allow(api_client.http_client).to receive(:get).
           with('bounces', an_instance_of(Hash)).
           and_return('TotalCount' => 1, 'Bounces' => [{}])
-      expect(subject.bounces.first(5).count).to eq(1)
+      expect(api_client.bounces.first(5).count).to eq(1)
     end
   end
 
@@ -381,8 +395,8 @@ describe Postmark::ApiClient do
 
     it 'requests data at /bounces' do
       allow(http_client).to receive(:get).with("bounces", options) {response}
-      expect(subject.get_bounces(options)).to be_an(Array)
-      expect(subject.get_bounces(options).count).to be_zero
+      expect(api_client.get_bounces(options)).to be_an(Array)
+      expect(api_client.get_bounces(options).count).to be_zero
     end
   end
 
@@ -391,7 +405,7 @@ describe Postmark::ApiClient do
 
     it 'requests a single bounce by ID at /bounces/:id' do
       expect(http_client).to receive(:get).with("bounces/#{id}")
-      subject.get_bounce(id)
+      api_client.get_bounce(id)
     end
   end
 
@@ -400,7 +414,7 @@ describe Postmark::ApiClient do
 
     it 'requests a specific bounce data at /bounces/:id/dump' do
       expect(http_client).to receive(:get).with("bounces/#{id}/dump")
-      subject.dump_bounce(id)
+      api_client.dump_bounce(id)
     end
   end
 
@@ -410,33 +424,33 @@ describe Postmark::ApiClient do
 
     it 'activates a specific bounce by sending a PUT request to /bounces/:id/activate' do
       expect(http_client).to receive(:put).with("bounces/#{id}/activate") {response}
-      subject.activate_bounce(id)
+      api_client.activate_bounce(id)
     end
   end
 
   describe '#opens' do
     it 'returns an Enumerator' do
-      expect(subject.opens).to be_kind_of(Enumerable)
+      expect(api_client.opens).to be_kind_of(Enumerable)
     end
 
     it 'performs a GET request to /opens/tags' do
-      allow(subject.http_client).to receive(:get).
+      allow(api_client.http_client).to receive(:get).
           with('messages/outbound/opens', an_instance_of(Hash)).
           and_return('TotalCount' => 1, 'Opens' => [{}])
-      expect(subject.opens.first(5).count).to eq(1)
+      expect(api_client.opens.first(5).count).to eq(1)
     end
   end
 
   describe '#clicks' do
     it 'returns an Enumerator' do
-      expect(subject.clicks).to be_kind_of(Enumerable)
+      expect(api_client.clicks).to be_kind_of(Enumerable)
     end
 
     it 'performs a GET request to /clicks/tags' do
-      allow(subject.http_client).to receive(:get).
+      allow(api_client.http_client).to receive(:get).
           with('messages/outbound/clicks', an_instance_of(Hash)).
           and_return('TotalCount' => 1, 'Clicks' => [{}])
-      expect(subject.clicks.first(5).count).to eq(1)
+      expect(api_client.clicks.first(5).count).to eq(1)
     end
   end
 
@@ -446,8 +460,8 @@ describe Postmark::ApiClient do
 
     it 'performs a GET request to /messages/outbound/opens' do
       allow(http_client).to receive(:get).with('messages/outbound/opens', options) {response}
-      expect(subject.get_opens(options)).to be_an(Array)
-      expect(subject.get_opens(options).count).to be_zero
+      expect(api_client.get_opens(options)).to be_an(Array)
+      expect(api_client.get_opens(options).count).to be_zero
     end
   end
 
@@ -457,8 +471,8 @@ describe Postmark::ApiClient do
 
     it 'performs a GET request to /messages/outbound/clicks' do
       allow(http_client).to receive(:get).with('messages/outbound/clicks', options) {response}
-      expect(subject.get_clicks(options)).to be_an(Array)
-      expect(subject.get_clicks(options).count).to be_zero
+      expect(api_client.get_clicks(options)).to be_an(Array)
+      expect(api_client.get_clicks(options).count).to be_zero
     end
   end
 
@@ -469,8 +483,8 @@ describe Postmark::ApiClient do
 
     it 'performs a GET request to /messages/outbound/opens' do
       allow(http_client).to receive(:get).with("messages/outbound/opens/#{message_id}", options).and_return(response)
-      expect(subject.get_opens_by_message_id(message_id, options)).to be_an(Array)
-      expect(subject.get_opens_by_message_id(message_id, options).count).to be_zero
+      expect(api_client.get_opens_by_message_id(message_id, options)).to be_an(Array)
+      expect(api_client.get_opens_by_message_id(message_id, options).count).to be_zero
     end
   end
 
@@ -481,8 +495,8 @@ describe Postmark::ApiClient do
 
     it 'performs a GET request to /messages/outbound/clicks' do
       allow(http_client).to receive(:get).with("messages/outbound/clicks/#{message_id}", options).and_return(response)
-      expect(subject.get_clicks_by_message_id(message_id, options)).to be_an(Array)
-      expect(subject.get_clicks_by_message_id(message_id, options).count).to be_zero
+      expect(api_client.get_clicks_by_message_id(message_id, options)).to be_an(Array)
+      expect(api_client.get_clicks_by_message_id(message_id, options).count).to be_zero
     end
   end
 
@@ -490,14 +504,14 @@ describe Postmark::ApiClient do
     let(:message_id) {42}
 
     it 'returns an Enumerator' do
-      expect(subject.opens_by_message_id(message_id)).to be_kind_of(Enumerable)
+      expect(api_client.opens_by_message_id(message_id)).to be_kind_of(Enumerable)
     end
 
     it 'performs a GET request to /opens/tags' do
-      allow(subject.http_client).to receive(:get).
+      allow(api_client.http_client).to receive(:get).
           with("messages/outbound/opens/#{message_id}", an_instance_of(Hash)).
           and_return('TotalCount' => 1, 'Opens' => [{}])
-      expect(subject.opens_by_message_id(message_id).first(5).count).to eq(1)
+      expect(api_client.opens_by_message_id(message_id).first(5).count).to eq(1)
     end
   end
 
@@ -505,14 +519,14 @@ describe Postmark::ApiClient do
     let(:message_id) {42}
 
     it 'returns an Enumerator' do
-      expect(subject.clicks_by_message_id(message_id)).to be_kind_of(Enumerable)
+      expect(api_client.clicks_by_message_id(message_id)).to be_kind_of(Enumerable)
     end
 
     it 'performs a GET request to /clicks/tags' do
-      allow(subject.http_client).to receive(:get).
+      allow(api_client.http_client).to receive(:get).
           with("messages/outbound/clicks/#{message_id}", an_instance_of(Hash)).
           and_return('TotalCount' => 1, 'Clicks' => [{}])
-      expect(subject.clicks_by_message_id(message_id).first(5).count).to eq(1)
+      expect(api_client.clicks_by_message_id(message_id).first(5).count).to eq(1)
     end
   end
 
@@ -524,12 +538,12 @@ describe Postmark::ApiClient do
       it 'performs a POST request to /triggers/inboundrules with given options' do
         allow(http_client).to receive(:post).with('triggers/inboundrules',
                                                   {'Rule' => 'example.com'}.to_json)
-        subject.create_trigger(:inbound_rules, options)
+        api_client.create_trigger(:inbound_rules, options)
       end
 
       it 'symbolizes response keys' do
         allow(http_client).to receive(:post).and_return(response)
-        expect(subject.create_trigger(:inbound_rules, options)).to eq(:rule => 'example.com')
+        expect(api_client.create_trigger(:inbound_rules, options)).to eq(:rule => 'example.com')
       end
     end
   end
@@ -539,12 +553,12 @@ describe Postmark::ApiClient do
 
     it 'performs a GET request to /triggers/tags/:id' do
       allow(http_client).to receive(:get).with("triggers/tags/#{id}")
-      subject.get_trigger(:tags, id)
+      api_client.get_trigger(:tags, id)
     end
 
     it 'symbolizes response keys' do
       allow(http_client).to receive(:get).and_return('Foo' => 'Bar')
-      expect(subject.get_trigger(:tags, id)).to eq(:foo => 'Bar')
+      expect(api_client.get_trigger(:tags, id)).to eq(:foo => 'Bar')
     end
   end
 
@@ -554,12 +568,12 @@ describe Postmark::ApiClient do
 
       it 'performs a DELETE request to /triggers/tags/:id' do
         allow(http_client).to receive(:delete).with("triggers/tags/#{id}")
-        subject.delete_trigger(:tags, id)
+        api_client.delete_trigger(:tags, id)
       end
 
       it 'symbolizes response keys' do
         allow(http_client).to receive(:delete).and_return('Foo' => 'Bar')
-        expect(subject.delete_trigger(:tags, id)).to eq(:foo => 'Bar')
+        expect(api_client.delete_trigger(:tags, id)).to eq(:foo => 'Bar')
       end
     end
 
@@ -568,12 +582,12 @@ describe Postmark::ApiClient do
 
       it 'performs a DELETE request to /triggers/inboundrules/:id' do
         allow(http_client).to receive(:delete).with("triggers/inboundrules/#{id}")
-        subject.delete_trigger(:inbound_rules, id)
+        api_client.delete_trigger(:inbound_rules, id)
       end
 
       it 'symbolizes response keys' do
         allow(http_client).to receive(:delete).and_return('Rule' => 'example.com')
-        expect(subject.delete_trigger(:tags, id)).to eq(:rule => 'example.com')
+        expect(api_client.delete_trigger(:tags, id)).to eq(:rule => 'example.com')
       end
     end
   end
@@ -586,22 +600,22 @@ describe Postmark::ApiClient do
 
       it 'performs a GET request to /triggers/inboundrules' do
         allow(http_client).to receive(:get).with('triggers/inboundrules', options) {response}
-        expect(subject.get_triggers(:inbound_rules, options)).to be_an(Array)
-        expect(subject.get_triggers(:inbound_rules, options).count).to be_zero
+        expect(api_client.get_triggers(:inbound_rules, options)).to be_an(Array)
+        expect(api_client.get_triggers(:inbound_rules, options).count).to be_zero
       end
     end
   end
 
   describe '#triggers' do
     it 'returns an Enumerator' do
-      expect(subject.triggers(:tags)).to be_kind_of(Enumerable)
+      expect(api_client.triggers(:tags)).to be_kind_of(Enumerable)
     end
 
     it 'performs a GET request to /triggers/tags' do
-      allow(subject.http_client).to receive(:get).
+      allow(api_client.http_client).to receive(:get).
           with('triggers/tags', an_instance_of(Hash)).
           and_return('TotalCount' => 1, 'Tags' => [{}])
-      expect(subject.triggers(:tags).first(5).count).to eq(1)
+      expect(api_client.triggers(:tags).first(5).count).to eq(1)
     end
   end
 
@@ -617,7 +631,7 @@ describe Postmark::ApiClient do
 
     it 'requests server info from Postmark and converts it to ruby format' do
       expect(http_client).to receive(:get).with('server') {response}
-      expect(subject.server_info).to have_key(:inbound_hash)
+      expect(api_client.server_info).to have_key(:inbound_hash)
     end
   end
 
@@ -634,7 +648,7 @@ describe Postmark::ApiClient do
 
     it 'updates server info in Postmark and converts it to ruby format' do
       expect(http_client).to receive(:put).with('server', anything) {response}
-      expect(subject.update_server_info(update)[:smtp_api_activated]).to be false
+      expect(api_client.update_server_info(update)[:smtp_api_activated]).to be false
     end
   end
 
@@ -660,7 +674,7 @@ describe Postmark::ApiClient do
     it 'gets templates info and converts it to ruby format' do
       expect(http_client).to receive(:get).with('templates', :offset => 0, :count => 2).and_return(response)
 
-      count, templates = subject.get_templates(:count => 2)
+      count, templates = api_client.get_templates(:count => 2)
 
       expect(count).to eq(31)
       expect(templates.first[:template_id]).to eq(123)
@@ -670,14 +684,14 @@ describe Postmark::ApiClient do
 
   describe '#templates' do
     it 'returns an Enumerator' do
-      expect(subject.templates).to be_kind_of(Enumerable)
+      expect(api_client.templates).to be_kind_of(Enumerable)
     end
 
     it 'requests data at /templates' do
-      allow(subject.http_client).to receive(:get).
+      allow(api_client.http_client).to receive(:get).
           with('templates', an_instance_of(Hash)).
           and_return('TotalCount' => 1, 'Templates' => [{}])
-      expect(subject.templates.first(5).count).to eq(1)
+      expect(api_client.templates.first(5).count).to eq(1)
     end
   end
 
@@ -697,7 +711,7 @@ describe Postmark::ApiClient do
     it 'gets single template and converts it to ruby format' do
       expect(http_client).to receive(:get).with('templates/123').and_return(response)
 
-      template = subject.get_template('123')
+      template = api_client.get_template('123')
 
       expect(template[:name]).to eq('Template Name')
       expect(template[:template_id]).to eq(123)
@@ -719,7 +733,7 @@ describe Postmark::ApiClient do
         with('templates', json_representation_of('Name' => 'template name')).
         and_return(response)
 
-      template = subject.create_template(:name => 'template name')
+      template = api_client.create_template(:name => 'template name')
 
       expect(template[:name]).to eq('template name')
       expect(template[:template_id]).to eq(123)
@@ -740,7 +754,7 @@ describe Postmark::ApiClient do
         with('templates/123', json_representation_of('Name' => 'template name')).
         and_return(response)
 
-      template = subject.update_template(123, :name => 'template name')
+      template = api_client.update_template(123, :name => 'template name')
 
       expect(template[:name]).to eq('template name')
       expect(template[:template_id]).to eq(123)
@@ -758,7 +772,7 @@ describe Postmark::ApiClient do
     it 'performs a DELETE request to /templates/:id' do
       expect(http_client).to receive(:delete).with('templates/123').and_return(response)
 
-      resp = subject.delete_template(123)
+      resp = api_client.delete_template(123)
 
       expect(resp[:error_code]).to eq(0)
     end
@@ -798,9 +812,9 @@ describe Postmark::ApiClient do
                                       'Subject' => '{{MyName}}')).
           and_return(response)
 
-        resp = subject.validate_template(:html_body => '{{MyName}}',
-                                         :text_body => '{{MyName}}',
-                                         :subject => '{{MyName}}')
+        resp = api_client.validate_template(:html_body => '{{MyName}}',
+                                            :text_body => '{{MyName}}',
+                                            :subject => '{{MyName}}')
 
         expect(resp[:all_content_is_valid]).to be true
         expect(resp[:html_body][:content_is_valid]).to be true
@@ -845,9 +859,9 @@ describe Postmark::ApiClient do
                                                         'TextBody' => '{{MyName}}',
                                                         'Subject' => '{{MyName}}')).and_return(response)
 
-        resp = subject.validate_template(:html_body => '{{#each}}',
-                                         :text_body => '{{MyName}}',
-                                         :subject => '{{MyName}}')
+        resp = api_client.validate_template(:html_body => '{{#each}}',
+                                            :text_body => '{{MyName}}',
+                                            :subject => '{{MyName}}')
 
         expect(resp[:all_content_is_valid]).to be false
         expect(resp[:text_body][:content_is_valid]).to be true
@@ -859,26 +873,22 @@ describe Postmark::ApiClient do
   end
 
   describe "#deliver_with_template" do
+    subject {api_client.deliver_with_template(message_hash)}
+
     let(:email) {Postmark::MessageHelper.to_postmark(message_hash)}
     let(:response) {{"MessageID" => 42}}
 
     it 'converts message hash to Postmark format and posts it to /email/withTemplate' do
       expect(http_client).to receive(:post).with('email/withTemplate', json_representation_of(email)) {response}
-      subject.deliver_with_template(message_hash)
-    end
-
-    it 'retries 3 times' do
-      2.times do
-        expect(http_client).to receive(:post).and_raise(Postmark::InternalServerError, 500)
-      end
-      expect(http_client).to receive(:post) {response}
-      expect {subject.deliver_with_template(message_hash)}.not_to raise_error
+      subject
     end
 
     it 'converts response to ruby format' do
       expect(http_client).to receive(:post).with('email/withTemplate', json_representation_of(email)) {response}
-      expect(subject.deliver_with_template(message_hash)).to have_key(:message_id)
+      expect(subject).to have_key(:message_id)
     end
+
+    it_should_behave_like "retryable"
   end
 
   describe '#deliver_in_batches_with_templates' do
@@ -905,7 +915,7 @@ describe Postmark::ApiClient do
       end
     end
 
-    before {subject.max_batch_size = max_batch_size}
+    before {api_client.max_batch_size = max_batch_size}
 
     it 'performs a total of (bath_size / max_batch_size) requests' do
       expect(http_client).
@@ -923,7 +933,7 @@ describe Postmark::ApiClient do
         response
       end
 
-      response = subject.deliver_in_batches_with_templates(message_hashes)
+      response = api_client.deliver_in_batches_with_templates(message_hashes)
       expect(response).to be_an Array
       expect(response.size).to eq message_hashes.size
 
@@ -946,7 +956,7 @@ describe Postmark::ApiClient do
 
     it 'converts response to ruby format' do
       expect(http_client).to receive(:get).with('stats/outbound', {:tag => 'foo'}) {response}
-      response = subject.get_stats_totals(:tag => 'foo')
+      response = api_client.get_stats_totals(:tag => 'foo')
       expect(response).to have_key(:sent)
       expect(response).to have_key(:bounce_rate)
     end
@@ -979,7 +989,7 @@ describe Postmark::ApiClient do
 
     it 'converts response to ruby format' do
       expect(http_client).to receive(:get).with('stats/outbound/sends', {:tag => 'foo'}) {response}
-      response = subject.get_stats_counts(:sends, :tag => 'foo')
+      response = api_client.get_stats_counts(:sends, :tag => 'foo')
       expect(response).to have_key(:days)
       expect(response).to have_key(:sent)
 
@@ -990,7 +1000,7 @@ describe Postmark::ApiClient do
 
     it 'uses fromdate that is passed in' do
       expect(http_client).to receive(:get).with('stats/outbound/sends', {:tag => 'foo', :fromdate => '2015-01-01'}) {response}
-      response = subject.get_stats_counts(:sends, :tag => 'foo', :fromdate => '2015-01-01')
+      response = api_client.get_stats_counts(:sends, :tag => 'foo', :fromdate => '2015-01-01')
       expect(response).to have_key(:days)
       expect(response).to have_key(:sent)
 
@@ -1001,7 +1011,7 @@ describe Postmark::ApiClient do
 
     it 'uses stats type that is passed in' do
       expect(http_client).to receive(:get).with('stats/outbound/opens/readtimes', {:tag => 'foo', :type => :readtimes}) {response}
-      response = subject.get_stats_counts(:opens, :type => :readtimes, :tag => 'foo')
+      response = api_client.get_stats_counts(:opens, :type => :readtimes, :tag => 'foo')
       expect(response).to have_key(:days)
       expect(response).to have_key(:sent)
 
@@ -1073,7 +1083,10 @@ describe Postmark::ApiClient do
       {
         :name => 'My Stream',
         :id => 'my-stream',
-        :message_stream_type => 'Broadcasts'
+        :message_stream_type => 'Broadcasts',
+        :subscription_management_configuration => {
+          :unsubscribe_handling_type => 'Custom'
+        }
       }
     end
 
@@ -1083,7 +1096,10 @@ describe Postmark::ApiClient do
         'Id' => 'my-stream',
         'MessageStreamType' => 'Broadcasts',
         'ServerId' => 222,
-        'CreatedAt' => '2020-04-01T03:33:33.333-03:00'
+        'CreatedAt' => '2020-04-01T03:33:33.333-03:00',
+        'SubscriptionManagementConfiguration' => {
+          'UnsubscribeHandlingType' => 'Custom'
+        }
       }
     end
 
@@ -1097,7 +1113,10 @@ describe Postmark::ApiClient do
              json_representation_of({
                'Name' => 'My Stream',
                'Id' => 'my-stream',
-               'MessageStreamType' => 'Broadcasts'
+               'MessageStreamType' => 'Broadcasts',
+               'SubscriptionManagementConfiguration' => {
+                 'UnsubscribeHandlingType' => 'Custom'
+               }
              }))
       subject
     end
@@ -1108,7 +1127,10 @@ describe Postmark::ApiClient do
         :name => 'My Stream',
         :server_id => 222,
         :message_stream_type => 'Broadcasts',
-        :created_at => '2020-04-01T03:33:33.333-03:00'
+        :created_at => '2020-04-01T03:33:33.333-03:00',
+        :subscription_management_configuration => {
+          :unsubscribe_handling_type => 'Custom'
+        }
       )
     }
   end
@@ -1118,7 +1140,10 @@ describe Postmark::ApiClient do
 
     let(:attrs) do
       {
-        :name => 'My Stream XXX'
+        :name => 'My Stream XXX',
+        :subscription_management_configuration => {
+          :unsubscribe_handling_type => 'Custom'
+        }
       }
     end
 
@@ -1128,7 +1153,10 @@ describe Postmark::ApiClient do
         'Id' => 'xxx',
         'MessageStreamType' => 'Broadcasts',
         'ServerId' => 222,
-        'CreatedAt' => '2020-04-01T03:33:33.333-03:00'
+        'CreatedAt' => '2020-04-01T03:33:33.333-03:00',
+        'SubscriptionManagementConfiguration' => {
+          'UnsubscribeHandlingType' => 'Custom'
+        }
       }
     end
 
@@ -1140,7 +1168,10 @@ describe Postmark::ApiClient do
       expect(http_client).to receive(:patch).
         with('message-streams/xxx',
              match_json({
-               :Name => 'My Stream XXX',
+               'Name' => 'My Stream XXX',
+               'SubscriptionManagementConfiguration' => {
+                 'UnsubscribeHandlingType' => 'Custom'
+               }
              }))
       subject
     end
@@ -1151,7 +1182,10 @@ describe Postmark::ApiClient do
         :name => 'My Stream XXX',
         :server_id => 222,
         :message_stream_type => 'Broadcasts',
-        :created_at => '2020-04-01T03:33:33.333-03:00'
+        :created_at => '2020-04-01T03:33:33.333-03:00',
+        :subscription_management_configuration => {
+          :unsubscribe_handling_type => 'Custom'
+        }
       )
     }
   end
@@ -1185,7 +1219,7 @@ describe Postmark::ApiClient do
     let(:stream_id) { 'my-stream'}
     let(:server_id) { 123 }
     let(:api_endpoint) { "message-streams/#{stream_id}/unarchive" }
-    let(:api_response) { 
+    let(:api_response) {
       { 'ID' => stream_id, 'ServerID' => server_id, 'Name' => 'My Stream',
         'Description' => 'My test stream.', 'MessageStreamType' => 'Transactional',
         'CreatedAt' => '2030-08-30T12:30:00.00-04:00', 'UpdatedAt' => '2030-09-30T12:30:00.00-04:00',