my_john_deere_api 2.3.7 → 2.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4494019454f9ba67d67a7e26d25dc0c74e0872ba1085635ca2f02591a206cb72
-  data.tar.gz: e4a48bf533688951723917da61a2e3b2e568d9aafbe1220039ffeadd3428e950
+  metadata.gz: 75b86b9b093f4aa0cc586ce56fb961654b1b91577947acf48392d8d2294c85b9
+  data.tar.gz: b5879b20c85891180747ba42657ffa399da981596820c813a7049d680240dd39
 SHA512:
-  metadata.gz: f2b0c778f634a120cbb5af43b4e583f2b8e86bedf593083716ae7942792f2502e2658601fae1129f99a158ca2ec68facaedbcda190347b2068704a31923acd30
-  data.tar.gz: 737f85d452fdf4720467369a680f358bddb5d7a7d6d57ba03e092a543fa708df08f2ed27fecfc9512bb84d03e1f024d0a2ae37e25f2bb2621a9eadfa7db013c8
+  metadata.gz: 6a8c729311baa853f8ae1039573f673cb01cc084d0fc9b662ce592dd1b907a85b153f04d07ebd6bf346558efb708242f5c13f3464f3c4c5b03a4c21a2479c2d9
+  data.tar.gz: cf5dd0b1e590baeb06ead7ffeffb4a7501de17b8b56596a297797186f1bc85aa33b196f58f19162f6027e40a27b023f9ad18ad3aa25e07b61fcd383612c0bbaa

data/lib/my_john_deere_api.rb

@@ -13,4 +13,5 @@ module MyJohnDeereApi
   autoload :Validators,     'my_john_deere_api/validators'
 
   require 'my_john_deere_api/errors'
+  require 'my_john_deere_api/net_http_retry'
 end

data/lib/my_john_deere_api/client.rb

@@ -4,10 +4,11 @@ module MyJohnDeereApi
     include Helpers::CaseConversion
 
     attr_accessor :contribution_definition_id
-    attr_reader :api_key, :api_secret, :access_token, :access_secret
+    attr_reader :api_key, :api_secret, :access_token, :access_secret, :http_retry_options
 
     DEFAULTS = {
-      environment: :live
+      environment: :live,
+      http_retry: {}
     }
 
     ##
@@ -37,6 +38,7 @@ module MyJohnDeereApi
 
       self.environment = options[:environment]
       @contribution_definition_id = options[:contribution_definition_id]
+      @http_retry_options = options[:http_retry]
     end
 
     ##
@@ -45,7 +47,15 @@ module MyJohnDeereApi
 
     def accessor
       return @accessor if defined?(@accessor)
-      @accessor = OAuth::AccessToken.new(consumer.user_get, access_token, access_secret)
+
+      @accessor = NetHttpRetry::Decorator.new(
+        OAuth::AccessToken.new(
+          consumer.user_get,
+          access_token,
+          access_secret
+        ),
+        http_retry_options
+      )
     end
 
     ##

data/lib/my_john_deere_api/net_http_retry.rb

@@ -0,0 +1,2 @@
+require 'my_john_deere_api/net_http_retry/decorator'
+require 'my_john_deere_api/net_http_retry/max_retries_exceeded_error'

data/lib/my_john_deere_api/net_http_retry/decorator.rb

