bond-spy 0.1.0 → 0.2.0

data/bond.gemspec

@@ -3,7 +3,7 @@ require_relative 'lib/bond/version'
 Gem::Specification.new do |spec|
   spec.name          = 'bond-spy'
   spec.version       = Bond::VERSION
-  spec.date          = '2016-01-28'
+  spec.date          = '2016-02-04'
 
   spec.authors       = ['George Necula', 'Erik Krogen']
   spec.email         = ['necula@cs.berkeley.edu', 'erikkrogen@gmail.com']
@@ -30,6 +30,7 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'bin'
 
   spec.required_ruby_version = '>= 2.1'
+  spec.add_runtime_dependency 'neatjson', '~> 0.6'
   spec.add_development_dependency 'bundler', '~> 1.10'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'

data/lib/bond.rb

@@ -1,5 +1,5 @@
 require 'singleton'
-require 'json'
+require 'neatjson'
 require 'fileutils'
 require 'shellwords'
 
@@ -79,14 +79,18 @@ class Bond
   #     - `:abort` - don't accept any new changes
   #     - `:accept` - accept all new changes
   #     - `:kdiff3` - use the kdiff3 graphical merge tool to reconcile differences
+  # @param decimal_precision The precision to use when serializing Float and Double values.
+  #     If not specified, defaults to 4 decimal places.
   #
   def start_test(rspec_test, test_name: nil, spy_groups: nil,
-                 observation_directory: nil, reconcile: nil)
+                 observation_directory: nil, reconcile: nil,
+                 decimal_precision: nil)
 
     @observations = []
     @spy_agents = Hash.new { |hash, key|
       hash[key] = []
     }
+    @decimal_precision = decimal_precision.nil? ? 4 : decimal_precision
     @observation_directory = nil
     @current_test = rspec_test
     @reconcile = reconcile
@@ -116,18 +120,26 @@ class Bond
   # @param spy_point_name [#to_s] The name of this spy point. Will be used to subsequently
   #     refer to this point for, e.g., {#deploy_agent}. This name also gets printed as
   #     part of the observation with the key `__spy_point__`.
+  # @param skip_save_observation [Boolean] Whether or not to skip recording the observation
+  #     created during this call to spy; other agent actions are enabled regardless. This is
+  #     used by {BondTargetable#spy_point} to enable `mock_only` spy points.
   # @param observation Keyword arguments which should be observed.
   # @return if an agent has been set for this spy point, this will return whatever value
   #     is specified by that agent. Otherwise, returns `:agent_result_none`.
-  def spy(spy_point_name=nil, **observation)
+  def spy(spy_point_name=nil, skip_save_observation=false, **observation)
     return :agent_result_none unless active? # If we're not testing, don't do anything
 
     spy_point_name = spy_point_name.nil? ? nil : spy_point_name.to_s
 
     observation[:__spy_point__] = spy_point_name unless spy_point_name.nil?
-    observation = deep_clone_sort_hashes(observation)
+    observation = deep_clone(observation)
     active_agent = spy_point_name.nil? ? nil : @spy_agents[spy_point_name].find { |agent| agent.process?(observation) }
 
+    do_save_observation = !skip_save_observation
+    unless active_agent.nil? or active_agent.skip_save_observation.nil?
+      do_save_observation = !active_agent.skip_save_observation
+    end
+
     res = :agent_result_none
     begin
       unless active_agent.nil?
@@ -135,10 +147,12 @@ class Bond
         res = active_agent.result(observation)
       end
     ensure
-      formatted = format_observation(observation, active_agent)
-      @observations <<= formatted
-      #TODO ETK printing
-      puts "Observing: #{formatted} #{", returning <#{res.to_s}>" if res != :agent_result_none}"
+      if do_save_observation
+        formatted = format_observation(observation, active_agent)
+        @observations <<= formatted
+        #TODO ETK printing
+        puts "Observing: #{formatted} #{", returning <#{res.to_s}>" if res != :agent_result_none}"
+      end
     end
 
     res
@@ -170,28 +184,20 @@ class Bond
   #     (new changes are not accepted), returns `:bond_fail`. Else returns `:pass`
   def finish_test
     fname = observation_file_name
