RubyGems - rworkflow - Versions diffs - 0.6.1 - Mend

rworkflow 0.6.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (61) hide show

checksums.yaml +7 -0
data/MIT-LICENSE +20 -0
data/Rakefile +117 -0
data/lib/rworkflow/flow.rb +450 -0
data/lib/rworkflow/flow_registry.rb +69 -0
data/lib/rworkflow/lifecycle.rb +102 -0
data/lib/rworkflow/minitest/test.rb +53 -0
data/lib/rworkflow/minitest/worker.rb +17 -0
data/lib/rworkflow/minitest.rb +8 -0
data/lib/rworkflow/sidekiq_flow.rb +186 -0
data/lib/rworkflow/sidekiq_helper.rb +84 -0
data/lib/rworkflow/sidekiq_lifecycle.rb +8 -0
data/lib/rworkflow/sidekiq_state.rb +42 -0
data/lib/rworkflow/state.rb +104 -0
data/lib/rworkflow/state_error.rb +13 -0
data/lib/rworkflow/transition_error.rb +9 -0
data/lib/rworkflow/version.rb +3 -0
data/lib/rworkflow/worker.rb +62 -0
data/lib/rworkflow.rb +15 -0
data/lib/tasks/rworkflow_tasks.rake +4 -0
data/test/dummy/README.rdoc +28 -0
data/test/dummy/Rakefile +6 -0
data/test/dummy/app/assets/javascripts/application.js +13 -0
data/test/dummy/app/assets/stylesheets/application.css +15 -0
data/test/dummy/app/controllers/application_controller.rb +5 -0
data/test/dummy/app/helpers/application_helper.rb +2 -0
data/test/dummy/app/views/layouts/application.html.erb +14 -0
data/test/dummy/bin/bundle +3 -0
data/test/dummy/bin/rails +4 -0
data/test/dummy/bin/rake +4 -0
data/test/dummy/config/application.rb +15 -0
data/test/dummy/config/boot.rb +5 -0
data/test/dummy/config/database.yml +25 -0
data/test/dummy/config/environment.rb +5 -0
data/test/dummy/config/environments/development.rb +37 -0
data/test/dummy/config/environments/production.rb +83 -0
data/test/dummy/config/environments/test.rb +41 -0
data/test/dummy/config/initializers/backtrace_silencers.rb +7 -0
data/test/dummy/config/initializers/cookies_serializer.rb +3 -0
data/test/dummy/config/initializers/filter_parameter_logging.rb +4 -0
data/test/dummy/config/initializers/inflections.rb +16 -0
data/test/dummy/config/initializers/mime_types.rb +4 -0
data/test/dummy/config/initializers/session_store.rb +3 -0
data/test/dummy/config/initializers/wrap_parameters.rb +14 -0
data/test/dummy/config/locales/en.yml +23 -0
data/test/dummy/config/routes.rb +56 -0
data/test/dummy/config/secrets.yml +22 -0
data/test/dummy/config.ru +4 -0
data/test/dummy/db/test.sqlite3 +0 -0
data/test/dummy/log/test.log +516 -0
data/test/dummy/public/404.html +67 -0
data/test/dummy/public/422.html +67 -0
data/test/dummy/public/500.html +66 -0
data/test/dummy/public/favicon.ico +0 -0
data/test/flow_test.rb +112 -0
data/test/lifecycle_test.rb +81 -0
data/test/rworkflow_test.rb +7 -0
data/test/sidekiq_flow_test.rb +173 -0
data/test/state_test.rb +99 -0
data/test/test_helper.rb +32 -0
metadata +199 -0

data/test/dummy/public/500.html ADDED Viewed