@@ -0,0 +1,53 @@
+module MyJohnDeereApi
+  module NetHttpRetry
+    class Decorator
+      attr_reader :object, :request_methods, :retry_delay_exponent, :max_retries, :response_codes
+
+      DEFAULTS = {
+        request_methods:      [:get, :post, :put, :delete],
+        retry_delay_exponent: 2,
+        max_retries: 12,
+        response_codes: ['429', '503']
+      }
+
+      def initialize(object, options={})
+        @object = object
+
+        [:request_methods, :retry_delay_exponent, :max_retries].each do |option|
+          instance_variable_set(:"@#{option}", options[option] || DEFAULTS[option])
+        end
+
+        @response_codes = (options[:response_codes] || DEFAULTS[:response_codes]).map(&:to_s)
+      end
+
+      def request(method_name, *args)
+        retries = 0
+        result = object.send(method_name, *args)
+
+        while response_codes.include?(result.code)
+          if retries >= max_retries
+            raise MaxRetriesExceededError.new(method_name, "#{result.code} #{result.message}")
+          end
+
+          delay = [result['retry-after'].to_i, retry_delay_exponent ** retries].max
+          sleep(delay)
+
+          result = object.send(method_name, *args)
+          retries += 1
+        end
+
+        result
+      end
+
+      private
+
+      def method_missing(method_name, *args, &block)
+        if request_methods.include?(method_name)
+          request(method_name, *args)
+        else
+          object.send(method_name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/my_john_deere_api/net_http_retry/max_retries_exceeded_error.rb

@@ -0,0 +1,20 @@
+module MyJohnDeereApi
+  module NetHttpRetry
+    ##
+    # This error is used when a single request has exceeded
+    # the number of retries allowed by NetHttpRetry::Decorator::MAX_RETRIES.
+
+    class MaxRetriesExceededError < StandardError
+
+      ##
+      # argument is a string which describes the attempted request
+
+      def initialize(request_method, response_message)
+        message = "Max retries exceeded for #{request_method.to_s.upcase} " +
+                  "request: #{response_message}"
+
+        super(message)
+      end
+    end
+  end
+end

data/lib/my_john_deere_api/version.rb

@@ -1,3 +1,3 @@
 module MyJohnDeereApi
-  VERSION='2.3.7'
+  VERSION='2.4.1'
 end

data/test/lib/my_john_deere_api/client_test.rb

@@ -6,7 +6,7 @@ describe 'MyJohnDeereApi::Client' do
     assert_equal 'thisIsATest', client.send(:camelize, :this_is_a_test)
   end
 
-  describe '#initialize(api_key, api_secret)' do
+  describe '#initialize(api_key, api_secret, options={})' do
     it 'sets the api key/secret' do
       client = JD::Client.new(api_key, api_secret)
 
@@ -35,6 +35,23 @@ describe 'MyJohnDeereApi::Client' do
       client = JD::Client.new(api_key, api_secret, contribution_definition_id: contribution_definition_id)
       assert_equal contribution_definition_id, client.contribution_definition_id
     end
+
+    it 'accepts a list of parameters for NetHttpRetry' do
+      custom_retries = JD::NetHttpRetry::Decorator::DEFAULTS[:max_retries] + 10
+
+      VCR.use_cassette('catalog') do
+        new_client = JD::Client.new(
+          api_key,
+          api_secret,
+          contribution_definition_id: contribution_definition_id,
+          environment: :sandbox,
+          access: [access_token, access_secret],
+          http_retry: {max_retries: custom_retries}
+        )
+
+        assert_equal custom_retries, new_client.accessor.max_retries
+      end
+    end
   end
 
   describe '#contribution_definition_id' do
@@ -130,7 +147,7 @@ describe 'MyJohnDeereApi::Client' do
 
     it 'sends the request' do
       response = VCR.use_cassette('put_asset') { client.put("/assets/#{asset_id}", attributes) }
-      puts "HASH!! #{response.inspect}" if response.is_a?(Hash)
+
       assert_equal '204', response.code
       assert_equal 'No Content', response.message
     end
@@ -199,7 +216,7 @@ describe 'MyJohnDeereApi::Client' do
 
   describe '#accessor' do
     it 'returns an object that can make user-specific requests' do
-      assert_kind_of OAuth::AccessToken, accessor
+      assert_kind_of JD::NetHttpRetry::Decorator, accessor
       assert_kind_of OAuth::Consumer, accessor.consumer
       assert_equal access_token, accessor.token
       assert_equal access_secret, accessor.secret

data/test/lib/my_john_deere_api/errors/max_retries_exceeded_error_test.rb

@@ -0,0 +1,13 @@
+require 'support/helper'
+
+describe 'JD::NetHttpRetry::MaxRetriesExceededError' do
+  it 'inherits from StandardError' do
+    error = JD::NetHttpRetry::MaxRetriesExceededError.new(:get, '503')
+    assert_kind_of StandardError, error
+  end
+
+  it 'accepts a request description, and includes in message' do
+    message = JD::NetHttpRetry::MaxRetriesExceededError.new(:get, '503 Service Unavailable').message
+    assert_equal message, "Max retries exceeded for GET request: 503 Service Unavailable"
+  end
+end

data/test/lib/my_john_deere_api/net_http_retry/decorator_test.rb

@@ -0,0 +1,163 @@
+require 'support/helper'
+
+describe 'JD::NetHttpRetry::Decorator' do
+  REQUESTS = {
+    get:    '/',
+    post:   '/organizations/000000/assets',
+    put:    '/assets/00000000-0000-0000-0000-000000000000',
+    delete: '/assets/00000000-0000-0000-0000-000000000000'
+  }
+
+  REQUEST_METHODS = REQUESTS.keys
+
+  let(:klass) { JD::NetHttpRetry::Decorator }
+  let(:object) { klass.new(mock, options) }
+
+  let(:options) do
+    {
+      request_methods: request_methods,
+      retry_delay_exponent: retry_delay_exponent,
+      max_retries: max_retries,
+      response_codes: response_codes
+    }
+  end
+
+  let(:request_methods) { nil }
+  let(:retry_delay_exponent) { nil }
+  let(:max_retries) { nil }
+  let(:response_codes) { nil }
+
+  let(:retry_values) { [13, 17, 19, 23] }
+  let(:exponential_retries) { (0..klass::DEFAULTS[:max_retries]-1).map{|i| 2 ** i} }
+
+  it 'wraps a "net-http"-responsive object' do
+    assert_kind_of OAuth::AccessToken, accessor.object
+  end
+
+  describe '#initialize' do
+    describe 'when request methods are specified' do
+      let(:request_methods) { [:banana, :fana, :fofana] }
+
+      it 'uses the supplied values' do
+        assert_equal request_methods, object.request_methods
+      end
+    end
+
+    describe 'when request methods are not specified' do
+      it 'uses the default values' do
+        assert_equal klass::DEFAULTS[:request_methods], object.request_methods
+      end
+    end
+
+    describe 'when retry_delay_exponent is specified' do
+      let(:retry_delay_exponent) { 42 }
+
+      it 'uses the supplied value' do
+        assert_equal retry_delay_exponent, object.retry_delay_exponent
+      end
+    end
+
+    describe 'when retry_delay_exponent is not specified' do
+      it 'uses the default value' do
+        assert_equal klass::DEFAULTS[:retry_delay_exponent], object.retry_delay_exponent
+      end
+    end
+
+    describe 'when max_retries is specified' do
+      let(:max_retries) { 42 }
+
+      it 'uses the supplied value' do
+        assert_equal max_retries, object.max_retries
+      end
+    end
+
+    describe 'when max_retries is not specified' do
+      it 'uses the default value' do
+        assert_equal klass::DEFAULTS[:max_retries], object.max_retries
+      end
+    end
+
+    describe 'when response_codes are specified' do
+      let(:response_codes) { ['200', '201'] }
+
+      it 'uses the supplied values' do
+        assert_equal response_codes, object.response_codes
+      end
+    end
+
+    describe 'when response_codes are specified as integers' do
+      let(:response_codes) { [200, 201] }
+
+      it 'uses the stringified versions of the supplied values' do
+        assert_equal response_codes.map(&:to_s), object.response_codes
+      end
+    end
+
+    describe 'when response_codes are not specified' do
+      it 'uses the default values' do
+        assert_equal klass::DEFAULTS[:response_codes], object.response_codes
+      end
+    end
+  end
+
+  describe "honors Retry-After headers" do
+    REQUEST_METHODS.each do |request_method|
+      it "in #{request_method.to_s.upcase} requests" do
+        retry_values.each do |retry_seconds|
+          accessor.expects(:sleep).with(retry_seconds)
+        end
+
+        VCR.use_cassette("accessor/#{request_method}_retry") do
+          accessor.send(request_method, REQUESTS[request_method])
+        end
+      end
+    end
+  end
+
+  describe 'employs exponential wait times for automatic retries' do
+    REQUEST_METHODS.each do |request_method|
+      it "in #{request_method.to_s.upcase} requests" do
+        exponential_retries[0,8].each do |retry_seconds|
+          accessor.expects(:sleep).with(retry_seconds)
+        end
+
+        VCR.use_cassette("accessor/#{request_method}_failed") do
+          accessor.send(request_method, REQUESTS[request_method])
+        end
+      end
+    end
+  end
+
+  describe 'when Retry-After is shorter than exponential wait time' do
+    REQUEST_METHODS.each do |request_method|
+      it "chooses longer exponential time in #{request_method.to_s.upcase} requests" do
+        exponential_retries[0,4].each do |retry_seconds|
+          accessor.expects(:sleep).with(retry_seconds)
+        end
+
+        VCR.use_cassette("accessor/#{request_method}_retry_too_soon") do
+          accessor.send(request_method, REQUESTS[request_method])
+        end
+      end
+    end
+  end
+
+  describe 'when max retries have been reached' do
+    REQUEST_METHODS.each do |request_method|
+      it "returns an error for #{request_method.to_s.upcase} requests" do
+        exponential_retries.each do |retry_seconds|
+          accessor.expects(:sleep).with(retry_seconds)
+        end
+
+        exception = assert_raises(JD::NetHttpRetry::MaxRetriesExceededError) do
+          VCR.use_cassette("accessor/#{request_method}_max_failed") do
+            accessor.send(request_method, REQUESTS[request_method])
+          end
+        end
+
+        expected_error = "Max retries exceeded for #{request_method.to_s.upcase} request: 429 Too Many Requests"
+        assert_equal expected_error, exception.message
+      end
+    end
+  end
+end

data/test/support/helper.rb

@@ -4,6 +4,7 @@ require 'dotenv/load'
 require 'minitest/autorun'
 require 'minitest/reporters'
 require 'my_john_deere_api'
+require 'mocha/minitest'
 
 require 'support/vcr_setup'
 

data/test/support/vcr/accessor/delete_failed.yml

@@ -0,0 +1,327 @@
+---
+http_interactions:
+- request:
+    method: delete
+    uri: https://sandboxapi.deere.com/platform/assets/00000000-0000-0000-0000-000000000000
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept:
+      - application/vnd.deere.axiom.v3+json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      User-Agent:
+      - OAuth gem v0.5.4
+      Authorization:
+      - OAuth oauth_consumer_key="johndeere-0000000000000000000000000000000000000000",
+        oauth_nonce="000000000000000000000000000000000000000000", oauth_signature="0000000000000000000000000000",
+        oauth_signature_method="HMAC-SHA1", oauth_timestamp="1581334172", oauth_token="00000000-0000-0000-0000-000000000000",
+        oauth_version="1.0"
+  response:
+    status:
+      code: 429
+      message: Too Many Requests
+    headers:
+      Date:
+      - Mon, 10 Feb 2020 17:29:36 GMT
+      X-Deere-Handling-Server:
+      - ip-10-214-45-99
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Deere-Elapsed-Ms:
+      - '96'
+    body:
+      encoding: UTF-8
+      string: ''
+    http_version: 
+  recorded_at: Mon, 10 Feb 2020 17:29:36 GMT
+- request:
+    method: delete
+    uri: https://sandboxapi.deere.com/platform/assets/00000000-0000-0000-0000-000000000000
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept:
+      - application/vnd.deere.axiom.v3+json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      User-Agent:
+      - OAuth gem v0.5.4
+      Authorization:
+      - OAuth oauth_consumer_key="johndeere-0000000000000000000000000000000000000000",
+        oauth_nonce="000000000000000000000000000000000000000000", oauth_signature="0000000000000000000000000000",
+        oauth_signature_method="HMAC-SHA1", oauth_timestamp="1581334172", oauth_token="00000000-0000-0000-0000-000000000000",
+        oauth_version="1.0"
+  response:
+    status:
+      code: 429
+      message: Too Many Requests
+    headers:
+      Date:
+      - Mon, 10 Feb 2020 17:29:36 GMT
+      X-Deere-Handling-Server:
+      - ip-10-214-45-99
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Deere-Elapsed-Ms:
+      - '96'
+    body:
+      encoding: UTF-8
+      string: ''
+    http_version: 
+  recorded_at: Mon, 10 Feb 2020 17:29:36 GMT
+- request:
+    method: delete
+    uri: https://sandboxapi.deere.com/platform/assets/00000000-0000-0000-0000-000000000000
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept:
+      - application/vnd.deere.axiom.v3+json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      User-Agent:
+      - OAuth gem v0.5.4
+      Authorization:
+      - OAuth oauth_consumer_key="johndeere-0000000000000000000000000000000000000000",
+        oauth_nonce="000000000000000000000000000000000000000000", oauth_signature="0000000000000000000000000000",
+        oauth_signature_method="HMAC-SHA1", oauth_timestamp="1581334172", oauth_token="00000000-0000-0000-0000-000000000000",
+        oauth_version="1.0"
+  response:
+    status:
+      code: 503
+      message: Service Unavailable
+    headers:
+      Date:
+      - Mon, 10 Feb 2020 17:29:36 GMT
+      X-Deere-Handling-Server:
+      - ip-10-214-45-99
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Deere-Elapsed-Ms:
+      - '96'
+    body:
+      encoding: UTF-8
+      string: ''
+    http_version: 
+  recorded_at: Mon, 10 Feb 2020 17:29:36 GMT
+- request:
+    method: delete
+    uri: https://sandboxapi.deere.com/platform/assets/00000000-0000-0000-0000-000000000000
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept:
+      - application/vnd.deere.axiom.v3+json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      User-Agent:
+      - OAuth gem v0.5.4
+      Authorization:
+      - OAuth oauth_consumer_key="johndeere-0000000000000000000000000000000000000000",
+        oauth_nonce="000000000000000000000000000000000000000000", oauth_signature="0000000000000000000000000000",
+        oauth_signature_method="HMAC-SHA1", oauth_timestamp="1581334172", oauth_token="00000000-0000-0000-0000-000000000000",
+        oauth_version="1.0"
+  response:
+    status:
+      code: 503
+      message: Service Unavailable
+    headers:
+      Date:
+      - Mon, 10 Feb 2020 17:29:36 GMT
+      X-Deere-Handling-Server:
+      - ip-10-214-45-99
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Deere-Elapsed-Ms:
+      - '96'
+    body:
+      encoding: UTF-8
+      string: ''
+    http_version: 
+  recorded_at: Mon, 10 Feb 2020 17:29:36 GMT
+- request:
+    method: delete
+    uri: https://sandboxapi.deere.com/platform/assets/00000000-0000-0000-0000-000000000000
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept:
+      - application/vnd.deere.axiom.v3+json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      User-Agent:
+      - OAuth gem v0.5.4
+      Authorization:
+      - OAuth oauth_consumer_key="johndeere-0000000000000000000000000000000000000000",
+        oauth_nonce="000000000000000000000000000000000000000000", oauth_signature="0000000000000000000000000000",
+        oauth_signature_method="HMAC-SHA1", oauth_timestamp="1581334172", oauth_token="00000000-0000-0000-0000-000000000000",
+        oauth_version="1.0"
+  response:
+    status:
+      code: 429
+      message: Too Many Requests
+    headers:
+      Date:
+      - Mon, 10 Feb 2020 17:29:36 GMT
+      X-Deere-Handling-Server:
+      - ip-10-214-45-99
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Deere-Elapsed-Ms:
+      - '96'
+    body:
+      encoding: UTF-8
+      string: ''
+    http_version: 
+  recorded_at: Mon, 10 Feb 2020 17:29:36 GMT
+- request:
+    method: delete
+    uri: https://sandboxapi.deere.com/platform/assets/00000000-0000-0000-0000-000000000000
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept:
+      - application/vnd.deere.axiom.v3+json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      User-Agent:
+      - OAuth gem v0.5.4
+      Authorization:
+      - OAuth oauth_consumer_key="johndeere-0000000000000000000000000000000000000000",
+        oauth_nonce="000000000000000000000000000000000000000000", oauth_signature="0000000000000000000000000000",
+        oauth_signature_method="HMAC-SHA1", oauth_timestamp="1581334172", oauth_token="00000000-0000-0000-0000-000000000000",
+        oauth_version="1.0"
+  response:
+    status:
+      code: 429
+      message: Too Many Requests
+    headers:
+      Date:
+      - Mon, 10 Feb 2020 17:29:36 GMT
+      X-Deere-Handling-Server:
+      - ip-10-214-45-99
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Deere-Elapsed-Ms:
+      - '96'
+    body:
+      encoding: UTF-8
+      string: ''
+    http_version: 
+  recorded_at: Mon, 10 Feb 2020 17:29:36 GMT
+- request:
+    method: delete
+    uri: https://sandboxapi.deere.com/platform/assets/00000000-0000-0000-0000-000000000000
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept:
+      - application/vnd.deere.axiom.v3+json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      User-Agent:
+      - OAuth gem v0.5.4
+      Authorization:
+      - OAuth oauth_consumer_key="johndeere-0000000000000000000000000000000000000000",
+        oauth_nonce="000000000000000000000000000000000000000000", oauth_signature="0000000000000000000000000000",
+        oauth_signature_method="HMAC-SHA1", oauth_timestamp="1581334172", oauth_token="00000000-0000-0000-0000-000000000000",
+        oauth_version="1.0"
+  response:
+    status:
+      code: 503
+      message: Service Unavailable
+    headers:
+      Date:
+      - Mon, 10 Feb 2020 17:29:36 GMT
+      X-Deere-Handling-Server:
+      - ip-10-214-45-99
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Deere-Elapsed-Ms:
+      - '96'
+    body:
+      encoding: UTF-8
+      string: ''
+    http_version: 
+  recorded_at: Mon, 10 Feb 2020 17:29:36 GMT
+- request:
+    method: delete
+    uri: https://sandboxapi.deere.com/platform/assets/00000000-0000-0000-0000-000000000000
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept:
+      - application/vnd.deere.axiom.v3+json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      User-Agent:
+      - OAuth gem v0.5.4
+      Authorization:
+      - OAuth oauth_consumer_key="johndeere-0000000000000000000000000000000000000000",
+        oauth_nonce="000000000000000000000000000000000000000000", oauth_signature="0000000000000000000000000000",
+        oauth_signature_method="HMAC-SHA1", oauth_timestamp="1581334172", oauth_token="00000000-0000-0000-0000-000000000000",
+        oauth_version="1.0"
+  response:
+    status:
+      code: 503
+      message: Service Unavailable
+    headers:
+      Date:
+      - Mon, 10 Feb 2020 17:29:36 GMT
+      X-Deere-Handling-Server:
+      - ip-10-214-45-99
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Deere-Elapsed-Ms:
+      - '96'
+    body:
+      encoding: UTF-8
+      string: ''
+    http_version: 
+  recorded_at: Mon, 10 Feb 2020 17:29:36 GMT
+- request:
+    method: delete
+    uri: https://sandboxapi.deere.com/platform/assets/00000000-0000-0000-0000-000000000000
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept:
+      - application/vnd.deere.axiom.v3+json
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      User-Agent:
+      - OAuth gem v0.5.4
+      Authorization:
+      - OAuth oauth_consumer_key="johndeere-0000000000000000000000000000000000000000",
+        oauth_nonce="000000000000000000000000000000000000000000", oauth_signature="0000000000000000000000000000",
+        oauth_signature_method="HMAC-SHA1", oauth_timestamp="1581334172", oauth_token="00000000-0000-0000-0000-000000000000",
+        oauth_version="1.0"
+  response:
+    status:
+      code: 204
+      message: No Content
+    headers:
+      Date:
+      - Mon, 10 Feb 2020 17:29:36 GMT
+      X-Deere-Handling-Server:
+      - ip-10-214-45-99
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Deere-Elapsed-Ms:
+      - '96'
+    body:
+      encoding: UTF-8
+      string: ''
+    http_version: 
+  recorded_at: Mon, 10 Feb 2020 17:29:36 GMT
+recorded_with: VCR 5.0.0