blood_contracts-instrumentation 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a1ff83954224dfbb24664768832c7db0e4b621364a92de707c3b1774fbc9e30
-  data.tar.gz: e271b417bdd7082067d91faf6826d91c0f13f5e2f3f01068ddba0a23af3edf8c
+  metadata.gz: 1799124ca3d91ee88f459ab3052a28317a65d84175f551ea48bedec9a2fc2d5c
+  data.tar.gz: b50de2922484d0e36dac0a72f4f92a4a895504c1f31cc56e42444ce213533122
 SHA512:
-  metadata.gz: d6c19029329fbf97adbea0fe440b0951c2ac6f9dd251ba4bf0c2e93d40421e9a823e9f5445c3483f4b78a4f3f23a5827bfa42406757d27f8d82264dbb660a66d
-  data.tar.gz: bdb1e16379fd159cff96592bff34fd0ed43182bf8da38720acc3a0bf4e759ee0fe78ba746f84a7fcdf7f5dea2f19463c32f68b11e1c5589c776b8abcb56a51f3
+  metadata.gz: 1fecb3bc14257121f2fb7f183e0db21184b60af47b7aa30511c927ad2404e9bc98738a89c354779bb27fc2dab5d17ddd7e7ff5393443e6758167ef4135aac079
+  data.tar.gz: f829a2f03ea9ebfc23e0b4394604aa867e59521fa3f5f42600b3a0d97ae371b22c7feba29b02dc0f6743e5122c6e487deb3dc27968519639b9fae2ff5ad1d77a

data/CHANGELOG.md

@@ -5,8 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [0.1.1] - [2019-07-25]
+
+Fixes NoMethodError in Instrument.build
+
+Adds specs
+
 ## [0.1.0] - [2019-07-05]
 
 This is a first public release marked in change log with features extracted from production app.
 Includes:
-TBD
+- Configuration for instruments (proc or a callable object)
+- Automatic detection of existing Refined types
+- Assignment of instruments to types
+- #match wrapper to handle before, after and finalize of call
+- 3 strategies of finalization (basic, threads and fibers)

data/blood_contracts-instrumentation.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |gem|
   gem.name          = 'blood_contracts-instrumentation'
-  gem.version       = '0.1.0'
+  gem.version       = '0.1.1'
   gem.authors       = ['Sergey Dolganov (sclinede)']
   gem.email         = ['sclinede@evilmartians.com']
 

data/lib/blood_contracts/instrumentation.rb

@@ -56,6 +56,14 @@ module BloodContracts
       @config ||= Config.new
     end
 
+    # Resets current instance of Config
+    #
+    # @return [Nothig]
+    #
+    def reset_config!
+      @config = nil
+    end
+
     require_relative "./instrumentation/failed_match.rb"
     require_relative "./instrumentation/session.rb"
 

data/lib/blood_contracts/instrumentation/instrument.rb

@@ -29,7 +29,7 @@ module BloodContracts
           instance = instrument_from_proc(proto)
 
           if before.respond_to?(:call)
-            inst.define_singleton_method(:before, &before)
+            instance.define_singleton_method(:before, &before)
           end
 
           define_stub(instance, :before)