@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>We're sorry, but something went wrong (500)</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <style>
+  body {
+    background-color: #EFEFEF;
+    color: #2E2F30;
+    text-align: center;
+    font-family: arial, sans-serif;
+    margin: 0;
+  }
+  div.dialog {
+    width: 95%;
+    max-width: 33em;
+    margin: 4em auto 0;
+  }
+  div.dialog > div {
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #BBB;
+    border-top: #B00100 solid 4px;
+    border-top-left-radius: 9px;
+    border-top-right-radius: 9px;
+    background-color: white;
+    padding: 7px 12% 0;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+  h1 {
+    font-size: 100%;
+    color: #730E15;
+    line-height: 1.5em;
+  }
+  div.dialog > p {
+    margin: 0 0 1em;
+    padding: 1em;
+    background-color: #F7F7F7;
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #999;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    border-top-color: #DADADA;
+    color: #666;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+  </style>
+</head>
+<body>
+  <!-- This file lives in public/500.html -->
+  <div class="dialog">
+    <div>
+      <h1>We're sorry, but something went wrong.</h1>
+    </div>
+    <p>If you are the application owner check the logs for more information.</p>
+  </div>
+</body>
+</html>

data/test/dummy/public/favicon.ico ADDED Viewed

File without changes

data/test/flow_test.rb ADDED Viewed

@@ -0,0 +1,112 @@
+require 'test_helper'
+module Rworkflow
+  class FlowTest < ActiveSupport::TestCase
+    def setup
+      super
+      RedisRds::Object.flushdb
+    end
+    def test_workflow
+      lifecycle = Lifecycle.new do |lc|
+        lc.state("State1", {cardinality: 2}) do |state|
+          state.transition :pushed, Flow::STATE_SUCCESSFUL
+          state.transition :failed, Flow::STATE_FAILED
+        end
+        lc.initial = "State1"
+      end
+      initial_objects = [1,2,3]
+      workflow = Flow.create(lifecycle, 'myWorkflow')
+      workflow_id = workflow.id
+      assert Flow.registered?(workflow)
+      workflow.start(initial_objects)
+      workflow = Flow.new(workflow_id)
+      assert !workflow.finished?
+      workflow.fetch(1, 'State1') do |objects|
+        assert_equal 2, objects.size
+        assert_equal (objects & initial_objects), objects
+        assert !workflow.finished?
+        workflow.transition('State1', :pushed, objects.first)
+        workflow.transition('State1', :failed, objects.second)
+      end
+      assert !workflow.finished?
+      workflow.fetch(2, 'State1') do |last|
+        assert_equal 1, last.size
+        assert_equal (last & initial_objects), last
+        assert !workflow.finished?
+        workflow.transition('State1', :pushed, last.first)
+      end
+      assert workflow.finished?
+      counters = workflow.get_counters
+      assert_equal 2, counters[Flow::STATE_SUCCESSFUL]
+      assert_equal 1, counters[Flow::STATE_FAILED]
+      assert_equal [1,3], workflow.list_objects(Flow::STATE_SUCCESSFUL)
+    end
+    def test_flow_cardinality_all_started
+      lifecycle = Lifecycle.new do |lc|
+        lc.state("State1", {cardinality: Lifecycle::CARDINALITY_ALL_STARTED}) do |state|
+          state.transition :pushed, Flow::STATE_SUCCESSFUL
+          state.transition :failed, Flow::STATE_FAILED
+        end
+        lc.initial = "State1"
+      end
+      initial_objects = (1..6).to_a
+      workflow = Flow.create(lifecycle, 'myWorkflow')
+      workflow.start(initial_objects)
+      workflow.fetch(1, 'State1') do |objects|
+        assert_equal initial_objects.size, objects.size, 'The flow should fetch the number of objects given at the start'
+      end
+    end
+    def test_flow_state_policy_wait
+      initial_objects = [1,2,3,4]
+      lifecycle = Lifecycle.new do |lc|
+        lc.state("InitState", {cardinality: 1}) do |state|
+          state.transition :pushed, "WaitState"
+        end
+        lc.state("WaitState", {cardinality: initial_objects.size, priority: State::DEFAULT_PRIORITY, policy: State::STATE_POLICY_WAIT}) do |state|
+          state.transition :collected, Flow::STATE_SUCCESSFUL
+        end
+        lc.initial = "InitState"
+      end
+      workflow = Flow.create(lifecycle, 'myWorkflow')
+      workflow.start(initial_objects)
+      (initial_objects.size - 1).times do
+        workflow.fetch(1, 'InitState') do |objects|
+          assert_equal 1, objects.size, 'The flow should fetch the number of objects corresponding to the state cardinality'
+          workflow.transition('InitState', :pushed, objects)
+        end
+      end
+      workflow.fetch(1, 'WaitState') do |objects|
+        # This block should not be executed
+        assert false, 'The collector state should not be executed until there is enough waiting objects (>= cardinality)'
+      end
+      # Lat object push in the initial state
+      workflow.fetch(1, 'InitState') do |objects|
+        assert_equal 1, objects.size, 'The flow should fetch the number of objects corresponding to the state cardinality'
+        workflow.transition('InitState', :pushed, objects)
+      end
+      workflow.fetch(1, 'WaitState') do |objects|
+        assert_equal initial_objects.size, objects.size, 'The flow should fetch the number of objects given at the start'
+      end
+    end
+  end
+end

data/test/lifecycle_test.rb ADDED Viewed

@@ -0,0 +1,81 @@
+require 'test_helper'
+module Rworkflow
+  class LifecycleTest < ActiveSupport::TestCase
+    def setup
+      super
+      RedisRds::Object.flushdb
+    end
+    def test_definition
+      lifecycle = Lifecycle.new do |lc|
+        lc.state("State1") do |state|
+          state.transition :pushed, :successful
+        end
+        lc.initial = 'State1'
+      end
+      assert_equal 'State1', lifecycle.initial
+      assert_equal :successful, lifecycle.transition("State1", :pushed)
+      assert_raises(Rworkflow::StateError) { lifecycle.transition("UnexistingState", :pushed) }
+      assert_raises(Rworkflow::TransitionError) { lifecycle.transition("State1", :non_existing_transition) }
+      lifecycle.default = Rworkflow::Flow::STATE_FAILED
+      assert_equal Rworkflow::Flow::STATE_FAILED, lifecycle.default
+      assert_equal Rworkflow::Flow::STATE_FAILED, lifecycle.transition("State1", :non_existing_transition)
+    end
+    def test_serialization
+      lifecycle = Lifecycle.new do |lc|
+        lc.state("State1") do |state|
+          state.transition :pushed, :successful
+        end
+        lc.initial = "State1"
+      end
+      serialized = lifecycle.serialize
+      unserialized = Lifecycle.unserialize(serialized)
+      assert_equal lifecycle.initial, unserialized.initial
+      assert_equal  Set.new(lifecycle.states.keys), Set.new(unserialized.states.keys)
+      assert lifecycle.states.all? {|name, state| unserialized.states[name].instance_eval{@transitions} == state.instance_eval{@transitions} }
+    end
+    def test_concat
+      lifecycle_one = LCFactory.simple_lifecycle("1", :next)
+      lifecycle_two = LCFactory.simple_lifecycle("2", :finish)
+      lifecycle_one.concat!("1", :next, lifecycle_two)
+      assert_equal '1', lifecycle_one.initial
+      assert_equal '2', lifecycle_one.transition("1", :next)
+      assert_equal SidekiqFlow::STATE_SUCCESSFUL, lifecycle_one.transition("2", :finish)
+      lifecycle_three = LCFactory.simple_lifecycle("3", :finish)
+      lifecycle_three.state('1') do |s|
+        s.transition(:next, '3')
+        s.transition(:prev, '2')
+      end
+      lifecycle_one.concat!('2', :finish, lifecycle_three)
+      assert_equal '3', lifecycle_one.transition('1', :next)
+      assert_equal '2', lifecycle_one.transition('1', :prev)
+      assert_equal '3', lifecycle_one.transition('2', :finish)
+    end
+    class LCFactory
+      def self.simple_lifecycle(state_name, transition, cardinality = 1, priority = nil)
+        return Rworkflow::Lifecycle.new do |cycle|
+          cycle.state(state_name, cardinality: cardinality, priority: priority) do |state|
+            state.transition transition, Rworkflow::SidekiqFlow::STATE_SUCCESSFUL
+            state.transition :failed, Rworkflow::SidekiqFlow::STATE_FAILED
+          end
+          cycle.initial = state_name
+        end
+      end
+    end
+  end
+end

data/test/rworkflow_test.rb ADDED Viewed

@@ -0,0 +1,7 @@
+require 'test_helper'
+class RworkflowTest < ActiveSupport::TestCase
+  test "truth" do
+    assert_kind_of Module, Rworkflow
+  end
+end

data/test/sidekiq_flow_test.rb ADDED Viewed

@@ -0,0 +1,173 @@
+require 'test_helper'
+module Rworkflow
+  class SidekiqFlowTest < ActiveSupport::TestCase
+    def setup
+      super
+      RedisRds::Object.flushdb
+    end
+    def test_lethal_workflow
+      lifecycle = Lifecycle.new do |lc|
+        lc.state("Rworkflow::SidekiqFlowTest::Floating", {CARDINALITY_ALL_STARTEDality: 10}) do |state|
+          state.transition :rescued, 'Rworkflow::SidekiqFlowTest::Lifeboat'
+          state.transition :drowned, Rworkflow::Flow::STATE_FAILED
+        end
+        lc.state("Rworkflow::SidekiqFlowTest::Lifeboat", {cardinality: 2}) do |state|
+          state.transition :landed, 'Rworkflow::SidekiqFlowTest::Land'
+          state.transition :starved, Rworkflow::Flow::STATE_FAILED
+        end
+        lc.state("Rworkflow::SidekiqFlowTest::Land") do |state|
+          state.transition :rescued, Rworkflow::Flow::STATE_SUCCESSFUL
+          state.transition :died, Rworkflow::Flow::STATE_FAILED
+        end
+        lc.initial = "Rworkflow::SidekiqFlowTest::Floating"
+      end
+      initial_objects = (0...20).to_a
+      workflow = SidekiqFlow.create(lifecycle, 'Lethal Rworkflow 2: Lethaler', {})
+      workflow.start(initial_objects)
+      assert workflow.finished?
+      counters = workflow.get_counters
+      assert_equal 19, counters[Rworkflow::Flow::STATE_FAILED]
+      assert_equal 1, counters[Rworkflow::Flow::STATE_SUCCESSFUL]
+      assert 2, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Floating").get.to_i
+      assert 6, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Lifeboat").get.to_i
+      assert 2, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Land").get.to_i
+    end
+    def test_pause_continue
+      lifecycle = Lifecycle.new do |lc|
+        lc.state("Rworkflow::SidekiqFlowTest::Floating", {cardinality: 10}) do |state|
+          state.transition :rescued, 'Rworkflow::SidekiqFlowTest::Lifeboat'
+          state.transition :drowned, Rworkflow::Flow::STATE_FAILED
+        end
+        lc.state("Rworkflow::SidekiqFlowTest::Lifeboat", {cardinality: 2}) do |state|
+          state.transition :landed, Rworkflow::Flow::STATE_SUCCESSFUL
+          state.transition :starved, Rworkflow::Flow::STATE_FAILED
+        end
+        lc.initial = "Rworkflow::SidekiqFlowTest::Floating"
+      end
+      initial_objects = (0...20).to_a
+      workflow = SidekiqFlow.create(lifecycle, 'Lethal Workflow 4: Lethalerest', {})
+      workflow.pause
+      workflow.start(initial_objects)
+      assert !workflow.finished?
+      workflow.pause
+      workflow.continue
+      assert !workflow.finished?
+      workflow.continue
+      assert workflow.finished?
+      counters = workflow.get_counters
+      assert_equal 18, counters[Rworkflow::Flow::STATE_FAILED]
+      assert_equal 2, counters[Rworkflow::Flow::STATE_SUCCESSFUL]
+      assert 2, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Floating").get.to_i
+      assert 6, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Lifeboat").get.to_i
+    end
+    def test_collector_state_workflow
+      lifecycle = Lifecycle.new do |lc|
+        lc.state("Rworkflow::SidekiqFlowTest::PostcardSend", {cardinality: 1}) do |state|
+          state.transition :sent, 'Rworkflow::SidekiqFlowTest::PostcardCollector'
+        end
+        lc.state("Rworkflow::SidekiqFlowTest::PostcardCollector", {cardinality: Lifecycle::CARDINALITY_ALL_STARTED, priority: State::DEFAULT_PRIORITY, policy: State::STATE_POLICY_WAIT}) do |state|
+          state.transition :received, Rworkflow::Flow::STATE_SUCCESSFUL
+        end
+        lc.initial = "Rworkflow::SidekiqFlowTest::PostcardSend"
+      end
+      initial_objects = (0...20).to_a
+      workflow = SidekiqFlow.create(lifecycle, 'CollectorWorkflow', {})
+      workflow.start(initial_objects)
+      assert workflow.finished?, 'Rworkflow finish successfully'
+      assert_equal 20, RedisRds::String.new("Rworkflow::SidekiqFlowTest::PostcardSend").get.to_i, 'All initial objects should be processed by the first state one by one'
+      assert_equal 1, RedisRds::String.new("Rworkflow::SidekiqFlowTest::PostcardSend_card").get.to_i, 'All initial objects should be processed by the first state one by one'
+      assert_equal 1, RedisRds::String.new("Rworkflow::SidekiqFlowTest::PostcardCollector").get.to_i, 'All initial objects should be processed by the collector state all at once'
+      assert_equal initial_objects.size, RedisRds::String.new("Rworkflow::SidekiqFlowTest::PostcardCollector_card").get.to_i, 'All initial objects should be processed by the collector state all at once'
+    end
+    def test_gated
+      lifecycle = Lifecycle.new do |lc|
+        lc.state("Rworkflow::SidekiqFlowTest::Floating", {cardinality: 10}) do |state|
+          state.transition :rescued, 'Rworkflow::SidekiqFlowTest::Lifeboat'
+          state.transition :drowned, Rworkflow::Flow::STATE_FAILED
+        end
+        lc.state("Rworkflow::SidekiqFlowTest::Lifeboat", {cardinality: 2, policy: SidekiqFlow::STATE_POLICY_GATED}) do |state|
+          state.transition :landed, Rworkflow::Flow::STATE_SUCCESSFUL
+          state.transition :starved, Rworkflow::Flow::STATE_FAILED
+        end
+        lc.initial = "Rworkflow::SidekiqFlowTest::Floating"
+      end
+      initial_objects = (0...20).to_a
+      workflow = SidekiqFlow.create(lifecycle, 'Lethal Workflow 4: Lethalerest', {})
+      workflow.start(initial_objects)
+      assert !workflow.finished?
+      workflow.open_gate('Rworkflow::SidekiqFlowTest::Lifeboat')
+      assert workflow.finished?
+      counters = workflow.get_counters
+      assert_equal 18, counters[Rworkflow::Flow::STATE_FAILED]
+      assert_equal 2, counters[Rworkflow::Flow::STATE_SUCCESSFUL]
+      assert 2, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Floating").get.to_i
+      assert 6, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Lifeboat").get.to_i
+    end
+    class Floating < Worker
+      def process(objects)
+        rescued, drowned = objects.partition { |object| object.even? }
+        transition(:rescued, rescued)
+        transition(:drowned, drowned)
+        RedisRds::String.new(self.class.name).incr
+      end
+    end
+    class Lifeboat < Worker
+      def process(objects)
+        landed, starved = objects.partition { |object| object < 4 }
+        transition(:landed, landed)
+        transition(:starved, starved)
+        RedisRds::String.new(self.class.name).incr
+      end
+    end
+    class Land < Worker
+      def process(objects)
+        rescued, died = objects.partition { |object| object == 0 }
+        transition(:rescued, rescued)
+        transition(:died, died)
+        RedisRds::String.new(self.class.name).incr
+      end
+    end
+    class PostcardSend < Worker
+      def process(objects)
+        transition(:sent, objects)
+        RedisRds::String.new(self.class.name).incr
+        RedisRds::String.new("#{self.class.name}_card").set(objects.size)
+      end
+    end
+    class PostcardCollector < Worker
+      def process(objects)
+        transition(:received, objects)
+        RedisRds::String.new(self.class.name).incr
+        RedisRds::String.new("#{self.class.name}_card").set(objects.size)
+      end
+    end
+  end
+end

data/test/state_test.rb ADDED Viewed

@@ -0,0 +1,99 @@
+require 'test_helper'
+module Rworkflow
+  class StateTest < ActiveSupport::TestCase
+    def setup
+      super
+      @state = State.new
+      RedisRds::Object.flushdb
+    end
+    def teardown
+      super
+    end
+    def test_transition
+      @state.transition('a', 'b')
+      @state.transition('b', 'c')
+      assert_equal 'b', @state.transitions['a'], 'Transition A->B missing.'
+      assert_equal 'c', @state.transitions['b'], 'Transition B->C missing.'
+    end
+    def test_perform
+      @state.transition('a', 'b')
+      @state.transition('b', 'c')
+      assert_equal 'b', @state.perform('a'), 'Transition A->B missing.'
+      assert_equal 'c', @state.perform('b'), 'Transition B->C missing.'
+    end
+    def test_equality
+      other_state = State.new
+      assert_equal @state, other_state, 'State A and B should be equal.'
+      other_state.policy = State::STATE_POLICY_WAIT
+      assert_not_equal @state, other_state, 'State A != B: different policies!'
+      other_state = State.new
+      other_state.priority = :high
+      assert_not_equal @state, other_state, 'State A != B: different priorities!'
+      other_state = State.new
+      other_state.cardinality = 32
+      assert_not_equal @state, other_state, 'State A != B: different cardinalities!'
+      other_state = State.new
+      other_state.transition('a', 'b')
+      other_state.transition('b', 'c')
+      @state.transition('a', 'b')
+      @state.transition('b', 'c')
+      assert_equal @state, other_state, 'State A === B: same transitions!'
+      other_state.transition('c', 'd')
+      assert_not_equal @state, other_state, 'State A != B: different transitions!'
+    end
+    def test_serialization
+      other_state = State.new
+      other_state.transition('a', 'b')
+      other_state.transition('b', 'c')
+      assert_not_equal @state.serialize, other_state.serialize, 'State A should not equal B: serialization failed'
+      @state.transition('a', 'b')
+      @state.transition('b', 'c')
+      assert_equal @state.serialize, other_state.serialize, 'State A should equal B: serialization failed'
+    end
+    def test_clone
+      cloned = @state.clone
+      assert_equal @state, cloned, 'Original and cloned states should be equal'
+      assert !@state.equal?(cloned), 'Original and cloned states should not be the same object'
+      @state.transition('a', 'b')
+      @state.policy = State::STATE_POLICY_WAIT
+      @state.cardinality = 2
+      @state.priority = :high
+      cloned = @state.clone
+      assert_equal @state, cloned, 'Original and cloned states should be equal'
+      assert !@state.equal?(cloned), 'Original and cloned states should not be the same object'
+    end
+    def test_merge
+      other_state = State.new(cardinality: 2, priority: :high, policy: State::STATE_POLICY_WAIT)
+      merged = @state.merge(other_state)
+      assert_equal merged, other_state, 'Merged state should be equal to state B'
+      other_state.transition('a', 'b')
+      other_state.transition('b', 'c')
+      @state.transition('a', 'c')
+      @state.transition('c', 'd')
+      expected_state = other_state.clone
+      expected_state.transition('c', 'd')
+      merged = @state.merge(other_state)
+      assert_equal merged, expected_state, 'Merged state should have same properties as B plus additional transition C->D'
+    end
+  end
+end

data/test/test_helper.rb ADDED Viewed

@@ -0,0 +1,32 @@
+# Configure Rails Environment
+ENV['RAILS_ENV'] = 'test'
+require 'simplecov'
+require 'coveralls'
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start
+require File.expand_path('../dummy/config/environment.rb', __FILE__)
+require 'rails/test_help'
+Rails.backtrace_cleaner.remove_silencers!
+connection = Redis.new(
+  host: 'localhost',
+  db: 1,
+  port: 6379,
+  timeout: 30,
+  thread_safe: true
+)
+RedisRds.configure(
+  connection: connection,
+  namespace: 'testns'
+)
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }