suture 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb83b84ac62cb811bdb3dcdd170aff6f8269fb3a
-  data.tar.gz: c5388bb1365857898de1de7743d5929d1fce620c
+  metadata.gz: 00233003cd21f9ec984925ed6fbc2f5a03ce9671
+  data.tar.gz: 526640d66eed549a7e7943f3ef2c459b1bfcd315
 SHA512:
-  metadata.gz: 3b01812aa2186bf0004864320e64308b3f40c68efa0e84e2549e4581599776a15ff3b8f2612a34bbf92790a518bc09ce96ee6df4fd56a2420e535528c535da42
-  data.tar.gz: bed8680f9b57cf5c789ab4d03347e0e2a9fe2415db9d7c98cd4f860a03613cb8f5ea22e187d5c16bc18c079a4b759454129bcbe1ba363bb9b18f5072deedc1a4
+  metadata.gz: 9b19ab9fd1965a1ac8b41522b4cbd9b5cad966616c4e3518bb41ad120375e324cf341d1bb5bd735b2cc341e28a8b00ffd108e1db7c25e3eb1d934016b52233c1
+  data.tar.gz: 53ceca44a97179bb4a256357d6ae3c587b9c67751c7aebc63fdf0c5637c9888f081e32d8b0f371f353b0a2c987b43d54fb295512c2830b0ea6e71c9062c2b40b

data/.projections.json

@@ -0,0 +1,5 @@
+{
+  "*": { "make": "bundle exec rake" },
+  "lib/*.rb": {"alternate": "test/{}_test.rb"},
+  "test/*_test.rb": {"alternate": "lib/{}.rb"}
+}

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+sudo: false
+before_install: gem install bundler
+rvm:
+  - 1.8.7
+  - 1.9
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3.1

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2016 Test Double, LLC
+
+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

@@ -1,5 +1,7 @@
 # Suture
 
+[![Build Status](https://travis-ci.org/testdouble/suture.svg?branch=master)](https://travis-ci.org/testdouble/suture)
+
 A refactoring tool for Ruby, designed to make it safe to change code you don't
 confidently understand. In fact, changing untrustworthy code is so fraught,
 Suture hopes to make it safer to completely reimplement a code path.

data/lib/suture/adapter/dictaphone.rb

@@ -1,18 +1,30 @@
 require "suture/wrap/sqlite"
+require "suture/value/observation"
+require "suture/error/observation_conflict"
 
 module Suture::Adapter
   class Dictaphone
-    def initialize
-      @db = Suture::Wrap::Sqlite.init
+    def initialize(plan)
+      @db = Suture::Wrap::Sqlite.init(plan.database_path)
+      @name = plan.name
+      @args = plan.args
     end
 
-    def record(name, args, result)
+    def record(result)
       Suture::Wrap::Sqlite.insert(@db, :observations, [:name, :args, :result],
-                                  [name.to_s, Marshal.dump(args), Marshal.dump(result)])
+                                  [@name.to_s, Marshal.dump(@args), Marshal.dump(result)])
+
+    rescue SQLite3::ConstraintException => e
+      old_result = result_for(@name, @args)
+      if old_result != result # TODO - use comparator
+        raise Suture::Error::ObservationConflict.new(@name, @args, result, old_result)
+      else
+        # We're all good here, it was just a duplicative observation. No harm.
+      end
     end
 
-    def play(name)
-      rows = Suture::Wrap::Sqlite.select(@db, :observations, "where name = ?", [name.to_s])
+    def play
+      rows = Suture::Wrap::Sqlite.select(@db, :observations, "where name = ?", [@name.to_s])
       rows.map do |row|
         Suture::Value::Observation.new(
           row[0],
@@ -22,5 +34,17 @@ module Suture::Adapter
         )
       end
     end
+
+  private
+
+    def result_for(name, args)
+      rows = Suture::Wrap::Sqlite.select(
+        @db,
+        :observations,
+        "where name = ? and args = ?",
+        [name.to_s, Marshal.dump(args)]
+      )
+      Marshal.load(rows.first[3])
+    end
   end
 end

data/lib/suture/builds_plan.rb

@@ -1,22 +1,17 @@
+require "suture/value/plan"
+require "suture/util/env"
+
 module Suture
   class BuildsPlan
     UN_ENV_IABLE_OPTIONS = [:name, :old, :new, :args]
 
     def build(name, options = {})
-      Value::Plan.new(options.merge(:name => name).merge(env))
-    end
-
-  private
-
-    def env
-      Hash[ENV.keys.
-          select { |k| k.start_with?("SUTURE_") }.
-          map { |k| [env_var_name_to_option_name(k), ENV[k]] }].
-          reject { |(k,v)| UN_ENV_IABLE_OPTIONS.include?(k) }
-    end
-
-    def env_var_name_to_option_name(name)
-      name.gsub(/^SUTURE\_/,'').downcase.to_sym
+      Value::Plan.new(
+        DEFAULT_OPTIONS.
+          merge(options).
+          merge(:name => name).
+          merge(Suture::Util::Env.to_map(UN_ENV_IABLE_OPTIONS))
+      )
     end
   end
 end

data/lib/suture/chooses_surgeon.rb

@@ -1,3 +1,6 @@
+require "suture/surgeon/observer"
+require "suture/surgeon/no_op"
+
 module Suture
   class ChoosesSurgeon
     def choose(plan)

data/lib/suture/error/observation_conflict.rb

@@ -0,0 +1,43 @@
+module Suture::Error
+  class ObservationConflict < StandardError
+    def initialize(name, args, new_result, old_result)
+      @name = name
+      @args = args
+      @new_result = new_result
+      @old_result = old_result
+    end
+
+    def message
+      <<-MSG.gsub(/^\s{8}/,'')
+        At suture #{@name.inspect} with inputs `#{@args.inspect}`, the newly-observed return value `#{@new_result.inspect}`
+        conflicts with previously recorded return value `#{@old_result.inspect}`.
+
+        That's not good! Here are a few ideas of what may have happened:
+
+        1. The old code path may have a side effect that results in different
+           return values. If it's possible, to create the suture at a point after
+           this side effect. Otherwise, read on.
+
+        2. Either environmental differents (e.g. system time resulting in a
+           different timestamp) or side effects (e.g. saving to a database
+           resulting in a different GUID value) mean that Suture is detecting two
+           different results for the same inputs. This can be worked around by
+           providing a custom comparator for the two values nearest common
+           ancestor type. Comparator support is tracked here:
+             https://github.com/testdouble/suture/issues/14
+
+        3. If neither of the above are true, it's possible that the old code path
+           was changed while still in the early stage of recording characterization
+           calls (presumably by mistake). If such a change may have occurred in
+           error, check your git history. Otherwise, perhaps you `record_calls` is
+           accidentally still enabled and should be turned off for this suture
+           (either with SUTURE_RECORD_CALLS=false or :record_calls => false).
+
+        4. If the old recording was made in error, then you may want to delete it
+           Deletion support via the Suture API is tracked here:
+             https://github.com/testdouble/suture/issues/10
+
+      MSG
+    end
+  end
+end

data/lib/suture/error/schema_version.rb

@@ -0,0 +1,12 @@
+module Suture::Error
+  class SchemaVersion < StandardError
+    def initialize(expected, actual)
+      @expected = expected
+      @actual = actual
+    end
+
+    def message
+      "Your suture gem is too #{@expected > @actual ? "new" : "old"} for this schema. Either delete your database or #{@expected > @actual ? "upgrade" : "downgrade"} the gem (expected schema version #{@expected}, was #{@actual})"
+    end
+  end
+end

data/lib/suture/error/verification_failed.rb

@@ -0,0 +1,12 @@
+module Suture::Error
+  class VerificationFailed < StandardError
+    def initialize(test_results)
+      super
+      @test_results = test_results
+    end
+
+    # def message
+    # end
+
+  end
+end

data/lib/suture/interprets_results.rb

@@ -0,0 +1,12 @@
+require "suture/error/verification_failed"
+
+module Suture
+  class InterpretsResults
+    def interpret(test_results)
+      return unless test_results.failed?
+      raise Suture::Error::VerificationFailed.new(test_results)
+    end
+  end
+end
+
+

data/lib/suture/prescribes_test_plan.rb

@@ -0,0 +1,19 @@
+require "suture/value/test_plan"
+require "suture/util/env"
+
+module Suture
+  class PrescribesTestPlan
+    UN_ENV_IABLE_OPTIONS = [:name, :subject, :args]
+    DEFAULT_TEST_OPTIONS = {
+      :fail_fast => true
+    }
+
+    def prescribe(name, options = {})
+      Value::TestPlan.new(DEFAULT_OPTIONS.
+                          merge(DEFAULT_TEST_OPTIONS).
+                          merge(options).
+                          merge(:name => name).
+                          merge(Suture::Util::Env.to_map(UN_ENV_IABLE_OPTIONS)))
+    end
+  end
+end

data/lib/suture/surgeon/observer.rb

@@ -2,13 +2,10 @@ require "suture/adapter/dictaphone"
 
 module Suture::Surgeon
   class Observer
-    def initialize
-      @dictaphone = Suture::Adapter::Dictaphone.new
-    end
-
     def operate(plan)
+      dictaphone = Suture::Adapter::Dictaphone.new(plan)
       plan.old.call(*plan.args).tap do |result|
-        @dictaphone.record(plan.name, plan.args, result)
+        dictaphone.record(result)
       end
     end
   end

data/lib/suture/tests_patient.rb

@@ -0,0 +1,38 @@
+require "suture/adapter/dictaphone"
+require "suture/value/test_results"
+
+module Suture
+  class TestsPatient
+    def test(test_plan)
+      dictaphone = Suture::Adapter::Dictaphone.new(test_plan)
+      experienced_failure_in_life = false
+      Value::TestResults.new(dictaphone.play.map { |observation|
+        if test_plan.fail_fast && experienced_failure_in_life
+          {
+            :observation => observation,
+            :ran => false
+          }
+        else
+          invoke(test_plan, observation).merge({
+            :observation => observation,
+            :ran => true
+          }).tap { |r| experienced_failure_in_life = true unless r[:passed]}
+        end
+      })
+    end
+
+    def invoke(test_plan, observation)
+      {}.tap do |result|
+        begin
+          result[:new_result] = test_plan.subject.call(*observation.args)
+          # TODO: Comparators go here:
+          result[:passed] = result[:new_result] == observation.result
+        rescue StandardError => e
+          result[:passed] = false
+          result[:error] = e
+        end
+      end
+    end
+  end
+end
+

data/lib/suture/util/env.rb

@@ -0,0 +1,22 @@
+module Suture::Util
+  module Env
+    def self.to_map(excludes)
+      Hash[
+        ENV.keys.
+            select { |k| k.start_with?("SUTURE_") }.
+            map { |k| [to_sym(k), sanitize_value(ENV[k])] }
+      ].reject { |(k,v)| excludes.include?(k) }
+    end
+
+    # private
+
+    def self.to_sym(name)
+      name.gsub(/^SUTURE\_/,'').downcase.to_sym
+    end
+
+    def self.sanitize_value(value)
+      return false if value == "false"
+      value
+    end
+  end
+end

data/lib/suture/value/plan.rb

@@ -1,12 +1,13 @@
 module Suture::Value
   class Plan
-    attr_reader :name, :old, :new, :args, :record_calls
+    attr_reader :name, :old, :new, :args, :record_calls, :database_path
     def initialize(attrs = {})
       @name = attrs[:name]
       @old = attrs[:old]
       @new = attrs[:new]
       @args = attrs[:args]
       @record_calls = !!attrs[:record_calls]
+      @database_path = attrs[:database_path]
     end
   end
 end

data/lib/suture/value/test_plan.rb

@@ -0,0 +1,12 @@
+module Suture::Value
+  class TestPlan
+    attr_accessor :name, :subject, :args, :fail_fast, :database_path
+    def initialize(attrs = {})
+      @name = attrs[:name]
+      @subject = attrs[:subject]
+      @args = attrs[:args]
+      @fail_fast = attrs[:fail_fast]
+      @database_path = attrs[:database_path]
+    end
+  end
+end

data/lib/suture/value/test_results.rb

@@ -0,0 +1,38 @@
+module Suture::Value
+  class TestResults
+    attr_reader :results
+
+    def initialize(results)
+      @results = results
+    end
+
+    def failed?
+      @results.any? { |r| !r[:passed] }
+    end
+
+    def ran_all_tests?
+      @results.all? { |r| r[:ran] }
+    end
+
+    def total_count
+      @results.size
+    end
+
+    def passed_count
+      @results.count { |r| r[:passed] }
+    end
+
+    def failed_count
+      @results.count { |r| !r[:passed] && r[:ran] }
+    end
+
+    def errored_count
+      @results.count { |r| r[:error] }
+    end
+
+    def skipped_count
+      @results.count { |r| !r[:ran] }
+    end
+  end
+end
+

data/lib/suture/version.rb

@@ -1,3 +1,3 @@
 module Suture
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/suture/wrap/sqlite.rb

@@ -1,24 +1,45 @@
 require "fileutils"
-require "SQLite3"
+require "sqlite3"
+require "suture/error/schema_version"
 
 module Suture::Wrap
   module Sqlite
-    def self.init
-      FileUtils.mkdir_p(File.join(Dir.getwd, "db"))
-      SQLite3::Database.new("db/suture.sqlite3").tap do |db|
+    SCHEMA_VERSION=1
+    def self.init(location)
+      full_path = File.join(Dir.getwd, location)
+      FileUtils.mkdir_p(File.dirname(full_path))
+      SQLite3::Database.new(full_path).tap do |db|
+        db.execute <<-SQL
+          create table if not exists schema_info (
+            version integer unique
+          );
+        SQL
+        db.execute("insert or ignore into schema_info values (?)", [SCHEMA_VERSION])
+        actual_schema_version = db.execute("select * from schema_info").first[0]
+        if SCHEMA_VERSION != actual_schema_version
+          raise Suture::Error::SchemaVersion.new(SCHEMA_VERSION, actual_schema_version)
+        end
+
         db.execute <<-SQL
           create table if not exists observations (
             id integer primary key,
             name varchar(255),
             args clob,
-            result clob
+            result clob,
+            unique(name, args)
           );
         SQL
       end
     end
 
     def self.insert(db, table, cols, vals)
-      db.execute("insert into #{table} (#{cols.join(", ")}) values (?,?,?)", vals)
+      sql = <<-SQL
+        insert into #{table}
+          (#{cols.join(", ")})
+        values
+          (#{vals.size.times.map { "?" }.join(", ")})
+      SQL
+      db.execute(sql, vals)
     end
 
     def self.select(db, table, where_clause, bind_params)

data/lib/suture.rb

@@ -1,16 +1,29 @@
 require "suture/version"
 
-require "suture/surgeon"
-require "suture/value"
-
 require "suture/builds_plan"
 require "suture/chooses_surgeon"
 require "suture/performs_surgery"
 
+require "suture/prescribes_test_plan"
+require "suture/tests_patient"
+require "suture/interprets_results"
+
 module Suture
+  DEFAULT_OPTIONS = {
+    :database_path => "db/suture.sqlite3"
+  }
+
   def self.create(name, options)
     plan = BuildsPlan.new.build(name, options)
     surgeon = ChoosesSurgeon.new.choose(plan)
     PerformsSurgery.new.perform(plan, surgeon)
   end
+
+  def self.verify(name, options)
+    test_plan = Suture::PrescribesTestPlan.new.prescribe(name, options)
+    test_results = Suture::TestsPatient.new.test(test_plan)
+    if test_results.failed?
+      Suture::InterpretsResults.new.interpret(test_results)
+    end
+  end
 end

data/suture.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "pry", "~> 0.9.12.6"
   spec.add_development_dependency "minitest", "~> 5.9"
   spec.add_development_dependency "gimme", "~> 0.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: suture
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Justin Searls
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-19 00:00:00.000000000 Z
+date: 2016-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: 0.9.12.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: 0.9.12.6
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -103,7 +103,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".projections.json"
+- ".travis.yml"
 - Gemfile
+- LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
@@ -112,13 +115,20 @@ files:
 - lib/suture/adapter/dictaphone.rb
 - lib/suture/builds_plan.rb
 - lib/suture/chooses_surgeon.rb
+- lib/suture/error/observation_conflict.rb
+- lib/suture/error/schema_version.rb
+- lib/suture/error/verification_failed.rb
+- lib/suture/interprets_results.rb
 - lib/suture/performs_surgery.rb
-- lib/suture/surgeon.rb
+- lib/suture/prescribes_test_plan.rb
 - lib/suture/surgeon/no_op.rb
 - lib/suture/surgeon/observer.rb
-- lib/suture/value.rb
+- lib/suture/tests_patient.rb
+- lib/suture/util/env.rb
 - lib/suture/value/observation.rb
 - lib/suture/value/plan.rb
+- lib/suture/value/test_plan.rb
+- lib/suture/value/test_results.rb
 - lib/suture/version.rb
 - lib/suture/wrap/sqlite.rb
 - suture.gemspec

data/lib/suture/surgeon.rb

@@ -1,2 +0,0 @@
-require "suture/surgeon/no_op"
-require "suture/surgeon/observer"

data/lib/suture/value.rb

@@ -1,2 +0,0 @@
-require "suture/value/observation"
-require "suture/value/plan"