flu_shot 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bf1b632233658c920443dcf05c1b80f786210abfbaf49a53fa611b0cafeca2c
-  data.tar.gz: 53de6450c297df25f17ac891f79f22c36106224f0166bd7955a6ecccf407b2ae
+  metadata.gz: d252d5c120bc8b41e6f80b754e2d08727250075f76ef3dca4815f5681d7dcfbd
+  data.tar.gz: 0b1f124319d00aa3f4f3c01ed9c068620c231f8b91f12f70a7938d1dfefe7f43
 SHA512:
-  metadata.gz: 0d65d96a6f53ed450979fd10106fa278d7602161a0012fc878e11b54d19c6fb87be24abed1c96c8f8ea1e971357a5963ef00e710dfaa0465e13b7e03bd144cac
-  data.tar.gz: b43fe609f44d25804d07a3908cdd35725551a0f4576fdbe9560786922e6fecc70f624bb86872bf51b40d491dfd9be3e20c8605880e2366166b3315786beb63c8
+  metadata.gz: e1f13c53db4a9ea6f28e0f90aa9bcb40091d53120e454254ac034f0bdd14162aaf378ff22707840b22a9885f46ca3ea3ce1baa9acc0521aab0f58ef72af29cdb
+  data.tar.gz: c1087095009ae80804ffedcf1a811adc31c177e915acb655b3578cf746341c9d1efc1986f48a057ae97af39f949089690319363e606bb574853512a93f6949c8

data/.github/workflows/ruby.yml

@@ -0,0 +1,20 @@
+name: Ruby
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby 2.4.9
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.4.9
+    - name: Build and test with Rake
+      run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+        bundle exec rake test

data/.gitignore

@@ -6,3 +6,6 @@
 /pkg/
 /spec/reports/
 /tmp/
+*.gem
+
+.DS_Store

data/.travis.yml

@@ -5,3 +5,5 @@ cache: bundler
 rvm:
   - 2.6.4
 before_install: gem install bundler -v 1.17.2
+services:
+  - redis-server

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    flu_shot (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.14.0)
+    mocha (1.11.2)
+    rake (10.5.0)
+    redis (4.1.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  flu_shot!
+  minitest (~> 5.0)
+  mocha (~> 1.11.0)
+  rake (~> 10.0)
+  redis (~> 4.1.0)
+
+BUNDLED WITH
+   1.17.2

data/README.md

@@ -1,8 +1,43 @@
 # FluShot
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/flu_shot`. To experiment with that code, run `bin/console` for an interactive prompt.
+<img style="float: right;" src="https://raw.githubusercontent.com/Nucc/flu_shot/assets/logo.png"/>
 
-TODO: Delete this and the text above, and describe your gem
+FluShot is a Chaos Testing tool for Ruby applications. It can inject unexpected behaviors into your system, like adding extra latency to a network request, simulating infinite loops, raising exceptions.
+
+**The project is currently in `work in progress`**
+
+Idea:
+
+First we specify the area where the flu shot needs to be injected:
+
+```
+class UserController < ApplicationController
+  def show
+    FluShot.inject(:user_controller_show) do
+      User.find(params[:user_id])
+    end
+  end
+end
+```
+
+We can specify vaccines that has a certain behaviour, like adding extra latency:
+```
+class Latency < FluShot::Vaccine
+  label :latency
+
+  def initialize(params = {})
+    sleep(rand(params[:max] - params[:min]) + params[:min])
+  end
+end
+```
+
+Finally we need to create a prescription for the `user_controller_show` and inject the `latency` vaccine:
+
+```
+FluShot::Prescription.for(:user_controller_show) do |prescription|
+  prescription.add(:latency, {min: 1000, max: 3000})
+end
+```
 
 ## Installation
 
@@ -22,7 +57,6 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
 
 ## Development
 
@@ -32,7 +66,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/flu_shot. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/nucc/flu_shot. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 

data/Rakefile

@@ -2,9 +2,9 @@ require "bundler/gem_tasks"
 require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
+  t.libs << "specs"
   t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.test_files = FileList["specs/**/*_spec.rb"]
 end
 
 task :default => :test

data/flu_shot.gemspec

@@ -39,4 +39,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.17"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "mocha", "~> 1.11.0"
+  spec.add_development_dependency "redis", "~> 4.1.0"
 end

data/lib/flu_shot/config.rb

@@ -0,0 +1,11 @@
+module FluShot
+  class Config
+    def self.storage=(value)
+      @@storage = value
+    end
+
+    def self.storage
+      @@storage ||= Storage::Memory.new
+    end
+  end
+end

data/lib/flu_shot/prescription.rb

@@ -0,0 +1,28 @@
+module FluShot
+  class Prescription
+    def self.spec(name, &block)
+      block.call(self.new(name)) if block_given?
+    end
+
+    def initialize(name)
+      @name = name
+      self.class.prescriptions.add(@name, [])
+    end
+
+    def add(vaccine, params = {})
+      current = self.class.prescriptions.get(@name)
+      current << { vaccine: vaccine, params: params }
+      self.class.prescriptions.add(@name, current)
+    end
+
+    def self.for(name)
+      prescriptions.get(name)
+    end
+
+    private
+
+    def self.prescriptions
+      Config.storage
+    end
+  end
+end

data/lib/flu_shot/sneeze.rb

@@ -0,0 +1,9 @@
+module FluShot
+  class Sneeze < StandardError
+    def initialize(exception)
+      @wrapped_exception = exception
+    end
+
+    attr_reader :wrapped_exception
+  end
+end

data/lib/flu_shot/storage/memory.rb

@@ -0,0 +1,19 @@
+module FluShot
+  module Storage
+    class Memory
+      def initialize
+        @storage = {}
+      end
+
+      def add(prescription_name, vaccines)
+        @storage[prescription_name] ||= []
+        vaccines = [vaccines] unless vaccines.is_a?(Array)
+        @storage[prescription_name] = vaccines
+      end
+
+      def get(prescription_name)
+        @storage[prescription_name] || []
+      end
+    end
+  end
+end

data/lib/flu_shot/storage/redis.rb

@@ -0,0 +1,28 @@
+require 'redis'
+require 'yaml'
+
+module FluShot
+  module Storage
+    class Redis
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def add(prescription, vaccines)
+        vaccines = [vaccines] unless vaccines.is_a?(Array)
+        @connection.hset('flu_shot', prescription.to_s, YAML.dump(vaccines))
+      end
+
+      def get(name)
+        value = @connection.hget('flu_shot', name)
+        value ? YAML.load(value) : []
+      end
+
+      def reset
+        @connection.hgetall('flu_shot').each_key do |x|
+          @connection.hdel('flu_shot', x)
+        end
+      end
+    end
+  end
+end

data/lib/flu_shot/vaccine.rb

@@ -0,0 +1,63 @@
+# The idea here is to do something like this in the code:
+#
+# ... your business layer ...
+# FluShot.inject(:user_profile_fetch)
+#
+# Define a latency vaccine that you can inject into your business layer
+# and adds a random delay between 1 and 3 seconds.
+#
+# class Latency < FluShot::Vaccine
+#   label :latency
+#
+#   def initialize(params)
+#     sleep(rand(params[:max] - params[:min]) + params[:min])
+#   end
+# end
+#
+# FluShot.on :user_profile_fetch do
+#   FluShot::Vaccine.use(:latency, {min: 1000, max: 3000})
+# end
+#
+#
+module FluShot
+  class Vaccine
+    attr_reader :attributes
+
+    def initialize(attributes = {})
+      @attributes = attributes
+    end
+
+    def self.label(name = nil)
+      if name.nil?
+        if defined?(@vaccine_name)
+          @vaccine_name
+        end || :unknown
+      else
+        @vaccine_name = name
+        vaccines[name] = self
+      end
+    end
+
+    def self.registered
+      self.vaccines.keys
+    end
+
+    def self.find(name)
+      self.vaccines[name]
+    end
+
+    def self.use(name, params = {})
+      find(name).new(params)
+    end
+
+    def label
+      self.class.label
+    end
+
+    private
+
+    def self.vaccines
+      Thread.current[:vaccines] ||= {}
+    end
+  end
+end

data/lib/flu_shot/version.rb

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

data/lib/flu_shot.rb

@@ -1,6 +1,56 @@
 require "flu_shot/version"
+require 'flu_shot/vaccine'
+require 'flu_shot/prescription'
+require 'flu_shot/config'
+require 'flu_shot/sneeze'
+
 
 module FluShot
+  module Storage
+    autoload :Memory, 'flu_shot/storage/memory'
+    autoload :Redis, 'flu_shot/storage/redis'
+  end
+
   class Error < StandardError; end
-  # Your code goes here...
+
+  def self.inject(name, &block)
+    if !before_filter.call
+      return
+    end
+
+    Prescription.for(name).each do |prescription|
+      Vaccine.find(prescription[:vaccine]).new(prescription[:params])
+    end
+
+    # @test
+    _before_init
+    block_given? ? block.call : nil
+
+  rescue FluShot::Sneeze => sneeze
+    raise sneeze.wrapped_exception
+
+  rescue
+    # @test
+    _exception_muted
+    block_given? ? block.call : nil
+  end
+
+  def self.inject_only_if(&block)
+    Thread.current[:before_filter] = block
+  end
+
+  private
+
+  def self.before_filter
+    Thread.current[:before_filter] ||= Proc.new { true }
+    Thread.current[:before_filter]
+  end
+
+  # @test
+  def self._before_init
+  end
+
+  # @test
+  def self._exception_muted
+  end
 end

data/specs/flu_shot_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe FluShot do
+  it 'has a VERSION number' do
+    refute_nil ::FluShot::VERSION
+  end
+
+  describe '#inject' do
+    it 'requires a name' do
+      assert_nil FluShot.inject('name')
+    end
+
+    it 'executes the given block' do
+      ret = FluShot.inject('name') do
+        'hello'
+      end
+
+      assert_equal 'hello', ret
+    end
+
+    it 'executes the given block even if exception occurs' do
+      FluShot.stubs(:_before_init).raises(StandardError, 'should be catched')
+      ret = FluShot.inject('name') do
+        'hello'
+      end
+
+      assert_equal 'hello', ret
+    end
+
+    it 'can be switched off' do
+      FluShot.inject_only_if do
+        false
+      end
+      FluShot.expects(:_before_init).never
+      FluShot.inject('name')
+    end
+  end
+
+  describe '#inject_only_if' do
+    it 'does not aborts when exception occurs in it' do
+      FluShot.inject_only_if do
+        raise 'it should be catched'
+      end
+      FluShot.expects(:_before_init).never
+      FluShot.expects(:_exception_muted).once
+      FluShot.inject('name')
+    end
+  end
+
+  describe 'sneeze' do
+    it 'is not rescued' do
+      FluShot.stubs(:_before_init).raises(FluShot::Sneeze.new(StandardError.new), 'should not be catched')
+
+      assert_raises StandardError do
+        FluShot.inject('name')
+      end
+    end
+  end
+end

data/specs/integration/inject_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe :inject do
+
+  class Rand123 < FluShot::Vaccine
+    label :injection_test_vaccine
+
+    def initialize(*args)
+      test
+    end
+
+    def test
+    end
+  end
+
+  it 'executes all the vaccines from a prescription' do
+    FluShot::Prescription.spec(:injection_name) do |p|
+      p.add(:injection_test_vaccine, {})
+    end
+
+    Rand123.any_instance.expects(:test).once
+    FluShot.inject(:injection_name)
+  end
+
+  it 'works with Redis store' do
+    FluShot::Config.storage = FluShot::Storage::Redis.new(Redis.new)
+    FluShot::Prescription.spec(:injection_name) do |p|
+      p.add(:injection_test_vaccine, {})
+    end
+
+    Rand123.any_instance.expects(:test).once
+    FluShot.inject(:injection_name)
+  end
+end

data/specs/lib/config_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe FluShot::Config do
+
+  describe '#storage' do
+
+    before do
+      FluShot::Config.storage = nil
+    end
+
+    it 'returns memory storage by default' do
+      assert FluShot::Config.storage.is_a?(FluShot::Storage::Memory)
+    end
+
+    it 'returns the same storage instance' do
+      assert_equal FluShot::Config.storage.object_id, FluShot::Config.storage.object_id
+    end
+
+    it 'can register other storage objects too' do
+      FluShot::Config.storage = FluShot::Storage::Redis.new(Redis.new)
+      assert FluShot::Config.storage.is_a?(FluShot::Storage::Redis)
+    end
+  end
+end

data/specs/lib/prescription_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe FluShot::Prescription do
+  describe '#spec' do
+
+    class VaccineMock < FluShot::Vaccine
+      label :vaccine_label
+
+      def initialize(*params)
+        params
+      end
+    end
+
+    it 'registers vaccines' do
+      FluShot::Prescription.spec(:name) do |order|
+        order.add(:vaccine_label)
+      end
+
+      assert_equal({:vaccine => :vaccine_label, :params => {}}, FluShot::Prescription.for(:name).first)
+    end
+
+    it 'remembers to the ingridients of the vaccines' do
+      FluShot::Prescription.spec(:name) do |p|
+        p.add(:vaccine_label, {param: 1})
+        p.add(:vaccine_label, {param: 2})
+      end
+
+      assert_equal({:vaccine => :vaccine_label, :params => {:param => 1}}, FluShot::Prescription.for(:name).first)
+      assert_equal 2, FluShot::Prescription.for(:name).size
+    end
+  end
+end

data/specs/lib/receipt_spec.rb

@@ -0,0 +1,8 @@
+# describe FluShot::Receipt do
+#   it ''
+# end
+
+
+# FluShot.describe(:shared_session) do |receipt|
+#   receipt.add(Vaccine.use(:latency, {min: 3000, max: 3000}))
+# end

data/specs/lib/sneeze_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe FluShot::Sneeze do
+  it 'can be raised as an exception' do
+    assert_raises do
+      raise FluShot::Sneeze.new
+    end
+  end
+
+  it 'can wrap another exception' do
+    sneeze = FluShot::Sneeze.new(StandardError.new)
+    assert_equal StandardError, sneeze.wrapped_exception.class
+  end
+end

data/specs/lib/storage/memory_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe FluShot::Storage::Memory do
+  before do
+    @store = FluShot::Storage::Memory.new
+  end
+
+  it 'returns [] when prescription is missing' do
+    assert_equal [], @store.get('prescription_name')
+  end
+
+  it 'stores vaccines for a prescription' do
+    @store.add('prescription_name', {vaccine: 'vaccine_name'})
+    assert_equal 'vaccine_name', @store.get('prescription_name').first[:vaccine]
+  end
+
+  it 'stores vaccine with parameters' do
+    @store.add('prescription_name', {vaccine: 'vaccine_name', params: {param: 'value'}})
+    assert_equal 'value', @store.get('prescription_name').first[:params][:param]
+  end
+end

data/specs/lib/storage/redis_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe FluShot::Storage::Redis do
+  before do
+    connection = Redis.new
+    @store = FluShot::Storage::Redis.new(connection)
+    @store.reset
+  end
+
+  it 'returns [] when prescription is missing' do
+    assert_equal [], @store.get('prescription_name')
+  end
+
+  it 'stores vaccine for a prescription' do
+    @store.add('prescription_name', {vaccine: 'vaccine_name'})
+    assert_equal 'vaccine_name', @store.get('prescription_name').first[:vaccine]
+  end
+
+  it 'stores vaccine with parameters' do
+    @store.add('prescription_name', {vaccine: 'vaccine_name', params: {param: 'value'}})
+    assert_equal 'value', @store.get('prescription_name').first[:params][:param]
+  end
+
+  it 'can reset itself' do
+    @store.add('prescription_name', {param: 1})
+    @store.reset
+    assert_equal [], @store.get('prescription_name')
+  end
+end

data/specs/lib/vaccine_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe FluShot::Vaccine do
+  it 'has an unknown label by default' do
+    vaccine = FluShot::Vaccine.new
+    assert_equal :unknown, vaccine.label
+  end
+
+  it 'has a label that registers itself in a repo' do
+    Class.new(FluShot::Vaccine) { label :latency }
+    assert FluShot::Vaccine.registered.include?(:latency)
+  end
+
+  it 'can have attributes' do
+    vaccine = FluShot::Vaccine.new({min: 1000, max: 3000})
+    assert_equal 1000, vaccine.attributes[:min]
+    assert_equal 3000, vaccine.attributes[:max]
+  end
+
+  describe '#find' do
+    it 'can initialize a vaccine from the label' do
+      class Vaccine1 < FluShot::Vaccine
+        label :vaccine1
+      end
+      assert_equal Vaccine1, FluShot::Vaccine.find(:vaccine1)
+    end
+  end
+
+  describe '#use' do
+    it 'finds and executes the vaccine' do
+      class Vaccine2 < FluShot::Vaccine
+        attr_reader :test_value
+        label :latency
+
+        def initialize(params = {})
+          @test_value = :ok
+        end
+      end
+
+      assert_equal :ok, FluShot::Vaccine.use(:latency).test_value
+    end
+
+    it 'finds and executes the vaccine with attributes' do
+      class Vaccine3 < FluShot::Vaccine
+        attr_reader :min, :max
+        label :latency
+
+        def initialize(params = {})
+          @min = params[:min]
+          @max = params[:max]
+        end
+      end
+
+      assert_equal 1000, FluShot::Vaccine.use(:latency, {min: 1000, max: 3000}).min
+      assert_equal 3000, FluShot::Vaccine.use(:latency, {min: 1000, max: 3000}).max
+    end
+  end
+end

data/specs/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "flu_shot"
+
+require "minitest/autorun"
+require "minitest/spec"
+require "mocha/minitest"
+
+class Minitest::Spec
+  before :each do
+    FluShot::Config.storage = FluShot::Storage::Memory.new
+    FluShot.inject_only_if { true }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flu_shot
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Laszlo Papp
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-08 00:00:00.000000000 Z
+date: 2020-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.11.0
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.0
 description: ''
 email:
 - nucc@bteam.hu
@@ -59,10 +87,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -70,7 +100,23 @@ files:
 - bin/setup
 - flu_shot.gemspec
 - lib/flu_shot.rb
+- lib/flu_shot/config.rb
+- lib/flu_shot/prescription.rb
+- lib/flu_shot/sneeze.rb
+- lib/flu_shot/storage/memory.rb
+- lib/flu_shot/storage/redis.rb
+- lib/flu_shot/vaccine.rb
 - lib/flu_shot/version.rb
+- specs/flu_shot_spec.rb
+- specs/integration/inject_spec.rb
+- specs/lib/config_spec.rb
+- specs/lib/prescription_spec.rb
+- specs/lib/receipt_spec.rb
+- specs/lib/sneeze_spec.rb
+- specs/lib/storage/memory_spec.rb
+- specs/lib/storage/redis_spec.rb
+- specs/lib/vaccine_spec.rb
+- specs/spec_helper.rb
 homepage: https://github.com/Nucc/flu_shot
 licenses:
 - MIT