blood_contracts 0.2.1 → 1.0.0

data/.travis.yml

@@ -1,5 +0,0 @@
-sudo: false
-language: ruby
-rvm:
-  - 2.4.1
-before_install: gem install bundler -v 1.16.1

data/lib/blood_contracts/base_contract.rb

@@ -1,42 +0,0 @@
-module BloodContracts
-  class BaseContract
-    extend Dry::Initializer
-    option :action
-
-    class << self
-      def rules
-        @rules ||= Set.new
-      end
-
-      def contract_rule(name, &block)
-        define_method("_#{name}", block)
-        rules << name
-      end
-    end
-
-    def call(data)
-      return yield(data) if block_given?
-      action.call(data)
-    end
-
-    def contract
-      @contract ||= Hash[
-        self.class.rules.map { |name| [name, {check: method("_#{name}")}] }
-      ]
-    end
-
-    def build_storage(name)
-      s = Storage.new(contract_name: name)
-      s.input_writer  = method(:input_writer)  if defined? input_writer
-      s.output_writer = method(:output_writer) if defined? output_writer
-      s.input_serializer  = input_serializer   if defined? input_serializer
-      s.output_serializer = output_serializer  if defined? output_serializer
-      s.meta_serializer   = meta_serializer    if defined? meta_serializer
-      s
-    end
-
-    def to_contract_suite(name: self.class.to_s.pathize)
-      Suite.new(storage: build_storage(name), contract: contract)
-    end
-  end
-end

data/lib/blood_contracts/contracts/description.rb

@@ -1,25 +0,0 @@
-module BloodContracts
-  module Contracts
-    class Description
-      def self.call(contract_hash)
-        Hashie::Mash.new(contract_hash).map do |name, rule|
-          rule_description = " - '#{name}' "
-          if rule.threshold
-            rule_description << <<~TEXT
-              in more then #{(rule.threshold * 100).round(2)}% of cases;
-            TEXT
-          elsif rule.limit
-            rule_description << <<~TEXT
-              in less then #{(rule.limit * 100).round(2)}% of cases;
-            TEXT
-          else
-            rule_description << <<~TEXT
-              in any number of cases;
-            TEXT
-          end
-          rule_description
-        end.compact.join
-      end
-    end
-  end
-end

data/lib/blood_contracts/contracts/iterator.rb

@@ -1,34 +0,0 @@
-module BloodContracts
-  module Contracts
-    class Iterator
-      extend Dry::Initializer
-
-      param :iterations, ->(v) do
-        v = ENV["iterations"] if ENV["iterations"]
-        v.to_i.positive? ? v.to_i : 1
-      end
-      param :time_to_run, ->(v) do
-        v = ENV["duration"] if ENV["duration"]
-        v.to_f if v.to_f.positive?
-      end, optional: true
-
-      def next
-        return iterations.times { yield } unless time_to_run
-
-        @iterations = iterations_from_time_to_run { yield }
-        [iterations - 1, 0].max.times { yield }
-      end
-
-      def count
-        @iterations
-      end
-
-      protected
-
-      def iterations_from_time_to_run
-        time_per_action = Benchmark.measure { yield }
-        (time_to_run / time_per_action.real).ceil
-      end
-    end
-  end
-end

data/lib/blood_contracts/contracts/matcher.rb

@@ -1,38 +0,0 @@
-module BloodContracts
-  module Contracts
-    class Matcher
-      extend Dry::Initializer
-
-      param :contract_hash, ->(v) { Hashie::Mash.new(v) }
-
-      def call(input, output, meta = Hash.new, storage:)
-        options = Hashie::Mash.new(input: input, output: output, meta: meta)
-
-        rule_names = select_matched_rules!(options).keys
-        rule_names = [Storage::UNDEFINED_RULE] if rule_names.empty?
-        Array(rule_names).each(&storage.method(:store))
-
-        yield rule_names, options if block_given?
-
-        !storage.found_unexpected_behavior?
-      end
-
-      private
-
-      def with_rule_options(rule_name, options)
-        rule_options = options.shallow_merge(meta: {})
-        result = yield(rule_options)
-        options.meta.merge!(rule_name.to_sym => rule_options.meta)
-        result
-      end
-
-      def select_matched_rules!(options)
-        contract_hash.select do |name, rule|
-          with_rule_options(name, options) do |rule_options|
-            rule.check.call(rule_options)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/blood_contracts/contracts/statistics.rb