data/spec/blood_contracts/instrumentation/config_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+RSpec.describe BloodContracts::Instrumentation::Config do
+  before do
+    module Test
+      require "json"
+
+      class EmailType < BC::Refined
+        REGEX = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i
+        def match
+          context[:email_input] = value.to_s
+          return failure(:invalid_email) if context[:email_input] !~ REGEX
+          context[:email] = context[:email_input]
+          self
+        end
+      end
+
+      class JsonType < BC::Refined
+        def match
+          context[:parsed] = JSON.parse(value.to_s)
+          self
+        end
+      end
+    end
+  end
+
+  subject { described_class.new }
+
+  describe "defaults on new instance" do
+    let(:default_pool_size) { BCI::SessionFinalizer::DEFAULT_POOL_SIZE }
+
+    it do
+      expect(subject.instruments).to be_empty
+      expect(subject.types).to be_empty
+      expect(subject.finalizer_pool_size).to eq(default_pool_size)
+      expect(subject.session_finalizer).to eq(:basic)
+    end
+  end
+
+  describe "#instrument" do
+    subject { BCI.configure { |config| config.send(:reset_types!) } }
+
+    before do
+      subject.types << Test::EmailType << Test::JsonType
+
+      subject.instrument "Json", lambda { |session|
+        puts "[SID:#{session.id}] #{session.result_type_name}"
+      }
+    end
+
+    let(:instruments) { { /Json/i => [kind_of(BCI::Instrument)] } }
+    let(:json_instruments) { [kind_of(BCI::Instrument)] }
+
+    it do
+      expect(subject.instruments).to match(instruments)
+      expect(subject.types).to match_array([Test::EmailType, Test::JsonType])
+      expect(Test::EmailType.instruments).to be_empty
+      expect(Test::JsonType.instruments).to match_array(json_instruments)
+    end
+  end
+
+  describe "#finalizer_pool_size=" do
+    before do
+      # Pool is only relevant for Fibers finalizer right now
+      subject.session_finalizer = :fibers
+      old_finalizer
+
+      subject.finalizer_pool_size = new_pool_size
+      new_finalizer
+    end
+
+    let(:old_finalizer) { BCI::SessionFinalizer.instance }
+    let(:new_finalizer) { BCI::SessionFinalizer.instance }
+    let(:new_pool_size) { 2 }
+
+    it do
+      expect(old_finalizer).not_to eq(new_finalizer)
+      expect(new_finalizer.fibers.size).to eq(new_pool_size)
+    end
+  end
+
+  describe "#session_finalizer=" do
+    before do
+      # Pool is only relevant for Fibers finalizer right now
+      config = BCI::Config.new
+      default_finalizer
+
+      config.session_finalizer = :fibers
+      fibers_finalizer
+
+      config.session_finalizer = :threads
+      threads_finalizer
+    end
+
+    let(:default_finalizer) { BCI::SessionFinalizer.instance }
+    let(:fibers_finalizer)  { BCI::SessionFinalizer.instance }
+    let(:threads_finalizer) { BCI::SessionFinalizer.instance }
+
+    it do
+      expect(default_finalizer).to eq(BCI::SessionFinalizer::Basic)
+      expect(fibers_finalizer).to match(kind_of(BCI::SessionFinalizer::Fibers))
+      expect(threads_finalizer).to eq(BCI::SessionFinalizer::Threads)
+    end
+  end
+end

data/spec/blood_contracts/instrumentation/failed_match_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+RSpec.describe BloodContracts::Instrumentation::FailedMatch do
+  subject do
+    begin
+      1 / 0
+    rescue StandardError => ex
+      described_class.new(ex, context: validation_context)
+    end
+  end
+
+  let(:validation_context) do
+    { some: "data", exception: kind_of(ZeroDivisionError) }
+  end
+
+  it do
+    is_expected.to be_invalid
+    expect(subject.match).to eq(subject)
+    expect(subject.exception).to match(kind_of(ZeroDivisionError))
+    expect(subject.context).to match(validation_context)
+  end
+end

