endicia_ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2de8392ca2c214fdb8b8a14f2b05bc4521349c8
+  data.tar.gz: 5becd6d57d1652bb94d369618d51703305597d4c
+SHA512:
+  metadata.gz: 0d2f26229ecb9af9e764dda8f9fe3d63b7cf99f7047f655d56b5ee4af8b65121d003d5945a40901c7c539bfbcd6312b453eedb094a63901bc4541bfdff1ce938
+  data.tar.gz: 1a4d7e2fc91b8afc9662f042fb07afdbd581692b836a13556e7eea45dbc4eb9b8c5410b5132212e07694ccd991e331f5ab8f88bcf84555731e7b0e1cacf60a4f

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.sw?

data/.ruby-gemset

@@ -0,0 +1 @@
+endicia_ruby

data/.ruby-version

@@ -0,0 +1 @@
+2.1.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in endicia_ruby.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dave Copeland
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,23 @@
+# endicia_ruby
+
+**Do not introduce Stitch Fix secret info to this repository**  We would like this to be open-sourced, but are keeping it private until that can be done.  So please avoid adding any Stitch Fix repo keys, API credentials, or anything like that here.
+
+Simple wrapper around Endicia's label generation and refunding API.  This currently supports only those features that Stitch Fix requires.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'endicia_ruby'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install endicia_ruby
+
+## Usage
+
+TBD

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/config/endicia.yml

@@ -0,0 +1,10 @@
+development: &development
+  credentials:
+    AccountID: <%= ENV['ENDICIA_ACCOUNT_ID'] || '2500334' %>
+    RequesterID: <%= ENV['ENDICIA_REQUESTER_ID'] || 'lxxx' %>
+    PassPhrase: <%= ENV['ENDICIA_PASSPHRASE'] || 'endicia.com' %>
+  environment: <%= ENV['ENDICIA_ENV'] || 'test' %>
+
+test:
+  <<: *development
+

