hoodoo 2.5.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82cf349eadbadcea2eaeb98421fb6a9e8b35dd5b0f037b2089ff553d99b650d0
-  data.tar.gz: 20564a912fb0e68505cb59721b081a61a64227b9676343180b117bcc9246a982
+  metadata.gz: bcd6275929dde876479da0087f2eef17e4d9fd3c8606182daeff2fd4c02c35c9
+  data.tar.gz: 3763e2d462802bbdae8240864e7bf73b83eb5458675da127af70edba8013dc1b
 SHA512:
-  metadata.gz: 555bb645bc07d3b4db3ff5341683ea98d5dfeea6a7dc1347723f892a36171da59f6faccb36e4a75e8a4b950c62c173b969e435e3eb8c37bb58319b5753be442c
-  data.tar.gz: 7f4c18b64388d17816227885ba6078d0ddc6fd009ede81e00b76e799c42e0e93b2033eec1e0a9bfb5417449cee5869fa0fc6b78da100873d6d2a00e3f50f92cd
+  metadata.gz: 6492416bb7afa5d8e7d9a23169293f055c73a6b9e8c63362f65b08ce7f49bd219874be90480ea7156c02373725e8088b19f9dfdda3a9ba2329b3037b7bc8b958
+  data.tar.gz: a8142c1c0973b77b1101af5f757b088b81a11bac48cce8597691288dcc288c8a786efd1ea6dd16820c44b9c222fb8df351cb739e6a2a6ea3e248f09b3943bacb

data/lib/hoodoo/services/middleware/exception_reporting/base_reporter.rb

@@ -162,7 +162,13 @@ module Hoodoo; module Services
                 :embeds              => context.request.embeds,
                 :references          => context.request.references,
                 :headers             => context.request.headers,
-                :list                => context.request.list.to_h
+                :list                => {
+                  :offset      => context.request.list.offset,
+                  :limit       => context.request.list.limit,
+                  :sort_data   => context.request.list.sort_data,
+                  :search_data => context.request.list.search_data,
+                  :filter_data => context.request.list.filter_data
+                }
               }
             }
 

data/lib/hoodoo/services/services/request.rb

@@ -64,31 +64,44 @@ module Hoodoo; module Services
         self.filter_data = {}
       end
 
-      # Represent the list data as a Hash, for uses such as persistence
-      # or loading into another session instance. The returned Hash is a
-      # full deep copy of any internal data; changing it will not alter
-      # the ListParameters object state.
+      # Represent the list data as a Hash, for uses such as persistence or
+      # loading into another session instance. The returned Hash is a full
+      # deep copy of any internal data; changing it will not alter the
+      # ListParameters object state.
       #
-      # Top-level keys in the Hash are Strings corresponding to the names
-      # of accessor parameters:
+      # Top-level keys in the Hash are Strings corresponding to fields
+      # supported by the query Hash in Hoodoo::Client::Endpoint#list,
+      # intentionally compatible so that pass-through / proxy scenarios from
+      # resource implementation to another resource are assisted:
       #
       #   * +"offset"+
       #   * +"limit"+
-      #   * +"sort_data"+
-      #   * +"search_data"+
-      #   * +"filter_data"+
+      #   * +"sort"+ (keys from the Hash under attribute #sort_data)
+      #   * +"direction"+ (values from the Hash under #sort_data)
+      #   * +"search"+ (deep-duplcated value of attribute #search_data)
+      #   * +"filter"+ (deep-duplcated value of attribute #filter_data)
       #
-      # Sort, search and filter data, if not empty, also have String keys.
+      # Sort, direction, search and filter data, if not empty, also have
+      # String keys / values. A single sort-direction key-value pair will be
+      # flattened to a simple value, while multiple sort-direction pairs are
+      # given as Arrays.
       #
       # See also #from_h!.
       #
       def to_h
+        sorts      = self.sort_data.keys.map( & :to_s )
+        directions = self.sort_data.values.map( & :to_s )
+
+        sorts      =      sorts.first if      sorts.count == 1
+        directions = directions.first if directions.count == 1
+
         {
-          'offset'      => self.offset,
-          'limit'       => self.limit,
-          'sort_data'   => Hoodoo::Utilities.deep_dup( self.sort_data   ),
-          'search_data' => Hoodoo::Utilities.deep_dup( self.search_data ),
-          'filter_data' => Hoodoo::Utilities.deep_dup( self.filter_data )
+          'offset'    => self.offset,
+          'limit'     => self.limit,
+          'sort'      => sorts,
+          'direction' => directions,
+          'search'    => Hoodoo::Utilities.deep_dup( self.search_data ),
+          'filter'    => Hoodoo::Utilities.deep_dup( self.filter_data )
         }
       end
 
