seam 1.1.2 → 2.0.0a1

data/seam.gemspec

@@ -1,30 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'seam/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "seam"
-  spec.version       = Seam::VERSION
-  spec.authors       = ["Darren Cauthon"]
-  spec.email         = ["darren@cauthon.com"]
-  spec.description   = %q{Simple workflows}
-  spec.summary       = %q{Simple workflows}
-  spec.homepage      = ""
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_runtime_dependency "activesupport"
-  spec.add_runtime_dependency "i18n"
-  spec.add_runtime_dependency "json"
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "subtle"
-  spec.add_development_dependency "mocha"
-  spec.add_development_dependency "contrast"
-  spec.add_development_dependency "timecop"
-end

data/spec/seam/effort_spec.rb

@@ -1,43 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Seam::Effort do
-  before do
-    Seam::Persistence.destroy
-  end
-
-  let(:flow) do
-    f = Seam::Flow.new
-    f.step1
-    f.step2
-    f
-  end
-
-  describe "updating an effort" do
-    it "should not create another document in the collection" do
-      first_effort = flow.start
-      Seam::Persistence.all.count.must_equal 1
-      first_effort.save
-      Seam::Persistence.all.count.must_equal 1
-
-      second_effort = flow.start
-      Seam::Persistence.all.count.must_equal 2
-      second_effort.save
-      Seam::Persistence.all.count.must_equal 2
-    end
-
-    it "should update the information" do
-      first_effort = flow.start
-      second_effort = flow.start
-
-      first_effort.next_step = 'i_changed_the_first_one'
-      first_effort.save
-      first_effort.to_hash.contrast_with! Seam::Effort.find(first_effort.id).to_hash, [:id, :created_at]
-      second_effort.to_hash.contrast_with! Seam::Effort.find(second_effort.id).to_hash, [:id, :created_at]
-
-      second_effort.next_step = 'i_changed_the_second_one'
-      second_effort.save
-      first_effort.to_hash.contrast_with! Seam::Effort.find(first_effort.id).to_hash, [:id, :created_at]
-      second_effort.to_hash.contrast_with! Seam::Effort.find(second_effort.id).to_hash, [:id, :created_at]
-    end
-  end
-end

data/spec/seam/flow_spec.rb