data/spec/blood_contracts/instrumentation/instrument_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RSpec.describe BloodContracts::Instrumentation::Instrument do
+  before do
+    module Test
+      Instrument = BloodContracts::Instrumentation::Instrument.build(
+        ->(session) { "[SID:#{session.id}] #{session.result_type_name}" },
+        before: ->(session) { session.extras[:started] = true },
+        after: ->(session) { session.extras[:finished] = true }
+      )
+
+      class CustomInstrument
+        def call(session)
+          "[SID:#{session.id}] #{session.result_type_name}"
+        end
+
+        def before(session)
+          session.extras[:started] = true
+        end
+
+        def after(session)
+          session.extras[:finished] = true
+        end
+      end
+    end
+  end
+
+  let!(:session) { BloodContracts::Instrumentation::Session.new("SomeType") }
+
+  describe ".build" do
+    # FIXME: add case when after and before are not defined on custom instrument
+    subject { BCI::Instrument.build(Test::CustomInstrument.new) }
+
+    let(:message) do
+      "[SID:#{session.id}] BloodContracts::Core::ContractFailure"
+    end
+
+    it do
+      expect(subject).to match(kind_of(Test::CustomInstrument))
+
+      session.start
+      subject.before(session)
+      expect(session.extras).to include(started: true)
+
+      session.finish(BC::ContractFailure.new({ SomeType: :damn }))
+      subject.after(session)
+
+      expect(session.extras).to include(finished: true)
+
+      expect(subject.call(session)).to eq(message)
+    end
+  end
+
+  describe "#before" do
+    before do
+      session.start
+      Test::Instrument.before(session)
+    end
+
+    it do
+      expect(session.extras).to include(started: true)
+      expect(session.extras).not_to include(finished: true)
+    end
+  end
+
+  describe "#after" do
+    before do
+      session.start
+      Test::Instrument.before(session)
+
+      session.finish(BC::ContractFailure.new({ SomeType: :damn }))
+      Test::Instrument.after(session)
+    end
+
+    it do
+      expect(session.extras).to include(started: true)
+      expect(session.extras).to include(finished: true)
+    end
+  end
+
+  describe "#call" do
+    before do
+      session.start
+      Test::Instrument.before(session)
+
+      session.finish(BC::ContractFailure.new({ SomeType: :damn }))
+      Test::Instrument.after(session)
+    end
+
+    subject { Test::Instrument.call(session) }
+
+    let(:message) do
+      "[SID:#{session.id}] BloodContracts::Core::ContractFailure"
+    end
+
+    it do
+      is_expected.to eq(message)
+      expect(session.extras).to include(started: true)
+      expect(session.extras).to include(finished: true)
+    end
+  end
+end

data/spec/blood_contracts/instrumentation/session_finalizer_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+RSpec.describe BloodContracts::Instrumentation::SessionFinalizer do
+  before do
+  end
+
+  describe "defaults on new instance" do
+  end
+
+  describe "Basic finalizer" do
+  end
+
+  describe "Threads finalizer" do
+  end
+
+  describe "Fibers finalizer" do
+  end
+end

data/spec/blood_contracts/instrumentation/session_recording_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe BloodContracts::Instrumentation::SessionRecording do
+  before do
+    BCI.reset_config!
+    module Test
+      class PhoneType < BC::Refined
+        REGEX = /\A(\+7|8)(9|8)\d{9}\z/i
+        def match
+          context[:phone_input] = value.to_s
+          return failure(:invalid_phone) if context[:phone_input] !~ REGEX
+          context[:phone] = context[:phone_input]
+          self
+        end
+      end
+
+      class CustomInstrument
+        def call(session)
+          "[SID:#{session.id}] #{session.result_type_name}"
+        end
+
+        def before(session)
+          session.extras[:started] = true
+        end
+
+        def after(session)
+          session.extras[:finished] = true
+        end
+      end
+    end
+
+    BCI.configure { |cfg| cfg.instrument "Phone", custom_instrument }
+  end
+
+  let(:custom_instrument) { Test::CustomInstrument.new }
+
+  it do
+    expect(Test::PhoneType.instruments).to match_array([custom_instrument])
+  end
+end