@@ -99,9 +112,33 @@ module Hoodoo; module Services
       def from_h!( hash )
         self.offset      = hash[ 'offset' ] if hash.has_key?( 'offset' )
         self.limit       = hash[ 'limit'  ] if hash.has_key?( 'limit'  )
-        self.sort_data   = Hoodoo::Utilities.deep_dup( hash[ 'sort_data'   ] ) if hash[ 'sort_data'   ].is_a?( Hash )
-        self.search_data = Hoodoo::Utilities.deep_dup( hash[ 'search_data' ] ) if hash[ 'search_data' ].is_a?( Hash )
-        self.filter_data = Hoodoo::Utilities.deep_dup( hash[ 'filter_data' ] ) if hash[ 'filter_data' ].is_a?( Hash )
+        self.search_data = Hoodoo::Utilities.deep_dup( hash[ 'search' ] ) if hash[ 'search' ].is_a?( Hash )
+        self.filter_data = Hoodoo::Utilities.deep_dup( hash[ 'filter' ] ) if hash[ 'filter' ].is_a?( Hash )
+
+        sorts      = hash[ 'sort'      ]
+        directions = hash[ 'direction' ]
+
+        # Ensure the values are Arrays not just simple e.g. Strings,
+        # so that we can zip them up into a Hash for the 'sort_data'
+        # attribute value. Merge the result onto the existing values.
+        #
+        sorts      = [ sorts      ] unless      sorts.is_a?( Array )
+        directions = [ directions ] unless directions.is_a?( Array )
+
+             sorts.compact!
+        directions.compact!
+
+             sorts.concat( self.sort_data.keys[        sorts.count .. -1 ] || [] )
+        directions.concat( self.sort_data.values[ directions.count .. -1 ] || [] )
+
+        # The middleware enforces a URI query string match of the
+        # count of sort and direction specifiers, so we do the same.
+        #
+        if sorts.length != directions.length
+          raise 'Hoodoo::Services::Request::ListParameters#from_h!: Sort and direction array lengths must match'
+        end
+
+        self.sort_data = Hash[ sorts.zip( directions ) ]
       end
     end
 

data/lib/hoodoo/version.rb

@@ -12,11 +12,11 @@ module Hoodoo
   # The Hoodoo gem version. If this changes, be sure to re-run
   # <tt>bundle install</tt> or <tt>bundle update</tt>.
   #
-  VERSION = '2.5.0'
+  VERSION = '2.5.1'
 
   # The Hoodoo gem date. If this changes, be sure to re-run
   # <tt>bundle install</tt> or <tt>bundle update</tt>.
   #
-  DATE = '2018-05-17'
+  DATE = '2018-05-18'
 
 end

data/spec/services/middleware/exception_reporting/base_reporter_spec.rb

@@ -88,11 +88,11 @@ describe Hoodoo::Services::Middleware::ExceptionReporting::BaseReporter do
             :references          => [ 'r1', 'r2' ],
             :headers             => { 'HTTP_X_EXAMPLE' => '42' },
             :list                => {
-              'offset'      => 0,
-              'limit'       => 50,
-              'sort_data'   => { 'created_at' => 'desc' },
-              'search_data' => { 'example'    => '42'   },
-              'filter_data' => { 'unexample'  => '24'   }
+              :offset      => 0,
+              :limit       => 50,
+              :sort_data   => { 'created_at' => 'desc' },
+              :search_data => { 'example'    => '42'   },
+              :filter_data => { 'unexample'  => '24'   }
             }
           },
           :session => Hoodoo::Services::Middleware.test_session().to_h()

data/spec/services/services/request_spec.rb

@@ -65,6 +65,71 @@ describe Hoodoo::Services::Request do
     end
   end
 
