right_develop 3.1.8 → 3.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 04ae23ffcb2adcaf347b19ff9f25fc3d4b179623
-  data.tar.gz: f272d7a94045c77748e6a4c5887082d56ab4c042
+  metadata.gz: f9bea4294ac48a9bb1c124143e96594b3993867c
+  data.tar.gz: 1817c459f9d80fea412f1e1e7a66c011c6629f0d
 SHA512:
-  metadata.gz: a80de468e508630973d7d859561e5a08dfa6dc1ec35dd33e9558bc1f2a2323e069ce91b2bede4486efdb8e7abbabc2ca96f4224180895a78f953edb4eb14fb28
-  data.tar.gz: 60e69d6668880d62ada2a1862319f109f8200dfa12969377c8bbc50c0c99a17391e75d361b2d156ee5095a9d96d73f2134f74cca56690eb33683a9f548b885d9
+  metadata.gz: 814de826f973fd7678c8723ea686bebc140aa18e39497e7d77d683c208dc6dddaa8895ab0bf121400c0005862ba01b49806c2ee9462863d4be55d27b71d20b5c
+  data.tar.gz: 65416ad1cbe5429b1e74b842449b739992f9d1e2d32e53569c209932f6ab8204e43c1596e576ff290d7995d15d393e9bfc62d3057b50bb4d28d7691bb8443e7e

data/VERSION

@@ -1 +1 @@
-3.1.8
+3.1.9

data/lib/right_develop/testing/clients/rest/requests/playback.rb

@@ -40,9 +40,10 @@ module RightDevelop::Testing::Client::Rest::Request
 
     # fake Net::HTTPResponse
     class FakeNetHttpResponse
-      attr_reader :code, :body, :elapsed_seconds, :call_count
+      attr_reader :code, :body, :delay_seconds, :elapsed_seconds, :call_count
 
       def initialize(response_hash, response_metadata)
+        @delay_seconds = response_metadata.delay_seconds
         @elapsed_seconds = Integer(response_hash[:elapsed_seconds] || 0)
         @code = response_metadata.http_status.to_s
         @headers = response_metadata.headers.inject({}) do |h, (k, v)|
@@ -140,6 +141,15 @@ module RightDevelop::Testing::Client::Rest::Request
           logger.debug("throttle delay = #{delay}")
           sleep delay
         end
+
+        # there may be a configured response delay (in addition to throttling)
+        # which allows for other responses to complete before the current
+        # response thread is unblocked. the response delay is absolute and not
+        # subject to the throttle factor.
+        if (delay = response.delay_seconds) > 0
+          logger.debug("configured response delay = #{delay}")
+          sleep delay
+        end
         log_response(response)
         process_result(response, &block)
       else
@@ -170,11 +180,15 @@ module RightDevelop::Testing::Client::Rest::Request
       file_path = nil
       past_epochs = state[:past_epochs] ||= []
       try_epochs = [state[:epoch]] + past_epochs
-      tried_paths = []
+      first_tried_path = nil
+      first_tried_epoch = nil
+      last_tried_epoch = nil
       try_epochs.each do |epoch|
         file_path = response_file_path(epoch)
         break if ::File.file?(file_path)
-        tried_paths << file_path
+        first_tried_path = file_path unless first_tried_path
+        first_tried_epoch = epoch unless first_tried_epoch
+        last_tried_epoch = epoch
         file_path = nil
       end
       if file_path
@@ -189,8 +203,10 @@ module RightDevelop::Testing::Client::Rest::Request
           response_hash[:body])
         result = FakeNetHttpResponse.new(response_hash, response_metadata)
       else
-        raise PLAYBACK_ERROR,
-              "Unable to locate response file(s): \"#{tried_paths.join("\", \"")}\""
+        msg = 'Unable to locate response file(s) in epoch range ' +
+              "[#{first_tried_epoch} - #{last_tried_epoch}]:\n  " +
+              first_tried_path.inspect
+        raise PLAYBACK_ERROR, msg
       end
       logger.debug("Played back response from #{file_path.inspect}.")
 

data/lib/right_develop/testing/recording/config.rb

@@ -52,7 +52,7 @@ module RightDevelop::Testing::Recording
 
     # keys allowed under the deep route configuration.
     ALLOWED_KINDS          = %w(request response)