@@ -1,34 +0,0 @@
-module BloodContracts
-  module Contracts
-    class Statistics
-      extend Dry::Initializer
-      param :iterator
-      option :storage, default: -> { Hash.new(0) }
-
-      def store(rule)
-        storage[rule] += 1
-      end
-
-      def to_h
-        Hash[storage.map { |rule_name, times| [rule_name, rule_stats(times)] }]
-      end
-
-      def to_s
-        to_h.map do |name, occasions|
-          " - '#{name}' happened #{occasions.times} time(s) "\
-          "(#{(occasions.percent * 100).round(2)}% of the time)"
-        end.join("; \n")
-      end
-
-      def found_unexpected_behavior?
-        storage.key?(Storage::UNDEFINED_RULE)
-      end
-
-      private
-
-      def rule_stats(times)
-        Hashie::Mash.new(times: times, percent: (times.to_f / iterator.count))
-      end
-    end
-  end
-end

data/lib/blood_contracts/contracts/validator.rb

@@ -1,47 +0,0 @@
-module BloodContracts
-  module Contracts
-    class Validator
-      extend Dry::Initializer
-
-      param :contract_hash, ->(v) { Hashie::Mash.new(v) }
-
-      def valid?(statistics)
-        return if statistics.found_unexpected_behavior?
-
-        last_run_stats = statistics.to_h
-        expectations.all? do |rule, check|
-          percent = last_run_stats[rule.name]&.percent || 0.0
-          check.call(percent, rule)
-        end
-      end
-
-      private
-
-      def expectations
-        Hash[
-          contract_hash.map do |name, rule|
-            if rule.threshold
-              [rule.merge(name: name), method(:threshold_check)]
-            elsif rule.limit
-              [rule.merge(name: name), method(:limit_check)]
-            else
-              [rule.merge(name: name), method(:anyway)]
-            end
-          end.compact
-        ]
-      end
-
-      def threshold_check(value, rule)
-        value > rule.threshold
-      end
-
-      def limit_check(value, rule)
-        value <= rule.limit
-      end
-
-      def anyway(_value, _rule)
-        true
-      end
-    end
-  end
-end

data/lib/blood_contracts/debugger.rb

@@ -1,39 +0,0 @@
-module BloodContracts
-  class Debugger < Runner
-    def runs
-      @runs ||= storage.find_all_samples(ENV["debug"]).each
-    end
-
-    def iterations
-      runs.size
-    end
-
-    def call
-      return super if debugging_samples?
-      true
-    end
-
-    def description
-      return super if debugging_samples?
-      "be skipped in current debugging session"
-    end
-
-    private
-
-    def match_rules?(matches_storage:)
-      matcher.call(*storage.load_sample(runs.next), storage: matches_storage)
-    end
-
-    def unexpected_further_investigation
-      ENV["debug"]
-    end
-
-    def further_investigation
-      ENV["debug"]
-    end
-
-    def debugging_samples?
-      runs.size.positive?
-    end
-  end
-end

data/lib/blood_contracts/runner.rb