+  # ==========================================================================
+
+  # Used for #list sub-tests around "#from_h!", where we want to ensure that
+  # a Hash containing less-than-all possible keys results in updates to just
+  # the relevant attributes of the target object.
+  #
+  # Provide a Hash of *attribute* key-value pairs for new values to assign,
+  # except for the special cases of Arrays in 'sort' and 'direction', which
+  # are mapped to the 'sort_data' Hash.
+  #
+  # Iterates over all the possible keys above and builds a Hash that contains
+  # just one at a time. Makes a new Request, sets the list options from the
+  # one-at-a-time Hash and verifies that only the one parameter changed.
+  #
+  # A little fiddly due to the name mappings "search"/"search_data" or
+  # "filter"/"filter_data" and the unpacking of "sort_data" into independently
+  # alterable "sort" and "direction" lists. Tests sort/direction flattening of
+  # single element arrays into simple types in passing.
+  #
+  def test_replacements( replacements )
+    replacements.each do | replacement_key, replacement_value |
+      request = Hoodoo::Services::Request.new
+      clean   = {
+        'offset'      => request.list.offset,
+        'limit'       => request.list.limit,
+        'sort_data'   => request.list.sort_data,
+        'search_data' => request.list.search_data,
+        'filter_data' => request.list.filter_data
+      }
+
+      from_h_key = case replacement_key
+        when 'search_data'
+          'search'
+        when 'filter_data'
+          'filter'
+        else
+          replacement_key
+      end
+
+      hash = { from_h_key => replacement_value }
+      request.list.from_h!( hash )
+
+      clean.each do | clean_key, clean_value |
+        expected_value = replacement_value # Makes code below easier to read
+
+        if clean_key == 'sort_data' && replacement_key == 'sort'
+          # In passing, test 1-element-array flattening...
+          expected_value = expected_value.first if expected_value.is_a?( Array ) && expected_value.count == 1
+          expect( request.list.send( clean_key ) ).to eql( { expected_value => clean_value.values.first } )
+
+        elsif clean_key == 'sort_data' && replacement_key == 'direction'
+          expected_value = expected_value.first if expected_value.is_a?( Array ) && expected_value.count == 1
+          expect( request.list.send( clean_key ) ).to eql( { clean_value.keys.first => expected_value } )
+
+        elsif clean_key == replacement_key
+          expect( request.list.send( clean_key ) ).to eql( expected_value )
+
+        else
+          expect( request.list.send( clean_key ) ).to eql( clean_value )
+
+        end
+      end
+    end
+  end
+
   context '#list' do
     it 'has correct default values' do
       expect( @r.list.offset      ).to eq( 0                          )
@@ -74,149 +139,268 @@ describe Hoodoo::Services::Request do
       expect( @r.list.filter_data ).to eq( {}                         )
     end
 
-    context 'and hashes via' do
-      before :each do
-        @offset = 1000
-        @limit  = 500
-        @sort   = { 'created_at' => 'asc' }
-        @search = { 'foo' => 'bar', 'bar' => { 'baz' => 3 } }
-        @filter = { 'bar' => 'foo', 'baz' => { 'bar' => 2 } }
-
-        @replacement_hash = {
-          'offset'      => @offset,
-          'limit'       => @limit,
-          'sort_data'   => @sort,
-          'search_data' => @search,
-          'filter_data' => @filter
-        }
-      end
+    it 'supports deprecated accessors' do
+      lo = 10
+      ll = 20
+      ke = 'foo'
+      di = 'asc'
+      sd = { :foo => :bar }
+      fd = { :baz => :foo }
+
+      @r.list_offset         = lo
+      @r.list_limit          = ll
+      @r.list_sort_data      = { ke => di }
+      @r.list_search_data    = sd
+      @r.list_filter_data    = fd
 
-      context '#to_h' do
+      expect( @r.list_offset         ).to eq( lo           )
+      expect( @r.list_limit          ).to eq( ll           )
+      expect( @r.list_sort_data      ).to eq( { ke => di } )
+      expect( @r.list_search_data    ).to eq( sd           )
+      expect( @r.list_filter_data    ).to eq( fd           )
+    end
+
+    # ========================================================================
+
+    context 'with a single sort key and direction' do
+      context 'and via' do
         before :each do