-    ALLOWED_CONFIG_ACTIONS = %w(significant timeouts transform variables)
+    ALLOWED_CONFIG_ACTIONS = %w(delay_seconds significant timeouts transform variables)
     ALLOWED_TIMEOUTS       = %w(open_timeout read_timeout)
     ALLOWED_VARIABLE_TYPES = %w(body header query)
 
@@ -178,11 +178,15 @@ module RightDevelop::Testing::Recording
           # normalize routes for efficient usage but keep them separate from
           # user's config so that .to_hash returns something understandable and
           # JSONizable/YAMLable.
-          @normalized_routes = value.inject(RightSupport::Data::Mash.new) do |r, (k, v)|
+          mutable_routes = value.inject(RightSupport::Data::Mash.new) do |r, (k, v)|
             r[normalize_route_prefix(k)] = normalize_route_data(k, v)
             r
           end
-          @config_hash['routes'] = ::RightSupport::Data::HashTools.deep_clone(value)
+
+          # deep freeze routes to detect any case where code is unintentionally
+          # modifying the route hash.
+          @normalized_routes = ::RightSupport::Data::HashTools.deep_freeze!(mutable_routes)
+          @config_hash['routes'] = ::RightSupport::Data::HashTools.deep_clone2(value)
         else
           raise ConfigError, 'routes must be a hash'
         end
@@ -554,6 +558,15 @@ module RightDevelop::Testing::Recording
 
         rst[rst_k] = rst_v.inject(RightSupport::Data::Mash.new) do |kc, (kc_k, kc_v)|
           case kc_k
+          when METADATA_CLASS::DELAY_SECONDS_KEY
+            begin
+              kc_v = Float(kc_v)
+            rescue ::ArgumentError
+              location = position_string(position, subpath + [rst_k, kc_k])
+              message = 'Invalid route configuration delay_seconds value at ' +
+                        "#{location}: #{kc_v.inspect}"
+              raise ConfigError, message
+            end
           when METADATA_CLASS::TIMEOUTS_KEY
             # sanity check.
             kc_v = kc_v.inject(RightSupport::Data::Mash.new) do |h, (k, v)|

data/lib/right_develop/testing/recording/metadata.rb

@@ -43,11 +43,12 @@ module RightDevelop::Testing::Recording
     KINDS = %w(request response)
 
     # route-relative config keys.
-    MATCHERS_KEY    = 'matchers'.freeze
-    SIGNIFICANT_KEY = 'significant'.freeze
-    TIMEOUTS_KEY    = 'timeouts'.freeze
-    TRANSFORM_KEY   = 'transform'.freeze
-    VARIABLES_KEY   = 'variables'.freeze
+    DELAY_SECONDS_KEY = 'delay_seconds'.freeze
+    MATCHERS_KEY      = 'matchers'.freeze
+    SIGNIFICANT_KEY   = 'significant'.freeze
+    TIMEOUTS_KEY      = 'timeouts'.freeze
+    TRANSFORM_KEY     = 'transform'.freeze
+    VARIABLES_KEY     = 'variables'.freeze
 
     # finds the value index for a recorded variable, if any.
     VARIABLE_INDEX_REGEX = /\[(\d+)\]$/
@@ -83,6 +84,7 @@ module RightDevelop::Testing::Recording
     end
 
     # exceptions.
+    class ConfigurationError < StandardError; end
     class RecordingError < StandardError; end
     class PlaybackError < StandardError; end
 
@@ -142,11 +144,12 @@ module RightDevelop::Testing::Recording
 
       # apply the configuration by substituting for variables in the request and
       # by obfuscating wherever a variable name is nil.
+      erck = @effective_route_config[@kind]
       case @mode
       when 'validate'
-        # do nothing; used to validate the fixtures before playback, etc.
+        # used to validate the fixtures before playback; no variable
+        # substitution should be performed.
       else
-        erck = @effective_route_config[@kind]
         if effective_variables = erck && erck[VARIABLES_KEY]
           recursive_replace_variables(
             [@kind, VARIABLES_KEY],
@@ -154,10 +157,10 @@ module RightDevelop::Testing::Recording
             effective_variables,
             erck[TRANSFORM_KEY])
         end