data/spec/blood_contracts/instrumentation/session_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+RSpec.describe BloodContracts::Instrumentation::Session do
+  before do
+    module Test
+      class PhoneType < BC::Refined
+        REGEX = /\A(\+7|8)(9|8)\d{9}\z/i
+        def match
+          context[:phone_input] = value.to_s
+          return failure(:invalid_phone) if context[:phone_input] !~ REGEX
+          context[:phone] = context[:phone_input]
+          self
+        end
+      end
+    end
+  end
+
+  subject { described_class.new(Test::PhoneType.name) }
+
+  describe "defaults on new instance" do
+    it do
+      expect(subject.extras).to be_empty
+
+      expect(subject.context).to be_empty
+      expect(subject.matcher_type_name).to eq(Test::PhoneType.name)
+
+      expect(subject.result_type_name).to be_nil
+      expect(subject.id.size).to eq(20)
+
+      expect(subject.started_at).to be_nil
+      expect(subject.finished_at).to be_nil
+
+      expect(subject.scope).to be_nil
+      expect(subject.path).to be_nil
+    end
+  end
+
+  describe "#start" do
+    before { subject.start }
+
+    it do
+      expect(subject.extras).to be_empty
+      expect(subject.context).to be_empty
+
+      expect(subject.matcher_type_name).to eq(Test::PhoneType.name)
+      expect(subject.result_type_name).to be_nil
+
+      expect(subject.id.size).to eq(20)
+
+      expect(subject.started_at).to match(kind_of(Time))
+      expect(subject.finished_at).to be_nil
+
+      expect(subject.scope).to be_nil
+      expect(subject.path).to be_nil
+    end
+  end
+
+  describe "#finish" do
+    before do
+      subject.start
+      subject.finish(invalid_match)
+    end
+
+    let(:invalid_match) { Test::PhoneType.match("asdasdsdas") }
+
+    it do
+      expect(subject.extras).to be_empty
+      expect(subject.context).to match(invalid_match.context)
+
+      expect(subject.matcher_type_name).to eq(Test::PhoneType.name)
+      expect(subject.result_type_name).to eq(BC::ContractFailure.name)
+
+      expect(subject.id.size).to eq(20)
+
+      expect(subject.started_at).to match(kind_of(Time))
+      expect(subject.finished_at).to match(kind_of(Time))
+
+      expect(subject.scope).to eq(described_class::NO_SCOPE)
+      expect(subject.path).to eq(described_class::NO_VALIDATION_PATH)
+    end
+  end
+end

data/spec/blood_contracts/instrumentation_spec.rb

@@ -2,6 +2,8 @@
 
 RSpec.describe BloodContracts::Instrumentation do
   before do
+    BCI.configure { |config| config.send(:reset_types!) }
+
     module Test
       require "json"
 
@@ -57,7 +59,9 @@ RSpec.describe BloodContracts::Instrumentation do
     context "when type matches instruments condition" do
       let(:type) { Test::JsonType.name }
 
-      it { is_expected.to match_array([kind_of(described_class::Instrument)]) }
+      it do
+        is_expected.to match_array([kind_of(BCI::Instrument)])
+      end
     end
 
     context "when type doesn't match instruments condition" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blood_contracts-instrumentation
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Sergey Dolganov (sclinede)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-11 00:00:00.000000000 Z
+date: 2019-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: blood_contracts-core
@@ -128,6 +128,12 @@ files:
 - lib/blood_contracts/instrumentation/session_finalizer/fibers.rb
 - lib/blood_contracts/instrumentation/session_finalizer/threads.rb
 - lib/blood_contracts/instrumentation/session_recording.rb
+- spec/blood_contracts/instrumentation/config_spec.rb
+- spec/blood_contracts/instrumentation/failed_match_spec.rb
+- spec/blood_contracts/instrumentation/instrument_spec.rb
+- spec/blood_contracts/instrumentation/session_finalizer_spec.rb
+- spec/blood_contracts/instrumentation/session_recording_spec.rb
+- spec/blood_contracts/instrumentation/session_spec.rb
 - spec/blood_contracts/instrumentation_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/sclinede/blood_contracts-core
@@ -154,5 +160,11 @@ signing_key:
 specification_version: 4
 summary: Adds instrumentation to BloodContracts refinement types
 test_files:
+- spec/blood_contracts/instrumentation/config_spec.rb
+- spec/blood_contracts/instrumentation/failed_match_spec.rb
+- spec/blood_contracts/instrumentation/instrument_spec.rb
+- spec/blood_contracts/instrumentation/session_finalizer_spec.rb
+- spec/blood_contracts/instrumentation/session_recording_spec.rb
+- spec/blood_contracts/instrumentation/session_spec.rb
 - spec/blood_contracts/instrumentation_spec.rb
 - spec/spec_helper.rb