-          @r.list.offset      = @offset
-          @r.list.limit       = @limit
-          @r.list.sort_data   = @sort
-          @r.list.search_data = @search
-          @r.list.filter_data = @filter
+          @offset = 1000
+          @limit  = 500
+          @sort   = { 'new_sort' => 'asc' }
+          @search = { 'foo' => 'bar', 'bar' => { 'baz' => 3 } }
+          @filter = { 'bar' => 'foo', 'baz' => { 'bar' => 2 } }
+
+          @replacement_hash = {
+            'offset'    => @offset,
+            'limit'     => @limit,
+            'sort'      => @sort.keys.first,
+            'direction' => @sort.values.first,
+            'search'    => @search,
+            'filter'    => @filter
+          }
         end
 
-        it 'returns the expected Hash' do
-          expect( @r.list.to_h ).to eq( @replacement_hash )
-        end
+        context '#to_h' do
+          before :each do
+            @r.list.offset      = @offset
+            @r.list.limit       = @limit
+            @r.list.sort_data   = @sort
+            @r.list.search_data = @search
+            @r.list.filter_data = @filter
+          end
 
-        it 'deep-duplicates the parameters' do
-          result = @r.list.to_h()
+          it 'returns the expected Hash' do
+            expect( @r.list.to_h ).to eq( @replacement_hash )
+          end
 
-          old_sort_value = @sort[ @sort.keys.first ]
-          result[ 'sort_data' ][ @sort.keys.first ] == 'changed'
-          expect( @sort[ @sort.keys.first ] ).to eql( old_sort_value )
+          it 'deep-duplicates the parameters' do
+            result = @r.list.to_h()
 
-          old_search_value = @search[ @search.keys.first ]
-          result[ 'search_data' ][ @search.keys.first ] == 'changed'
-          expect( @search[ @search.keys.first ] ).to eql( old_search_value )
+            old_search_value = @search.values.first
+            result[ 'search' ][ @search.keys.first ] = 'changed'
+            expect( @search.values.first ).to eql( old_search_value )
 
-          old_filter_value = @filter[ @filter.keys.first ]
-          result[ 'filter_data' ][ @filter.keys.first ] == 'changed'
-          expect( @filter[ @filter.keys.first ] ).to eql( old_filter_value )
+            old_filter_value = @filter.values.first
+            result[ 'filter' ][ @filter.keys.first ] = 'changed'
+            expect( @filter.values.first ).to eql( old_filter_value )
+          end
         end
-      end
 
-      context '#from_h!' do
-        it 'overwrites all parameters' do
-          request = Hoodoo::Services::Request.new
+        context '#from_h!' do
+          it 'overwrites all parameters' do
+            request = Hoodoo::Services::Request.new
+
+            expect( request.list.offset      ).to eq( 0                          )
+            expect( request.list.limit       ).to eq( 50                         )
+            expect( request.list.sort_data   ).to eq( { 'created_at' => 'desc' } )
+            expect( request.list.search_data ).to eq( {}                         )
+            expect( request.list.filter_data ).to eq( {}                         )
 
-          expect( request.list.offset      ).to eq( 0                          )
-          expect( request.list.limit       ).to eq( 50                         )
-          expect( request.list.sort_data   ).to eq( { 'created_at' => 'desc' } )
-          expect( request.list.search_data ).to eq( {}                         )
-          expect( request.list.filter_data ).to eq( {}                         )
+            request.list.from_h!( @replacement_hash )
 
-          request.list.from_h!( @replacement_hash )
+            expect( request.list.offset      ).to eq( @offset )
+            expect( request.list.limit       ).to eq( @limit  )
+            expect( request.list.sort_data   ).to eq( @sort   )
+            expect( request.list.search_data ).to eq( @search )
+            expect( request.list.filter_data ).to eq( @filter )
+          end
 
-          expect( request.list.offset      ).to eq( @offset )
-          expect( request.list.limit       ).to eq( @limit  )
-          expect( request.list.sort_data   ).to eq( @sort   )
-          expect( request.list.search_data ).to eq( @search )
-          expect( request.list.filter_data ).to eq( @filter )
+          it 'overwrites only provided parameters' do
+            test_replacements( {
+              'offset'      => @offset,
+              'limit'       => @limit,
+              'sort'        => @sort.keys.first,
+              'direction'   => @sort.values.first,
+              'search_data' => @search,
+              'filter_data' => @filter
+            } )
+          end
         end
 
-        it 'overwrites only provided parameters' do
-          replacements = {
-            'offset'      => @offset,
-            'limit'       => @limit,
-            'sort_data'   => @sort,
-            'search_data' => @search,
-            'filter_data' => @filter
-          }
+        context '#to_h and #from_h! together' do
+          before :each do
+            @r.list.offset      = @offset
+            @r.list.limit       = @limit
+            @r.list.sort_data   = @sort
+            @r.list.search_data = @search
+            @r.list.filter_data = @filter
+          end
 
-          # Iterate over all the possible keys above and build a Hash that
-          # contains just one at a time. Make a new request, set the list
-          # options from the one-at-a-time Hash and verify that only that
-          # one parameter changed.
+          it 'translates from one list to another' do
+            hash = @r.list.to_h
 
-          replacements.each do | replacement_key, replacement_value |
             request = Hoodoo::Services::Request.new
-            clean   = {
-              'offset'      => request.list.offset,
-              'limit'       => request.list.limit,
-              'sort_data'   => request.list.sort_data,
-              'search_data' => request.list.search_data,
-              'filter_data' => request.list.filter_data
-            }
-
-            hash = { replacement_key => replacement_value }
             request.list.from_h!( hash )
 
-            clean.each do | clean_key, clean_value |
-              if clean_key == replacement_key
-                expect( request.list.send( clean_key ) ).to eql( replacement_value )
-              else
-                expect( request.list.send( clean_key ) ).to eql( clean_value )
-              end
-            end
+            expect( request.list.to_h ).to eql( @replacement_hash )
           end
         end
       end
+    end
 
-      context '#to_h and #from_h! together' do
+    # ========================================================================
+
+    context 'with multiple sort keys and directions' do
+      context 'and via' do
         before :each do
-          @r.list.offset      = @offset
-          @r.list.limit       = @limit
-          @r.list.sort_data   = @sort
-          @r.list.search_data = @search
-          @r.list.filter_data = @filter
+          @offset = 1000
+          @limit  = 500
+          @sort   = { 'new_sort' => 'asc', 'another_new_sort' => 'asc' }
+          @search = { 'foo' => 'bar', 'bar' => { 'baz' => 3 } }
+          @filter = { 'bar' => 'foo', 'baz' => { 'bar' => 2 } }
+
+          @replacement_hash = {
+            'offset'    => @offset,
+            'limit'     => @limit,
+            'sort'      => @sort.keys,
+            'direction' => @sort.values,
+            'search'    => @search,
+            'filter'    => @filter
+          }
         end
 
-        it 'translates from one list to another' do
-          hash = @r.list.to_h
+        context '#to_h' do
+          before :each do
+            @r.list.offset      = @offset
+            @r.list.limit       = @limit
+            @r.list.sort_data   = @sort
+            @r.list.search_data = @search
+            @r.list.filter_data = @filter
+          end
 
-          request = Hoodoo::Services::Request.new
-          request.list.from_h!( hash )
+          it 'returns the expected Hash' do
+            expect( @r.list.to_h ).to eq( @replacement_hash )
+          end
 