-        if logger.debug?
-          logger.debug("#{@kind} effective_route_config = #{@effective_route_config[@kind].inspect}")
-          logger.debug("#{@kind} typenames_to_values = #{@typenames_to_values.inspect}")
-        end
+      end
+      if logger.debug?
+        logger.debug("#{@kind} effective_route_config = #{@effective_route_config[@kind].inspect}")
+        logger.debug("#{@kind} typenames_to_values = #{@typenames_to_values.inspect}")
       end
 
       # recreate headers and body from data using variable substitutions and
@@ -181,6 +184,12 @@ module RightDevelop::Testing::Recording
       @checksum ||= compute_checksum
     end
 
+    # @return [Float] delay in seconds (of response) from effective
+    #  configuration or empty
+    def delay_seconds
+      Float((@effective_route_config[@kind] || {})[DELAY_SECONDS_KEY] || 0)
+    end
+
     # @return [Hash] timeouts from effective configuration or empty
     def timeouts
       (@effective_route_config[@kind] || {})[TIMEOUTS_KEY] || {}
@@ -347,7 +356,7 @@ module RightDevelop::Testing::Recording
             # note that we never want to fail to proxy back a response because
             # the server doesn't know what JSON is; log a warning and continue.
             # this actually happens with Right API 1.5 health-check saying
-            # response is 'application/json' but returning "ok"
+            # response is 'application/json' but returning "\"ok\""
             logger.warn("Failed to parse JSON data from #{body.inspect}: #{e.class} #{e.message}")
           end
         else
@@ -377,10 +386,10 @@ module RightDevelop::Testing::Recording
       when ::Hash, ::Array
         body_hash = body
       when ::String
-        body_hash = parse_body(normalized_headers, body)
-        return body unless body_hash
-      else
-        return body
+        # use unparsed original body to avoid losing information when we are
+        # unable to parse or parse a literal JSON string as happens in the case
+        # of RightAPI's health-check.
+        return @body
       end
       case ct = compute_content_type(normalized_headers)
       when 'application/x-www-form-urlencoded'
@@ -433,11 +442,16 @@ module RightDevelop::Testing::Recording
               match_deep(@typenames_to_values[qualifier_type], qualifier_name_to_value)
             end
             if all_matched
+              # note that we must be careful to deep clone the existing result
+              # before merging as any previously-merged configuration (shared
+              # from the original configuration) would be modified by deep
+              # merging. use .deep_merge instead of .deep_merge!
+              #
               # the final data is the union of all configurations matching
               # this request path and qualifiers. the uri regex and other
               # data used to match the request parameters is eliminated from
               # the final configuration.
-              ::RightSupport::Data::HashTools.deep_merge!(result, configuration)
+              result = ::RightSupport::Data::HashTools.deep_merge(result, configuration)
             end
           end
         end
@@ -771,37 +785,15 @@ module RightDevelop::Testing::Recording
       significant_data = RightSupport::Data::Mash.new(verb: @verb)
       significant_data[:http_status] = @http_status if @http_status
 
-      # headers
-      copy_if_significant(:header, significant, significant_data)
-
-      # query
-      unless copy_if_significant(:query, significant, significant_data)
-        # entire query string is significant by default.
-        significant_data[:query] = @typenames_to_values[:query]
-      end
-
-      # body
-      unless copy_if_significant(:body, significant, significant_data)
-        case body_value = @typenames_to_values[:body]
-        when nil
-          # body is either nil, empty or was not parsable; insert the checksum
-          # of the original body.
-          case @body
-          when nil, '', ' '
-            significant_data[:body_checksum] = 'empty'
-          else
-            significant_data[:body_checksum] = ::Digest::MD5.hexdigest(@body)
-          end
-        else
-          # body was parsed but no single element was considered significant.
-          # use the parsed body so that it can be 'normalized' in sorted order.
-          significant_data[:body] = body_value
-        end
+      # significance by type.
+      [:header, :query, :body].each do |type|
+        copy_if_significant(type, significant, significant_data)
       end
 
       # use deep-sorted JSON to prevent random ordering changing the checksum.
       checksum_data = self.class.deep_sorted_json(significant_data)
-      if logger.debug? && @mode != 'validate'
+      if logger.debug?
+        logger.debug("#{@kind} significant = #{significant.inspect}")
         logger.debug("#{@kind} checksum_data = #{checksum_data.inspect}")
       end
       ::Digest::MD5.hexdigest(checksum_data)