-    fdir = File.dirname(fname)
-    unless File.directory?(fdir)
-      FileUtils.mkdir_p(fdir)
-      top_git_ignore = File.join(observation_directory, '.gitignore')
-      unless File.file?(top_git_ignore)
-        # TODO ETK make this configurable in case you don't use git?
-        File.open(top_git_ignore, 'w') do |outfile|
-          outfile.print("*_now.json\n*.diff\n")
-        end
-      end
+    
+    if @current_test.exception.nil?
+      test_fail = nil
+    else
+      test_fail = "Test had failure(s): #{@current_test.exception}\n#{@current_test.exception.backtrace.join("\n")}"
     end
 
-    test_fail = !@current_test.exception.nil?
-
     ref_file = fname + '.json'
     cur_file = fname + '_now.json'
     File.delete(cur_file) if File.exists?(cur_file)
     save_observations(cur_file)
 
-    reconcile_result = reconcile_observations(ref_file, cur_file,
-                                              test_fail ? 'Test had failure(s)!' : nil)
-    return :test_fail if test_fail
+    reconcile_result = reconcile_observations(ref_file, cur_file, test_fail)
+    return :test_fail unless test_fail.nil?
     return reconcile_result
   ensure
     @current_test = nil
@@ -272,29 +278,29 @@ class Bond
   # @return The formatted hash.
   def format_observation(observation, agent = nil)
     # TODO ETK actually have formatters
-    JSON.pretty_generate(observation, indent: ' '*4)
+    JSON.neat_generate(observation, sorted: true, decimals: @decimal_precision,
+                       indent: ' '*4, wrap: true, after_colon: 1)
   end
 
-  # Deep-clones an object while sorting any Hashes at any depth:
+  # Deep-clones an object
   #
-  # - Hash: Creates a new hash containing all of the old key-value
-  #         pairs sorted by key
-  # - Array: Creates a new array with the old contents *not* sorted
+  # - Hash: Creates a new hash containing all of the old key-value pairs
+  # - Array: Creates a new array with the old contents
   # - Other: Attempts to call Object#clone. If this fails (results in #TypeError)
   #          then the object is returned as-is (assumes that non-cloneable objects
   #          are immutable and thus don't need cloning)
   #
   # @param obj The object to be cloned.
-  # @return The deep-clone with hashes sorted.
-  def deep_clone_sort_hashes(obj)
+  # @return The deep-clone.
+  def deep_clone(obj)
     if obj.is_a?(Hash)
       {}.tap do |new|
-        obj.sort.each do |k, v|
-          new[k] = deep_clone_sort_hashes(v)
+        obj.each do |k, v|
+          new[k] = deep_clone(v)
         end
       end
-    elsif obj.is_a?(Array) # Don't sort arrays, just clone
-      obj.map { |x| deep_clone_sort_hashes(x) }
+    elsif obj.is_a?(Array)
+      obj.map { |x| deep_clone(x) }
     else
       begin
         obj.clone
@@ -353,10 +359,17 @@ class SpyAgent
   #           formatting.
   #
   #     - Keys that control how the observation is saved. This is processed after all
-  #       the above functions. **NOT YET AVAILABLE**
+  #       the above functions.
   #
   #         - `formatter: func` - If specified, a function that is given the observation and
   #           can update it in place. The formatted observation is what gets serialized and saved.
+  #           **NOT YET AVAILABLE**
+  #         - `skip_save_observation: Boolean` - If specified, determines whether or not the
+  #           observation will be saved after all of the agent's other actions have been processed.
+  #           Useful for hiding observations of a spy point that e.g. is sometimes useful but in some
+  #           tests is irrelevant and clutters up the observations. This value, if present, will override
+  #           the `skip_save_observation` parameter of {Bond#spy} and the `mock_only` parameter of
+  #           {BondTargetable#spy_point}.
   #
   def initialize(**opts)
     # TODO ETK needs formatters
@@ -364,6 +377,7 @@ class SpyAgent
     @exception_spec = nil
     @doers = []
     @filters = []
+    @skip_save_observation = nil
 
     opts.each do |k, v|
       case k.to_s # Convert to string in case it was passed as a symbol
@@ -373,12 +387,16 @@ class SpyAgent
           @exception_spec = v
         when 'do'
           @doers = [*v]