-          expect( request.list.to_h ).to eql( @replacement_hash )
+          it 'deep-duplicates the parameters' do
+            result = @r.list.to_h()
+
+            old_sort_key = @sort.keys.first
+            result[ 'sort' ][ 0 ] = 'changed'
+            expect( @sort.keys.first ).to eql( old_sort_key )
+
+            old_sort_value = @sort.values.first
+            result[ 'direction' ][ 0 ] = 'changed'
+            expect( @sort.values.first ).to eql( old_sort_value )
+          end
+        end
+
+        context '#from_h!' do
+          it 'overwrites all parameters' do
+            request = Hoodoo::Services::Request.new
+
+            expect( request.list.offset      ).to eq( 0                          )
+            expect( request.list.limit       ).to eq( 50                         )
+            expect( request.list.sort_data   ).to eq( { 'created_at' => 'desc' } )
+            expect( request.list.search_data ).to eq( {}                         )
+            expect( request.list.filter_data ).to eq( {}                         )
+
+            request.list.from_h!( @replacement_hash )
+
+            expect( request.list.offset      ).to eq( @offset )
+            expect( request.list.limit       ).to eq( @limit  )
+            expect( request.list.sort_data   ).to eq( @sort   )
+            expect( request.list.search_data ).to eq( @search )
+            expect( request.list.filter_data ).to eq( @filter )
+          end
+
+          context 'overwrites only provided parameters' do
+            it 'with single element sort/direction arrays' do
+              test_replacements( {
+                'offset'      => @offset,
+                'limit'       => @limit,
+                'sort'        => [ @sort.keys.first   ],
+                'direction'   => [ @sort.values.first ],
+                'search_data' => @search,
+                'filter_data' => @filter
+              } )
+            end
+
+            # The default Request object has only one 'sort_data' key-value
+            # pair, so if we tried to replace "one half" of that with more
+            # elements, we should get an exception about mismatched lengths.
+            #
+            context 'with multi-element sort/direction arrays' do
+              it 'and raises an exception if changing sort only' do
+                expect {
+                  request = Hoodoo::Services::Request.new
+                  request.list.from_h!( { 'sort' => @sort.keys } )
+                }.to raise_error( RuntimeError, 'Hoodoo::Services::Request::ListParameters#from_h!: Sort and direction array lengths must match' )
+              end
+
+              it 'and raises an exception if changing direction only' do
+                expect {
+                  request = Hoodoo::Services::Request.new
+                  request.list.from_h!( { 'direction' => @sort.keys } )
+                }.to raise_error( RuntimeError, 'Hoodoo::Services::Request::ListParameters#from_h!: Sort and direction array lengths must match' )
+              end
+
+              it 'and works if changing sort and direction' do
+                request = Hoodoo::Services::Request.new
+                request.list.from_h!( { 'sort' => @sort.keys, 'direction' => @sort.values } )
+                expect( request.list.sort_data ).to eql( @sort )
+              end
+            end
+          end
         end
       end
     end
 
-    it 'supports deprecated accessors' do
-      lo = 10
-      ll = 20
-      ke = 'foo'
-      di = 'asc'
-      sd = { :foo => :bar }
-      fd = { :baz => :foo }
+    # ========================================================================
+
+    context '#from_h!' do
+      context 'edge case' do
+        context 'of mismatched sort and direction arrays' do
+          it 'raises an exception' do
+            expect {
+              request = Hoodoo::Services::Request.new
+              request.list.from_h!( { 'sort' => [ '1', '2' ], 'direction' => [ '1', '2', '3' ] } )
+            }.to raise_error( RuntimeError, 'Hoodoo::Services::Request::ListParameters#from_h!: Sort and direction array lengths must match' )
+
+            expect {
+              request = Hoodoo::Services::Request.new
+              request.list.from_h!( { 'sort' => [ '1', '2', '3' ], 'direction' => [ '1', '2' ] } )
+            }.to raise_error( RuntimeError, 'Hoodoo::Services::Request::ListParameters#from_h!: Sort and direction array lengths must match' )
+          end
+        end
 
-      @r.list_offset         = lo
-      @r.list_limit          = ll
-      @r.list_sort_data      = { ke => di }
-      @r.list_search_data    = sd
-      @r.list_filter_data    = fd
+        context 'of nil sort keys and directions' do
+          it 'works if the arrays still match' do
+            request = Hoodoo::Services::Request.new
+            request.list.from_h!( { 'sort' => [ '1', nil, '2' ], 'direction' => [ '1', '2', nil ] } )
+            expect( request.list.sort_data ).to eql( { '1' => '1', '2' => '2' } )
+          end
 
-      expect( @r.list_offset         ).to eq( lo           )
-      expect( @r.list_limit          ).to eq( ll           )
-      expect( @r.list_sort_data      ).to eq( { ke => di } )
-      expect( @r.list_search_data    ).to eq( sd           )
-      expect( @r.list_filter_data    ).to eq( fd           )
+          it 'raises an exception if the arrays then mismatch' do
+            expect {
+              request = Hoodoo::Services::Request.new
+              request.list.from_h!( { 'sort' => [ '1', '2', '3' ], 'direction' => [ '1', '2', nil ] } )
+            }.to raise_error( RuntimeError, 'Hoodoo::Services::Request::ListParameters#from_h!: Sort and direction array lengths must match' )
+          end
+        end
+      end
     end
-  end
-end
+
+  end # "context '#list' do"
+end   # "describe Hoodoo::Services::Request do"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hoodoo
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.5.1
 platform: ruby
 authors:
 - Loyalty New Zealand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-17 00:00:00.000000000 Z
+date: 2018-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dalli