@@ -1,173 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe "flow" do
-  before do
-    Seam::Persistence.destroy
-  end
-
-  after do
-    Timecop.return
-  end
-
-  describe "a useful example" do
-    let(:flow) do
-      f = Seam::Flow.new
-      f.wait_for_attempting_contact_stage limit: 2.weeks
-      f.determine_if_postcard_should_be_sent
-      f.send_postcard_if_necessary
-      f
-    end
-
-    describe "steps that must be taken" do
-      before do
-        flow
-      end
-
-      it "should not throw an error" do
-        flow.steps.count.must_equal 3
-      end
-
-      it "should set the name of the three steps" do
-        flow.steps[0].name.must_equal "wait_for_attempting_contact_stage"
-        flow.steps[1].name.must_equal "determine_if_postcard_should_be_sent"
-        flow.steps[2].name.must_equal "send_postcard_if_necessary"
-      end
-
-      it "should set the step types of the three steps" do
-        flow.steps[0].type.must_equal "do"
-        flow.steps[1].type.must_equal "do"
-        flow.steps[2].type.must_equal "do"
-      end
-      
-      it "should set the arguments as well" do
-        flow.steps[0].arguments.must_equal [{ limit: 14.days.to_i }]
-        flow.steps[1].arguments.must_equal []
-        flow.steps[2].arguments.must_equal []
-      end
-    end
-  end
-
-  describe "a more useful example" do
-
-    describe "starting an effort" do
-      let(:flow) do
-        flow = Seam::Flow.new
-        flow.do_something
-        flow.do_something_else
-        flow
-      end
-
-      let(:now) { Time.parse('1/1/2011') }
-
-      before do
-        Timecop.freeze now
-
-        @expected_uuid = SecureRandom.uuid.to_s
-        SecureRandom.stubs(:uuid).returns(@expected_uuid)
-                                 .then.returns(1)
-                                 .then.returns(2)
-
-        @effort = flow.start( { first_name: 'John' } )
-      end
-
-      it "should mark no steps as completed" do
-        @effort.completed_steps.count.must_equal 0
-      end
-
-      it "should stamp the effort with a uuid" do
-        @effort.id.must_equal @expected_uuid
-      end
-
-      it "should stamp the create date" do
-        @effort.created_at.must_equal now
-      end
-
-      it "should stamp the next execute date" do
-        @effort.next_execute_at.must_equal now
-      end
-
-      it "should stamp the next step name" do
-        @effort.next_step.must_equal "do_something"
-      end
-
-      it "should save an effort in the db" do
-        effort = Seam::Effort.find @effort.id
-        effort.to_hash.contrast_with! @effort.to_hash, [:id, :created_at]
-      end
-
-      it "should set unique identifiers on the flow ids" do
-        effort = Seam::Effort.find @effort.id
-        effort.flow['steps'][0]['id'].must_equal '1'
-        effort.flow['steps'][1]['id'].must_equal '2'
-      end
-
-    end
-  end
-
-  describe "adding steps" do
-    describe "new steps" do
-      it "should return true" do
-        flow = Seam::Flow.new
-        flow.do_something.must_equal true
-        flow.do_something_else.must_equal true
-      end
-    end
-
-    describe "repeating steps" do
-      it "should only add the step once" do
-        flow = Seam::Flow.new
-        flow.do_something.must_equal true
-        flow.steps.count.must_equal 1
-        flow.do_something.must_equal true
-        flow.steps.count.must_equal 2
-      end
-    end
-
-    describe "repeating steps with different data" do
-      it "should only add the step once" do
-        flow = Seam::Flow.new
-        flow.do_something(special_id: 'one').must_equal true
-        flow.do_something( { special_id: 'two' }, 4).must_equal true
-        flow.steps.count.must_equal 2
-
-        flow.steps[0].arguments.count.must_equal 1
-        flow.steps[0].arguments[0].contrast_with!( { special_id: 'one' } )
-        flow.steps[1].arguments.count.must_equal 2
-        flow.steps[1].arguments[0].contrast_with!( { special_id: 'two' } )
-        flow.steps[1].arguments[1].must_equal 4
-      end
-    end
-  end
-
-  describe "stamping history" do
-    describe "default" do
-      it "should should be false" do
-        flow = Seam::Flow.new
-        flow.stamp_data_history.must_equal false
-      end
-    end
-
-    describe "setting it to true" do
-      it "allow to be set to true" do
-        flow = Seam::Flow.new
-        flow.stamp_data_history = true
-        flow.stamp_data_history.must_equal true
-      end
-    end
-
-    describe "carrying the value through the serialization" do
-
-      it "should be able to persist false" do
-        flow = Seam::Flow.new
-        flow.stamp_data_history = false
-        flow.to_hash[:stamp_data_history].must_equal false
-      end
-
-      it "should be able to persist true" do
-        flow = Seam::Flow.new
-        flow.stamp_data_history = true
-        flow.to_hash[:stamp_data_history].must_equal true
-      end
-    end
-  end
-end

data/spec/seam/step_spec.rb

@@ -1,34 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Seam::Step do
-  describe "initialize" do
-    it "should allow values to be set with the constructor" do
-      step = Seam::Step.new( { id:   'an id',
-                               name: 'a name',
-                               type: 'a type',
-                               arguments: ['1234', 2] } )
-      step.id.must_equal 'an id'
-      step.name.must_equal 'a name'
-      step.type.must_equal 'a type'
-      step.arguments.count.must_equal 2
-      step.arguments[0].must_equal '1234'
-      step.arguments[1].must_equal 2
-    end
-  end
-
-  describe "to hash" do
-    it "should allow values to be set with the constructor" do
-      step = Seam::Step.new( { id:   'an id',
-                               name: 'a name',
-                               type: 'a type',
-                               arguments: ['1234', 2] } )
-      step = Seam::Step.new step.to_hash
-      step.id.must_equal 'an id'
-      step.name.must_equal 'a name'
-      step.type.must_equal 'a type'
-      step.arguments.count.must_equal 2
-      step.arguments[0].must_equal '1234'
-      step.arguments[1].must_equal 2
-    end
-  end
-end

data/spec/seam/wait_worker_spec.rb