@@ -815,41 +807,138 @@ module RightDevelop::Testing::Recording
     # @param [Hash] significant selectors
     # @param [Hash] significant_data to populate
     #
-    # @return [TrueClass|FalseClass] true if any were significant
+    # @return [TrueClass] always true
     def copy_if_significant(type, significant, significant_data)
-      if significant_type = significant[type]
-        significant_data[type] = recursive_selective_hash_copy(
-          RightSupport::Data::Mash.new, @typenames_to_values[type], significant_type)
-        true
+      case significant_type = significant[type]
+      when nil
+        # no explicit significance declared; use the default behavior for type.
+        default_copy_if_significant(type, significant_data)
+      when false
+        # no fields are significant; copy nothing.
+      when true
+        # all fields are significant; copy everything.
+        significant_data[type] = @typenames_to_values[type]
       else
-        false
+        # recursively copy significant values from hash.
+        significant_data[type] = recursive_selective_hash_copy(
+          @typenames_to_values[type],
+          significant_type,
+          [type])
       end
+      true
     end
 
-    # Recursively selects and copies values from source to target.
-    def recursive_selective_hash_copy(target, source, selections, path = [])
-      selections.each do |k, v|
-        case v
+    # Copies fields by type only if considered significant by default.
+    #
+    # @param [String|Symbol] type of significance
+    # @param [Hash] significant_data to populate
+    #
+    # @return [TrueClass] always true
+    def default_copy_if_significant(type, significant_data)
+      case type
+      when :header
+        # headers are insignificant by default
+      when :query
+        significant_data[:query] = @typenames_to_values[:query]
+      when :body
+        case body_value = @typenames_to_values[:body]
         when nil
-          # hash to nil; user configured by using flat hashes instead of arrays.
-          # it's a style thing that makes the YAML look prettier.
-          copy_hash_value(target, source, path + [k])
-        when ::Array
-          # also supporting arrays of names at top level or under a hash.
-          v.each { |item| copy_hash_value(target, source, path + [item]) }
-        when ::Hash
-          # recursion.
-          recursive_selective_hash_copy(target, source, v, path + [k])
+          # body is either nil, empty or was not parsable; insert the checksum
+          # of the original body.
+          case @body
+          when nil, '', ' '
+            significant_data[:body_checksum] = 'empty'
+          else
+            significant_data[:body_checksum] = ::Digest::MD5.hexdigest(@body)
+          end
+        else
+          # body was parsed but no single element was considered significant.
+          # use the parsed body so that it can be 'normalized' in sorted order.
+          significant_data[:body] = body_value
         end
+      else
+        raise ::NotImplementedError,
+              "Unexpected significant type: #{type.inspect}"
       end
-      target
+      true
     end
 
-    # copies a single value between hashes by path.
-    def copy_hash_value(target, source, path)
-      value = ::RightSupport::Data::HashTools.deep_get(source, path)
-      ::RightSupport::Data::HashTools.deep_set!(target, path, value)
-      true
+    # Recursively selects values from source.
+    #
+    # @param [Object] source for selection
+    # @param [Object] selections to perform
+    # @param [Array] log_path as array of keys or indexes for logging only
+    #
+    # @return [Object] target of same type as source
+    #
+    def recursive_selective_hash_copy(source, selections, log_path)
+      return nil if source.nil?
+      result = nil
+      case selections
+      when nil, true
+        # hash to nil or true; nil means that user configured by using flat
+        # hashes instead of arrays, which is a style thing that makes the YAML
+        # look prettier. true means explictly consider all elements at current
+        # key to be significant.
+        result = ::RightSupport::Data::HashTools.deep_clone2(source)
+      when false
+        # explicitly declared nothing at current level to be significant.
+      when ::Array
+        # supporting special case of an array of all key names as a list of
+        # significant hash key/values.
+        if selections.all? { |item| item.is_a?(::String) || item.is_a?(::Symbol) }
+          # select hash values by listed keys.
+          unless source.kind_of?(::Hash)
+            msg = 'Mismatched significant qualifier with source type at ' +
+                  "#{log_path.join('/')}: #{source.class}"
+            raise ::ConfigurationError, msg
+          end
+          selections.each do |k|
+            source_value = source[k]
+            unless source_value.nil?
+              result ||= ::RightSupport::Data::Mash.new
+              result[k] = ::RightSupport::Data::HashTools.deep_clone2(source_value)
+            end
+          end
+        else
+          # select specific hash elements of array with specific significance.
+          # if a particular element has no siginificance then its selector can
+          # be a literal false or else it can fall off the end of the listed
+          # selectors.
+          unless source.kind_of?(::Array)
+            msg = 'Mismatched significant qualifier with source type at ' +
+                  "#{log_path.join('/')}: #{source.class}"
+            raise ::ConfigurationError, msg
+          end
+          selections.each_with_index do |item, idx|
+            if idx < source.size
+              result ||= []
+              result << recursive_selective_hash_copy(
+                source[idx], item, log_path + ["[#{idx}]"])
+            else
+              break
+            end
+          end
+        end
+      when ::Hash
+        unless source.kind_of?(::Hash)
+          msg = 'Mismatched significant qualifier with source type at ' +
+                "#{log_path.join('/')}: #{source.class}"
+          raise ::ConfigurationError, msg
+        end
+        selections.each do |k, v|
+          target = recursive_selective_hash_copy(source[k], v, log_path + [k])
+          unless target.nil?
+            result ||= ::RightSupport::Data::Mash.new
+            result[k] = target
+          end
+        end
+        result
+      else
+        raise ::ConfigurationError,
+              "Unexpected significant value type at #{log_path.join('/')}: #{v.class}"
+      end
+      result
     end
 
   end # Metadata