data/endicia_ruby.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'endicia_ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "endicia_ruby"
+  spec.version       = Endicia::VERSION
+  spec.authors       = ["Jon Dean", "Dave Copeland"]
+  spec.email         = ["jon@stitchfix.com","dave@stitchfix.com"]
+  spec.summary       = %q{Wrapper around Endicia's APIs}
+  spec.description   = %q{Wrapper around Endicia's APIs}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "nokogiri"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "httparty"
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "vcr"
+  spec.add_development_dependency "faker"
+end

data/lib/endicia_ruby/label.rb

@@ -0,0 +1,53 @@
+require 'nokogiri'
+
+require_relative 'label_response'
+require_relative 'request'
+
+module Endicia
+  class Label < Request
+
+    # values is a Hash of the API values you wish to send to Endicia, nested as the documentation describes
+    # options is a Hash of other options (see default_options() for available options)
+    def request_label(values = {}, options = {})
+      # Build the options for this method with passed in values overriding defaults
+      root_node_attrs = root_attributes.merge!(values[:attrs] || {})
+      # Include API credentials in the values we use to build the XML
+      node_values = @options[:credentials].merge!(values[:nodes] || {})
+
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.LabelRequest(root_node_attrs) do
+          recursive_build_xml_nodes!(xml, node_values)
+        end
+      end
+      xml_body = builder.to_xml
+
+      # Log the XML of the request if desired
+      log("ENDICIA LABEL REQUEST: #{format_xml_for_logging(xml_body)}") if options[:log_requests]
+
+      # Post the XML to the appropriate API URL
+      url = "#{api_url_base}/GetPostageLabelXML"
+
+      # Endicia's test server has an invalid certificate o_O
+      raw_response = self.class.post(url, body: "labelRequestXML=#{xml_body}", verify: environment != :test)
+
+      # Log the XML of the response if desired
+      log("ENDICIA LABEL RESPONSE: #{format_xml_for_logging(raw_response.body)}") if options[:log_responses]
+
+      # Build a nice response object and return it
+      Endicia::LabelResponse.new(raw_response).tap do |the_label|
+        the_label.request_body = xml_body.to_s
+        the_label.request_url = url
+      end
+    end
+
+    protected
+
+    def root_attributes
+      {
+        Test: api_test_mode_value,
+        LabelType: 'Default',
+      }
+    end
+
+  end
+end

data/lib/endicia_ruby/label_response.rb

@@ -0,0 +1,46 @@
+require 'active_support/core_ext/string/inflections'
+
+module Endicia
+  class LabelResponse
+    attr_accessor :image,
+                  :status,
+                  :tracking_number,
+                  :final_postage,
+                  :transaction_date_time,
+                  :transaction_id,
+                  :postmark_date,
+                  :postage_balance,
+                  :pic,
+                  :error_message,
+                  :reference_id,
+                  :reference_id2,
+                  :reference_id3,
+                  :reference_id4,
+                  :requester_id,
+                  :cost_center,
+                  :request_body,
+                  :request_url,
+                  :response_body
+    def initialize(result)
+      self.response_body = filter_response_body(result.body.dup)
+      data = result["LabelRequestResponse"] || {}
+      data.each do |k, v|
+        if k == 'Base64LabelImage'
+          k = "image"
+        elsif k == 'Label'
+          # when customs form is included in xml, Endicia returns the image in a different format
+          k = "image"
+          v = v["Image"]["__content__"]
+        end
+        setter = :"#{k.tableize.singularize}="
+        send(setter, v) if !k['xmlns'] && respond_to?(setter)
+      end
+    end
+
+    private
+    def filter_response_body(string)
+      # Strip image data for readability:
+      string.sub(/<.*Image>.+<\/.*Image>/, "<Image>[data]</Image>")
+    end
+  end
+end

data/lib/endicia_ruby/refund.rb

@@ -0,0 +1,53 @@
+require 'uri'
+require 'nokogiri'
+require_relative 'request'
+require_relative 'refund_response'
+
+module Endicia
+  class Refund < Request
+
+    # Request a refund for the given tracking number(s)
+    #
+    # tracking_numbers can be an array of strings or a single string
+    #
+    # Returns an Endicia::RefundResponse
+    #
+    def request_refund(tracking_numbers, options = {})
+      # Build the options for this method with passed in values overriding defaults
+      options.reverse_merge!(default_options)
+
+      # If we didn't get an array of tracking numbers make it one for simplicity
+      tracking_numbers = tracking_numbers.is_a?(Array) ? tracking_numbers : [tracking_numbers]
+
+      # Build the XML document
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.RefundRequest do
+          # Add the credentials
+          recursive_build_xml_nodes!(xml, @options[:credentials])
+          # Add the value for Test since this API is different and wants it as a node and not attribute, apparently
+          xml.Test(api_test_mode_value)
+          # Add all tracking numbers
+          xml.RefundList do |xml|
+            tracking_numbers.collect do |tracking_number|
+              xml.PICNumber(tracking_number)
+            end
+          end
+        end
+      end
+      xml_body = builder.to_xml
+
+      # Log the XML of the request if desired
+      log("ENDICIA REFUND REQUEST: #{format_xml_for_logging(xml_body)}") if options[:log_requests]
+
+      params = { method: 'RefundRequest', XMLInput: URI.encode(xml_body) }
+      raw_response = self.class.get(els_service_url(params))
+
+      # Log the XML of the response if desired
+      log("ENDICIA REFUND RESPONSE: #{format_xml_for_logging(raw_response.body)}") if options[:log_responses]
+
+      Endicia::RefundResponse.new(raw_response)
+
+    end
+
+  end
+end

data/lib/endicia_ruby/refund_response.rb

@@ -0,0 +1,39 @@
+require 'ostruct'
+require 'nokogiri'
+
+module Endicia
+  class RefundResponse
+
+    attr_accessor :success,         # boolean: true if all tracking numbers are approved or false otherwise
+                                    # (Probably better to use tracking_numbers to check each individually)
+                  :form_number,     # Form Number for refunded label
+                  :raw_response,    # The XML response as a string
+                  :parsed_response, # A Nokogiri document of the XML response
+                  :tracking_numbers # An array with information about all requested tracking numbers
+                                    # Each entry is an OpenStruct with:
+                                    #   pic_number: '123456789',         # the tracking number you requested
+                                    #   approved:   true,                # or false
+                                    #   message:    "the message"        # message describing success or failure
+
+    def initialize(response)
+      @success = true
+      @tracking_numbers = []
+      @raw_response = response.body
+
+      @parsed_response = Nokogiri::XML(response.body)
+      refund_response = @parsed_response.xpath('/RefundResponse')
+      @form_number = refund_response.at('FormNumber').content
+
+      refund_list = refund_response.at('RefundList')
+
+      refund_list.xpath('//PICNumber').each do |refund_node|
+        approved = refund_node.at('IsApproved').content.try(:strip).try(:upcase) == "YES"
+        @tracking_numbers << OpenStruct.new(pic_number: refund_node.children.first.text.try(:strip),
+                                            approved:   approved,
+                                            message:    refund_node.at('ErrorMsg').content.try(:strip))
+        @success = @success && approved
+      end
+    end
+
+  end
+end

data/lib/endicia_ruby/request.rb

@@ -0,0 +1,168 @@
+require 'httparty'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/object/blank'
+
+# Hack fix because Endicia sends response back without protocol in xmlns uri
+module HTTParty
+  class Request
+    alias_method :parse_response_without_hack, :parse_response
+    def parse_response(body)
+      parse_response_without_hack(
+        body.sub(/xmlns=("|')(.*envmgr.com|.*endicia.com)/i, 'xmlns=\1https://\2'))
+    end
+  end
+end
+
+module Endicia
+  class Request
+
+    include HTTParty
+
+    ENDICIA_API_HOSTS = {
+      test: 'https://www.envmgr.com',
+      sandbox: 'https://elstestserver.endicia.com',
+      production: 'https://LabelServer.Endicia.com',
+    }
+
+    # Pass a hash of options with:
+    # {
+    #   credentials: {
+    #     AccountID: '2500334',
+    #     RequesterID: 'lxxx',
+    #     PassPhrase: 'endicia.com',
+    #   },
+    #   environment: 'test' # or 'production' or 'sandbox'
+    # }
+    #
+    # Or if using Rails, create an endicia.yml in {Rails.root}/config/ in this format:
+    # development: &development
+    #   credentials:
+    #     AccountID: youraccountid
+    #     RequesterID: lxxx
+    #     PassPhrase: endicia.com
+    #   environment: sandbox
+    #
+    # test:
+    #   <<: *development
+    #
+    # staging:
+    #   <<: *development
+    #
+    # production:
+    #   credentials:
+    #     AccountID: youraccountid
+    #     RequesterID: lsfx
+    #     PassPhrase: yourpassword
+    #   environment: production
+    #
+    # If both an endicia.yml file is present and a hash of options is passed, any values in the hash take precedence
+    def initialize(options = {})
+      @options = load_options_from_config_file.deep_merge(options)
+    end
+
+    protected
+
+    # Separated so you can easily stub in tests with something like the following (in rspec):
+    #   Endicia::Request.any_instance.stub(:environment).and_return(:sandbox)
+    #   Endicia::Label.request_label(values)
+    # Note: since api_url_base is memoized you want to do this before you make the first API call on that object
+    def environment
+      @options[:environment].try(:to_sym)
+    end
+
+    # Most requests use this url
+    def api_host
+      if ENDICIA_API_HOSTS.key?(environment)
+        ENDICIA_API_HOSTS[environment]
+      else
+        raise "Invalid environment value: '#{environment}'"
+      end
+    end
+
+    def api_url_base
+      @api_url_base ||= "#{api_host}/LabelService/EwsLabelService.asmx"
+    end
+
+    # Some requests use the ELS service url. This URL is used for requests that
+    # can accept GET, and have params passed via URL instead of a POST body.
+    # Pass a hash of params to have them converted to a &key=value string and
+    # appended to the URL.
+    def els_service_url(params = {})
+      params = params.to_a.map { |i| "#{i[0]}=#{i[1]}"}.join('&')
+      "http://www.endicia.com/ELS/ELSServices.cfc?wsdl&#{params}"
+    end
+
+    def default_options
+      {
+        log_requests:   false,
+        log_responses:  false,
+      }
+    end
+
+    # Build nodes for the given xml builder recursively from a Hash
+    def recursive_build_xml_nodes!(xml, nodes)
+      nodes.each do |key, value|
+        node_name = key.to_s.sub(/^./,&:upcase) # convert "fooBar" to "FooBar"
+        case value
+        when Hash
+          xml.send(node_name) do
+            recursive_build_xml_nodes!(xml, value)
+          end
+        when Array
+          xml.send(node_name) do
+            value.each do |v|
+              recursive_build_xml_nodes!(xml, v)
+            end
+          end
+        else
+          xml.send(node_name, value)
+        end
+      end
+    end
+
+    # The Test attribute for the root node of the XML request
+    # Looks like:
+    #   <LabelRequest Test="YES" ...>
+    # or:
+    #   <LabelRequest Test="NO" ...>
+    def api_test_mode_value
+      @options[:environment] == 'production' ? 'NO' : 'YES'
+    end
+
+    # If using Rails, load default config options from {Rails.root}/config/endicia.yml
+    def load_options_from_config_file
+      configuration_values = {}
+      if defined?(Rails)
+        config_file = File.join(Rails.root, 'config', 'endicia.yml')
+        if File.exist?(config_file)
+          configuration_values = YAML.load(ERB.new(File.read(config_file)).result)[Rails.env]
+          recursive_symbolize_keys!(configuration_values)
+        end
+      end
+      configuration_values
+    end
+
+    # Used by load_options_from_config_file
+    def recursive_symbolize_keys! hash
+      hash.symbolize_keys!
+      hash.values.select{|v| v.is_a? Hash}.each{|h| recursive_symbolize_keys!(h)}
+    end
+
+    # Make a one line string with image data stripped for use in logging
+    def format_xml_for_logging(xml_string)
+      xml_string.to_s.gsub("\r\n", '').gsub("\n", '').gsub("\t", '').gsub("\s{2,}", ' ').sub(/<.*Image>.*<\/.*Image>/, '<Image>[data]</Image>')
+    end
+
+    # Helper for logging messages via Rails.logger if available or just puts if not using Rails
+    def log(message, level: :info)
+      if defined?(Rails)
+        Rails.logger.send(level, message)
+      else
+        puts message
+      end
+    end
+
+  end
+end

data/lib/endicia_ruby/version.rb

@@ -0,0 +1,3 @@
+module Endicia
+  VERSION = "0.0.1"
+end

data/lib/endicia_ruby.rb

@@ -0,0 +1,7 @@
+require "endicia_ruby/version"
+require "endicia_ruby/label"
+require "endicia_ruby/label_response"
+require "endicia_ruby/refund"
+require "endicia_ruby/refund_response"
+require "endicia_ruby/request"
+

data/spec/label_response_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Endicia::LabelResponse do
+  describe "initialize" do
+    let(:result) {
+      OpenStruct.new(
+        "LabelRequestResponse"  => {
+          image_key             => image_value,
+          "Status"              => Faker::Lorem.sentence,
+          "TrackingNumber"      => Faker::Lorem.sentence,
+          "FinalPostage"        => Faker::Lorem.sentence,
+          "TransactionDateTime" => Faker::Lorem.sentence,
+          "TransactionId"       => Faker::Lorem.sentence,
+          "PostmarkDate"        => Faker::Lorem.sentence,
+          "PostageBalance"      => Faker::Lorem.sentence,
+          "Pic"                 => Faker::Lorem.sentence,
+          "ErrorMessage"        => Faker::Lorem.sentence,
+          "ReferenceId"         => Faker::Lorem.sentence,
+          "ReferenceId2"        => Faker::Lorem.sentence,
+          "ReferenceId3"        => Faker::Lorem.sentence,
+          "ReferenceId4"        => Faker::Lorem.sentence,
+          "RequesterId"         => Faker::Lorem.sentence,
+          "CostCenter"          => Faker::Lorem.sentence,
+          "RequestBody"         => Faker::Lorem.sentence,
+          "RequestUrl"          => Faker::Lorem.sentence,
+          "Ignored"             => Faker::Lorem.sentence,
+        },
+        body: "<Image>ksadjhfalskjfhalsjfhaslfjhasdljkf</Image>"
+      )
+    }
+    let(:expected_image_value) { Faker::Lorem.sentence }
+    let(:image_key) { "Base64LabelImage" }
+    let(:image_value) { expected_image_value }
+
+    subject(:response) { described_class.new(result) }
+
+    it "turns the awful Enterprise keys into snake-case and sets 'em up appropriate" do
+      expect(response.status).to eq(result["LabelRequestResponse"]["Status"])
+      expect(response.tracking_number).to eq(result["LabelRequestResponse"]["TrackingNumber"])
+      expect(response.final_postage).to eq(result["LabelRequestResponse"]["FinalPostage"])
+      expect(response.transaction_date_time).to eq(result["LabelRequestResponse"]["TransactionDateTime"])
+      expect(response.transaction_id).to eq(result["LabelRequestResponse"]["TransactionId"])
+      expect(response.postmark_date).to eq(result["LabelRequestResponse"]["PostmarkDate"])
+      expect(response.postage_balance).to eq(result["LabelRequestResponse"]["PostageBalance"])
+      expect(response.pic).to eq(result["LabelRequestResponse"]["Pic"])
+      expect(response.error_message).to eq(result["LabelRequestResponse"]["ErrorMessage"])
+      expect(response.reference_id).to eq(result["LabelRequestResponse"]["ReferenceId"])
+      expect(response.reference_id2).to eq(result["LabelRequestResponse"]["ReferenceId2"])
+      expect(response.reference_id3).to eq(result["LabelRequestResponse"]["ReferenceId3"])
+      expect(response.reference_id4).to eq(result["LabelRequestResponse"]["ReferenceId4"])
+      expect(response.requester_id).to eq(result["LabelRequestResponse"]["RequesterId"])
+      expect(response.cost_center).to eq(result["LabelRequestResponse"]["CostCenter"])
+      expect(response.request_body).to eq(result["LabelRequestResponse"]["RequestBody"])
+      expect(response.request_url).to eq(result["LabelRequestResponse"]["RequestUrl"])
+    end
+
+    it "masks data in the body" do
+      expect(response.response_body).to eq("<Image>[data]</Image>")
+    end
+
+    context "for typical case" do
+      let(:image_key) { "Base64LabelImage" }
+      let(:image_value) { expected_image_value }
+
+      it "translates Base64LabelImage to 'image'" do
+        expect(response.image).to eq(expected_image_value)
+      end
+    end
+
+    context "for customs form case" do
+      let(:image_key) { "Label" }
+      let(:image_value) { 
+        {
+          "Image" => {
+            "__content__" => expected_image_value
+          }
+        }
+      }
+      it "translates Base64LabelImage to 'image'" do
+        expect(response.image).to eq(expected_image_value)
+      end
+    end
+  end
+end

data/spec/label_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper.rb'
+
+describe Endicia::Label do
+  subject(:label) { described_class.new }
+
+  describe "#request_label", vcr: { record: :new_episodes } do
+    let(:values) {
+      {
+        ToName: Faker::Name.name,
+        ToCompany: Faker::Company.name,
+        ToPostalCode: "90210",
+        ToAddress1: Faker::Address.street_address,
+        ToAddress2: Faker::Address.secondary_address,
+        ToCity: Faker::Address.city,
+        ToState: "CA",
+        PartnerTransactionID: 12345,
+        PartnerCustomerID: 45678,
+        MailClass: "Priority",
+        MailpieceShape: "Parcel",
+        ToZIP4: '1234',
+        WeightOz: "32", # 2 pounds
+        MailpieceDimensions: {
+          Length: "12",
+          Width:  "16",
+          Height: "18",
+        },
+        FromCompany: Faker::Company.name,
+        ReturnAddress1: Faker::Address.street_address,
+        ReturnAddress2: Faker::Address.secondary_address,
+        FromCity: Faker::Address.city,
+        FromState: "DC",
+        FromPostalCode: "20005",
+        FromZIP4: "1234",
+        FromPhone: "2025551212",
+      }
+    }
+
+    it "makes a request and properly parses the result" do
+      response = label.request_label({ nodes: values, attrs: {} }, { log_requests: true, log_responses: true })
+      expect(response.status).to eq("0")
+      expect(response.tracking_number).to_not be_blank
+      expect(response.final_postage).to match(/^\d+\.\d+/)
+      expect(response.transaction_date_time).to match(/^\d{14}$/)
+      expect(response.transaction_id).to_not be_blank
+      expect(response.postmark_date).to match(/^\d{8}$/)
+      expect(response.postage_balance).to match(/^\d+\.\d+/)
+      expect(response.pic).to_not be_blank
+      expect(response.error_message).to be_blank
+      expect(response.reference_id).to be_blank
+      expect(response.reference_id2).to be_blank
+      expect(response.reference_id3).to be_blank
+      expect(response.reference_id4).to be_blank
+      expect(response.requester_id).to_not be_blank
+      expect(response.cost_center).to_not be_blank
+      expect(response.request_url).to_not be_blank
+      expect(response.request_body).to_not be_blank
+    end
+
+    it "handles a nonsense request" do
+      response = label.request_label({ nodes: {}, attrs: {} }, { log_requests: true, log_responses: true })
+      expect(response.status).to_not eq("0")
+    end
+  end
+end