@@ -1,92 +0,0 @@
-require_relative "contracts/validator"
-require_relative "contracts/matcher"
-require_relative "contracts/description"
-require_relative "contracts/iterator"
-require_relative "contracts/statistics"
-
-module BloodContracts
-  class Runner
-    extend Dry::Initializer
-
-    param :checking_proc
-
-    option :suite
-    option :storage, default: -> { suite.storage }
-
-    option :iterations, default: -> { 1 }
-    option :time_to_run, optional: true
-    option :stop_on_unexpected, default: -> { false }
-    option :iterator, default: -> do
-      Contracts::Iterator.new(iterations, time_to_run)
-    end
-
-    option :context, optional: true
-
-    option :statistics, default: -> { Contracts::Statistics.new(iterator) }
-    option :matcher,   default: -> { Contracts::Matcher.new(suite.contract) }
-    option :validator, default: -> { Contracts::Validator.new(suite.contract) }
-    option :contract_description, default: -> do
-      Contracts::Description.call(suite.contract)
-    end
-
-    def call
-      return false if :halt == catch(:unexpected_behavior) do
-        iterator.next do
-          next if match_rules?(matches_storage: statistics) do
-            input = suite.data_generator.call
-            [input, checking_proc.call(input)]
-          end
-          throw :unexpected_behavior, :halt if stop_on_unexpected
-        end
-      end
-      validator.valid?(statistics)
-    end
-
-    # FIXME: Move to locales
-    def failure_message
-      intro = "expected that given Proc would meet the contract:"
-
-      if stats.unexpected_behavior?
-        "#{intro}\n#{contract_description}\n"\
-        " during #{iterator.count} run(s) but got unexpected behavior.\n\n"\
-        "For further investigations open: #{storage.unexpected_suggestion}"
-      else
-        "#{intro}\n#{contract_description}\n"\
-          " during #{iterator.count} run(s) but got:\n#{statistics}\n\n"\
-          "For further investigations open: #{storage.suggestion}"
-      end
-    end
-
-    # FIXME: Move to locales
-    def description
-      "meet the contract:\n#{contract_description} \n"\
-      " during #{iterator.count} run(s). Stats:\n#{statistics}\n\n"\
-      "For further investigations open: #{storage.suggestion}\n"
-    end
-
-    protected
-
-    def match_rules?(matches_storage:)
-      matcher.call(*yield, storage: matches_storage) do |rules, options|
-        storage.store(options: options, rules: rules, context: context)
-      end
-    rescue StandardError => error
-      # FIXME: Possible recursion?
-      # Write test about error in the storage#store (e.g. writing error)
-      store_exception(error, input, output, context)
-      raise
-    end
-
-    def store_exception(error, input, output, context)
-      storage.store(
-        options: {
-          input: input,
-          output: output || {},
-          meta: {exception: error},
-        },
-        rules: [Storage::EXCEPTION_CAUGHT],
-        context: context,
-      )
-    end
-  end
-end

data/lib/blood_contracts/storage.rb

@@ -1,79 +0,0 @@
-require_relative "./storages/base_backend.rb"
-require_relative "./storages/file_backend.rb"
-require_relative "./storages/serializer.rb"
-
-module BloodContracts
-  class Storage
-    extend Dry::Initializer
-    extend Forwardable
-
-    Serializer = BloodContracts::Storages::Serializer
-    FileBackend = BloodContracts::Storages::FileBackend
-
-    option :contract_name
-
-    DEFAULT_WRITER = -> (options) do
-      "INPUT:\n#{options.input}\n\n#{'=' * 90}\n\nOUTPUT:\n#{options.output}"
-    end
-
-    option :input_writer,
-           ->(v) { valid_writer(v) }, default: -> { DEFAULT_WRITER }
-    option :output_writer,
-           ->(v) { valid_writer(v) }, default: -> { DEFAULT_WRITER }
-
-    option :input_serializer,
-           ->(v) { Serializer.call(v) }, default: -> { default_serializer }
-    option :output_serializer,
-           ->(v) { Serializer.call(v) }, default: -> { default_serializer }
-    option :meta_serializer,
-           ->(v) { Serializer.call(v) }, default: -> { default_serializer }
-
-    option :backend, default: -> { FileBackend.new(self, contract_name) }
-
-    def_delegators :@backend, :sample_exists?,
-                   :load_sample, :find_all_samples,
-                   :serialize_sample, :describe_sample,
-                   :suggestion, :unexpected_suggestion
-
-    def self.valid_writer(writer)
-      return writer if writer.respond_to?(:call) || writer.respond_to?(:to_sym)
-      raise ArgumentError
-    end
-
-    def input_serializer=(serializer)
-      @input_serializer = Serializer.call(serializer)
-    end
-
-    def output_serializer=(serializer)
-      @output_serializer = Serializer.call(serializer)
-    end
-
-    def meta_serializer=(serializer)
-      @meta_serializer = Serializer.call(serializer)
-    end
-
-    def input_writer=(writer)
-      @input_writer = self.class.valid_writer(writer)
-    end
-
-    def output_writer=(writer)
-      @output_writer = self.class.valid_writer(writer)
-    end
-
-    UNDEFINED_RULE = :__no_tag_match__
-    EXCEPTION_CAUGHT = :__exception_raised__
-
-    def default_serializer
-      { load: Oj.method(:load), dump: Oj.method(:dump) }
-    end
-
-    def store(options:, rules:, context:)
-      options = Hashie::Mash.new(options)
-
-      Array(rules).each do |rule_name|
-        describe_sample(rule_name, options, context)
-        serialize_sample(rule_name, options, context)
-      end
-    end
-  end
-end