+        when 'skip_save_observation'
+          @skip_save_observation = v
         else # Must be a filter
           @filters <<= SpyAgentFilter.new(k.to_s, v)
       end
     end
   end
 
+  attr_reader :skip_save_observation
+
   # Checks if this agent should process this observation
   # @return true iff this agent should process this observation
   def process?(observation)

data/lib/bond/targetable.rb

@@ -46,15 +46,21 @@ module BondTargetable
   #     names to exclude from the spy. Can be useful if you don't care about the value of some argument.
   # @param spy_result [Boolean] If true, spy on the return value. The spy point name will be
   #     `{spy_point_name}.result` and the key name will be `result`.
+  # @param mock_only [Boolean] If true, don't record calls to this method as observations.
+  #     This allows for the ability to mock a method without observing all of its calls, useful
+  #     if mocking e.g. a small utility method whose call order is unimportant. This can be
+  #     overridden by using the `skip_save_observation` parameter when deploying an agent
+  #     ({Bond#deploy_agent}).
   # @api public
   def spy_point(spy_point_name: nil, require_agent_result: false, excluded_keys: [],
-                spy_result: false)
+                spy_result: false, mock_only: false)
     @__last_annotation_args = {
         spy_point_name: spy_point_name,
         require_agent_result: require_agent_result,
         # Allow for a single key or an array of them, and map to_s in case they were passed as symbols
         excluded_keys: [*excluded_keys].map(&:to_s),
-        spy_result: spy_result
+        spy_result: spy_result,
+        mock_only: mock_only
     }
   end
 
@@ -147,7 +153,7 @@ module BondTargetable
       observation[name] = value unless options[:excluded_keys].include?(name.to_s)
     end
 
-    ret = Bond.instance.spy(spy_point_name, observation)
+    ret = Bond.instance.spy(spy_point_name, options[:mock_only], observation)
     if options[:require_agent_result] && ret == :agent_result_none
       raise "#{spy_point_name} requires mocking but received :agent_result_none"
     end

data/lib/bond/version.rb

@@ -1,3 +1,3 @@
 class Bond
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/bond_spec.rb

@@ -146,6 +146,22 @@ describe Bond do
       bond.spy(result: bond.spy('my_point'))
     end
 
+    it 'should skip saving observations when specified' do
+      bond.spy('skipped_point', skip_save_observation = true, key: 'value')
+
+      bond.deploy_agent('skipped_point', result: 'Mock Value')
+      ret = bond.spy('skipped_point', skip = true, key: 'value')
+      bond.spy('skipped_return_value', val: ret)
+
+      bond.deploy_agent('normal_point', skip_save_observation: false, result: 'Mock Value')
+      ret = bond.spy('normal_point', skip_save_observation = true, key: 'value')
+      bond.spy('not_skipped_return_value', val: ret)
+
+      bond.deploy_agent('skipped_point', skip_save_observation: true, result: 'Mock Value')
+      ret = bond.spy('skipped_point', key: 'value')
+      bond.spy('skipped_return_value', val: ret)
+    end
+
   end
 
   # TODO

data/spec/bond_targetable_spec.rb

@@ -45,6 +45,9 @@ describe BondTargetable do
     bond.spy_point(spy_point_name: 'spy_return', spy_result: true)
     def annotated_method_spy_return(arg1) 'return' end
 
+    bond.spy_point(spy_point_name: 'mock_only', mock_only: true)
+    def annotated_method_mock_only; 'return' end
+
     bond.spy_point
     def annotated_method_with_block(arg1, &blk) yield; end
 
@@ -142,6 +145,16 @@ describe BondTargetable do
       bond.deploy_agent('spy_return', result: 'new return')
       tc.annotated_method_spy_return('arg_value')
     end
+
+    it 'correctly respects mock_only' do
+      bond.spy('unmocked_return', val: tc.annotated_method_mock_only)
+
+      bond.deploy_agent('mock_only', result: 'mocked return')
+      bond.spy('mocked_return', val: tc.annotated_method_mock_only)
+
+      bond.deploy_agent('mock_only', skip_save_observation: false, result: 'mocked return')
+      bond.spy('mocked_return', val: tc.annotated_method_mock_only)
+    end
   end
 
   it 'correctly spies protected methods' do

data/spec/test_observations/bond_spec/Bond_with_agents_should_call_doers_before_returning_result.json