data/lib/right_develop/testing/servers/might_api/Gemfile

@@ -2,4 +2,4 @@ source 'https://rubygems.org'
 
 gem 'rack'
 gem 'rest-client'
-gem 'right_support', '>= 2.8.31'
+gem 'right_support', '>= 2.8.38'

data/lib/right_develop/testing/servers/might_api/Gemfile.lock

@@ -5,7 +5,7 @@ GEM
     rack (1.5.2)
     rest-client (1.6.7)
       mime-types (>= 1.16)
-    right_support (2.8.31)
+    right_support (2.8.38)
 
 PLATFORMS
   ruby
@@ -13,4 +13,4 @@ PLATFORMS
 DEPENDENCIES
   rack
   rest-client
-  right_support (>= 2.8.31)
+  right_support (>= 2.8.38)

data/lib/right_develop/testing/servers/might_api/lib/config.rb

@@ -140,16 +140,18 @@ module RightDevelop::Testing::Server::MightApi
               # load request/response pair to validate.
               request_file_path = ::File.join(requests_dir, path)
               response_file_path = ::File.join(responses_dir, path)
+              logger.debug("Normalizing request #{request_file_path.inspect} ...")
               request_data = RightSupport::Data::Mash.new(::YAML.load_file(request_file_path))
               response_data = RightSupport::Data::Mash.new(::YAML.load_file(response_file_path))
 
               # if confing contains unreachable (i.e. no available route) files
               # then that is ignorable.
               query_string = request_data[:query]
+              path_parent = ::File.dirname(path)
               uri = METADATA_CLASS.normalize_uri(
                 URI::HTTP.build(
                   host:  'none',
-                  path:  (route_path + ::File.dirname(path)),
+                  path:  path_parent == '.' ? route_path : (route_path + path_parent),
                   query: request_data[:query]).to_s)
 
               # compute checksum from recorded request metadata.

data/right_develop.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: right_develop 3.1.8 ruby lib
+# stub: right_develop 3.1.9 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "right_develop"
-  s.version = "3.1.8"
+  s.version = "3.1.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Tony Spataro"]
-  s.date = "2014-11-11"
+  s.date = "2014-12-01"
   s.description = "A toolkit of development tools created by RightScale."
   s.email = "support@rightscale.com"
   s.executables = ["right_develop"]
@@ -81,7 +81,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "https://github.com/rightscale/right_develop"
   s.licenses = ["MIT"]
-  s.rubygems_version = "2.2.0"
+  s.rubygems_version = "2.2.2"
   s.summary = "Reusable dev & test code."
 
   if s.respond_to? :specification_version then

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: right_develop
 version: !ruby/object:Gem::Version
-  version: 3.1.8
+  version: 3.1.9
 platform: ruby
 authors:
 - Tony Spataro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-11 00:00:00.000000000 Z
+date: 2014-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: right_support
@@ -249,7 +249,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Reusable dev & test code.