@@ -1,179 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-class DoSomething < Seam::Worker
-  def process
-  end
-end
-
-describe Seam::WaitWorker do
-
-  it "should be a worker" do
-    Seam::WaitWorker.new.is_a? Seam::Worker
-  end
-
-  it "should handle the wait step" do
-    Seam::WaitWorker.new.step.must_equal 'wait'
-  end
-
-  let(:today) do
-    Time.parse '1/1/2011'
-  end
-
-  let(:effort_id) do
-    effort = flow.start
-    effort.id
-  end
-
-  describe "using it in a flow" do
-
-    [:length_of_time].to_objects { [
-      [3.days],
-      [1.day],
-      [30.minutes]
-    ] }.each do |test|
-
-      describe "a simple situation" do
-
-        let(:flow) do
-          f = Seam::Flow.new
-          f.wait test.length_of_time
-          f.do_something
-          f
-        end
-
-        before do
-          Timecop.freeze today
-          effort_id
-        end
-
-        it "should move to the next step" do
-          Seam::WaitWorker.new.execute_all
-          Seam::Effort.find(effort_id).next_step.must_equal "do_something"
-        end
-        j
-        it "should set the next execute date" do
-          Seam::WaitWorker.new.execute_all
-          Seam::Effort.find(effort_id).next_execute_at.must_equal (today + test.length_of_time)
-        end
-
-      end
-
-    end
-
-    describe "time has passed since the flow was started and the wait worker was called" do
-
-      let(:today)                              { Time.parse('1/1/2011') }
-      let(:time_to_wait)                       { 3.days }
-      let(:time_before_wait_worker_was_called) { 1.day }
-      let(:expected_start)                     { today + time_to_wait }
-
-      let(:flow) do
-        f = Seam::Flow.new
-        f.wait time_to_wait
-        f.do_something
-        f
-      end
-
-      before do
-        Timecop.freeze today
-        effort_id
-
-        Timecop.freeze today + time_before_wait_worker_was_called
-      end
-
-      it "should move to the next step" do
-        Seam::WaitWorker.new.execute_all
-        Seam::Effort.find(effort_id).next_step.must_equal "do_something"
-      end
-       
-      it "should set the next execute date" do
-        Seam::WaitWorker.new.execute_all
-        Seam::Effort.find(effort_id).next_execute_at.must_equal expected_start
-      end
-
-    end
-
-    describe "time has passed since the last step was started and the wait worker was called" do
-
-      let(:today)                              { Time.parse('1/1/2011') }
-      let(:time_to_wait)                       { 8.days }
-      let(:time_it_took_for_previous_step)     { 1.days }
-      let(:time_before_wait_worker_was_called) { 3.day }
-      let(:expected_start)                     { today + time_to_wait + time_it_took_for_previous_step }
-
-      let(:flow) do
-        f = Seam::Flow.new
-        f.do_something
-        f.wait time_to_wait
-        f.do_something
-        f
-      end
-
-      before do
-        Timecop.freeze today
-        effort_id
-
-        Timecop.freeze Time.now + time_it_took_for_previous_step
-        DoSomething.new.execute_all
-        Timecop.freeze Time.now + time_before_wait_worker_was_called
-      end
-
-      it "should move to the next step" do
-        Seam::WaitWorker.new.execute_all
-        Seam::Effort.find(effort_id).next_step.must_equal "do_something"
-      end
-       
-      it "should set the next execute date" do
-        Seam::WaitWorker.new.execute_all
-        Seam::Effort.find(effort_id).next_execute_at.must_equal expected_start
-      end
-
-    end
-    j
-    describe "a more complex example of waiting" do
-
-      let(:today)                              { Time.parse('1/1/2011') }
-      let(:time_to_wait)                       { 8.days }
-      let(:time_it_took_for_first_step)        { 1.days }
-      let(:time_it_took_for_second_step)       { 4.days }
-      let(:time_before_wait_worker_was_called) { 3.day }
-      let(:expected_start)                     { today + 
-                                                 time_to_wait + 
-                                                 time_it_took_for_first_step +
-                                                 time_it_took_for_second_step  }
-
-      let(:flow) do
-        f = Seam::Flow.new
-        f.do_something
-        f.do_something
-        f.wait time_to_wait
-        f.do_something
-        f
-      end
-
-      before do
-        Timecop.freeze today
-        effort_id
-
-        Timecop.freeze Time.now + time_it_took_for_first_step
-        DoSomething.new.execute_all
-        Timecop.freeze Time.now + time_it_took_for_second_step
-        DoSomething.new.execute_all
-        Timecop.freeze Time.now + time_before_wait_worker_was_called
-      end
-
-      it "should move to the next step" do
-        Seam::WaitWorker.new.execute_all
-        Seam::Effort.find(effort_id).next_step.must_equal "do_something"
-      end
-       
-      it "should set the next execute date" do
-        Seam::WaitWorker.new.execute_all
-        Seam::Effort.find(effort_id).next_execute_at.must_equal expected_start
-      end
-
-    end
-    
-  end
-
-end