@@ -1,14 +1,14 @@
 [
 {
-  "__spy_point__": "internal_doer"
+    "__spy_point__": "internal_doer"
 },
 {
-  "__spy_point__": "internal_result"
+    "__spy_point__": "internal_result"
 },
 {
-  "__spy_point__": "my_point"
+    "__spy_point__": "my_point"
 },
 {
-  "result": "mocked"
+    "result": "mocked"
 }
 ]

data/spec/test_observations/bond_spec/Bond_with_agents_should_call_the_function_passed_as_result_if_it_is_callable.json

@@ -1,23 +1,23 @@
 [
 {
-  "__spy_point__": "my_point",
-  "obs_name": "foo"
+    "__spy_point__": "my_point",
+    "obs_name": "foo"
 },
 {
-  "result": 2
+    "result": 2
 },
 {
-  "__spy_point__": "my_point",
-  "obs_name": "bar"
+    "__spy_point__": "my_point",
+    "obs_name": "bar"
 },
 {
-  "result": "agent_result_none"
+    "result": "agent_result_none"
 },
 {
-  "__spy_point__": "my_point",
-  "obs_name": "foo"
+    "__spy_point__": "my_point",
+    "obs_name": "foo"
 },
 {
-  "result": 3
+    "result": 3
 }
 ]

data/spec/test_observations/bond_spec/Bond_with_agents_should_correctly_call_a_single_doer_if_filter_criteria_are_met.json

@@ -1,10 +1,10 @@
 [
 {
-  "__spy_point__": "internal",
-  "val": "value"
+    "__spy_point__": "internal",
+    "val": "value"
 },
 {
-  "__spy_point__": "my_point",
-  "my_key": "value"
+    "__spy_point__": "my_point",
+    "my_key": "value"
 }
 ]

data/spec/test_observations/bond_spec/Bond_with_agents_should_correctly_call_multiple_doers.json

@@ -1,13 +1,13 @@
 [
 {
-  "__spy_point__": "internal",
-  "val": 10
+    "__spy_point__": "internal",
+    "val": 10
 },
 {
-  "__spy_point__": "my_point",
-  "my_key": 10
+    "__spy_point__": "my_point",
+    "my_key": 10
 },
 {
-  "side_effect_value": 10
+    "side_effect_value": 10
 }
 ]

data/spec/test_observations/bond_spec/Bond_with_agents_should_not_call_doers_of_overriden_agents.json

@@ -1,8 +1,8 @@
 [
 {
-  "__spy_point__": "valid_agent"
+    "__spy_point__": "valid_agent"
 },
 {
-  "__spy_point__": "my_point"
+    "__spy_point__": "my_point"
 }
 ]

data/spec/test_observations/bond_spec/Bond_with_agents_should_skip_saving_observations_when_specified.json

@@ -0,0 +1,18 @@
+[
+{
+    "__spy_point__": "skipped_return_value",
+    "val": "Mock Value"
+},
+{
+    "__spy_point__": "normal_point",
+    "key": "value"
+},
+{
+    "__spy_point__": "not_skipped_return_value",
+    "val": "Mock Value"
+},
+{
+    "__spy_point__": "skipped_return_value",
+    "val": "Mock Value"
+}
+]

data/spec/test_observations/bond_spec/Bond_with_agents_should_throw_an_exception_if_specified_by_agent.json

@@ -1,9 +1,9 @@
 [
 {
-  "__spy_point__": "my_point"
+    "__spy_point__": "my_point"
 },
 {
-  "__spy_point__": "rescue_point",
-  "except": "TypeError exception!"
+    "__spy_point__": "rescue_point",
+    "except": "TypeError exception!"
 }
 ]

data/spec/test_observations/bond_spec/Bond_with_agents_should_throw_the_result_of_the_value_passed_to_exception_if_callable.json

@@ -1,10 +1,10 @@
 [
 {
-  "__spy_point__": "my_point",
-  "key": "Value passed to exception"
+    "__spy_point__": "my_point",
+    "key": "Value passed to exception"
 },
 {
-  "__spy_point__": "rescue_point",
-  "except": "Value passed to exception"
+    "__spy_point__": "rescue_point",
+    "except": "Value passed to exception"
 }
 ]