iron_cuke 0.0.2 → 0.0.3

data/.gitignore

@@ -2,4 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
-iron_cuke.log
+iron_cuke.log*

data/README.md

@@ -0,0 +1,86 @@
+iron_cuke
+=========
+
+A small gem to help you mock out [IronWorker](http://iron.io) while using cucumber. iron_cuke provides a set of steps and Cucumber world objects you can use to simulate IronWorker while running cucumber tests, thereby saving time *and* money.
+
+Help
+----
+
+* The [iron_cuke github page](https://github.com/yosemsweet/iron_cuke/) is the best place to start for documentation/help. Eventually I hope to have a wiki in place but that may take a while.
+* [Patches and bugs](https://github.com/yosemsweet/iron_cuke/issues) at github issues
+* RDoc - there is no rdoc archive for iron_cuke. This is on the todo list for iron_cuke.
+
+Installation
+------------
+
+iron_cuke is a Rails 3 gem. It is currently tested against Rails 3.1 and should work with Rails 3.2 and 3.0
+
+Include the gem in your Gemfile within the :test group:
+
+```ruby
+group :test do
+  gem 'iron_cuke'
+end
+```
+
+I'm assuming you also have cucumber-rails and iron_worker gems installed, if not iron_cuke won't do you much good:
+
+```ruby
+  gem 'cucumber-rails', :group => :test
+  gem 'iron_worker'
+```
+Now run:
+
+```ruby
+bundle install
+rails generate iron_cuke
+```
+
+
+Basic Usage
+-----------
+
+Create and schedule/queue workers as normal. You can run your workers in one of three ways.
+
+1. Use the `"When iron cuke runs"` step.
+2. Use the `@iron_cuke` tag for your scenario - this will run IronCuke after every step (NOTE: This doesn't work if you have a scenario with a background)
+3. Manually invoke it via `IronCuke.run`
+
+How Does it Work?
+-----------------
+
+###IronCuke module###
+
+The IronCuke module encapsulates access to IronCuke::ScheduledQueue and IronCuke::Queue
+We monkey patch IronWorker.service to adjust the implementation of schedule and queue to use IronCuke::TestService instead.
+
+*Functions*
+* run - runs all workers according to options passed in. Defaults to using time == Time.now and priority == 0 which should run all queued workers and all scheduled workers scheduled to run before or at now. Higher priority items execute before lower priority ones.
+* queue - takes a worker and priority options (equivalent to IronWorker service) and adds them to a worker queue to be executed the next time run is called. Priority defaults to 0.
+* schedule - takes a worker and schedule parameters (equivalent to IronWorker service). Adds the worker into the hash at time. returns an array response equivalent to posting to iron worker. The response includes a scheduled_task_id identifying the scheduled worker
+* clear - clears everything queued or scheduled
+
+###IronCuke::TestService###
+
+The IronCuke::TestService is an alternative (and very minimal) implementation of the IronWorker.service. Basically instead of doing all the interesting IronWorker goodness to package your workers and run them on the cloud it fakes doing all that and instead puts them in incredibly boring and simple hash like objects.
+
+###IronCuke::QueueItem###
+
+QueueItems wrap your workers in the various internal queues. Basically they allow me to keep track of the options the worker was queued with.
+
+###IronCuke::ScheduledQueue and IronCuke::Queue###
+
+These are hash like modules that extend the base IronCuke interface. They provide the schedule and queue management functionality.
+
+Contribute
+----------
+
+Got awesome ideas or want to knock off an item on the TODO list?
+
+* Fork the project.
+* Test drive your feature addition or bug fix.  Specs make all the difference here.
+* Commit, do not mess with Rakefile or version.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+Gem started by Yosem Sweet and released (whatever that means) under the MIT license

data/TODO.md

@@ -1,13 +1,45 @@
-* Create specs for QueueItems - easy
-* Create specs for ScheduledQueue - easy
-* Create spec for TestService - easy and critical
-* Support schedule options of: - medium
-** run_times > 1
-** every x period
-* Instead of creating a bunch of mixins we should implement an IronWorker::TestService and have IronWorker.service return that. - hard
-* Create a more dynamic response system. Right now it is basically just hardcoded. - easy
-* Set up generators to create an iron_cuke.rb in cucumber features/support if present
-* Implement cancel_schedule
-* Implement schedules via TestService
-* Implement Queueing system
+Todo
+====
 
+* *Testing*
+ * Create spec for TestService - easy and critical
+ * Create specs for QueueItems - easy
+ * Create specs for ScheduledQueue - easy
+ * Create specs for generators 
+ * Create specs for cucumber step and support files
+* *Schedule*
+ * Support schedule options of: - medium
+  * run_times > 1
+  * every x period
+ * Ensure chronological execution order
+* *Queue*
+ * Support recursive options for queue
+ * Support timeout options for queue
+  * Set an error/timeout mode
+ * Return error response if a worker queues a worker of same class and recursive isn't set to true
+* Exceptions and errors
+ * Log instead of puts
+ * Provide a callback hook
+* *Being a good gem
+ * Better generators and options for time mocking (iron_cuke:install, iron_cuke:install --timecop, iron_cuke:install --time-warp, etc)
+ * RDocs
+ * Travis CI
+  * Rails 3, 3.1, 3.2
+  * MRI 1.9.1, 1.9.2, 1.9.3
+  * JRuby
+  * REE
+  * Rubinius
+ * Wiki with details examples
+ * Samples of how to use Rack::Test to make requests via workers in test environment 
+
+
+
+
+Notes
+=====
+
+* Needs to work with cucumber (rspec later)
+* Run jobs locally
+* We don't need to run them asynchronously although it is awesome if they are.
+* Scheduled events should fire when the timecop time says they should
+* Rspec integration test not needed, just unit test

data/iron_cuke.gemspec

@@ -7,8 +7,8 @@ Gem::Specification.new do |s|
   s.version     = IronCuke::VERSION
   s.authors     = ["Yosem Sweet"]
   s.email       = ["yosem.sweet@gmail.com"]
-  s.homepage    = ""
-  s.summary     = %q{A small engine to help you mock out iron worker while using cucumber}
+  s.homepage    = "https://github.com/yosemsweet/iron_cuke"
+  s.summary     = %q{A small gem to help you mock out iron worker while using cucumber}
   s.description = %q{iron_cuke provides a set of steps and Cucumber world objects you can use to simulate IronWorker while running cucumber tests.}
 
   s.rubyforge_project = "iron_cuke"
@@ -19,16 +19,15 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # specify any dependencies here; for example:
-	s.add_dependency "iron_worker"
-	s.add_dependency "cucumber", ">=0.8"
-	s.add_dependency "json"
+	s.add_dependency "iron_worker", '~>2.3'
+	s.add_dependency "cucumber", "~>1.1"
+	s.add_dependency "rails", "~>3.0"
+	s.add_dependency "json", '~>1.4'
 
-	s.add_development_dependency "require_all"
 	s.add_development_dependency "rack"
 	s.add_development_dependency "bundler"
 	s.add_development_dependency "git"
-	s.add_development_dependency "rspec-rails", "~>2.8.0"
-	s.add_development_dependency "rails", "~>3.1.0"
-	s.add_development_dependency "cucumber-rails"
+	s.add_development_dependency "rspec-rails", '~>2.8'
+	s.add_development_dependency "cucumber-rails", '~>1.1'
 	s.add_development_dependency "ruby-debug19"
 end

data/iron_cuke.log.0

@@ -0,0 +1,136 @@
+# Logfile created on 2012-02-01 18:56:13 -0800 by logger.rb/25413
+Test worker run #<TestWorker:0x00000101e265d8>
+Test worker run #<TestWorker:0x00000101e265b0>
+Test worker run #<TestWorker:0x00000101576910>
+Test worker run #<TestWorker:0x000001015768e8>
+Test worker run #<TestWorker:0x0000010138e6e8>
+Test worker run #<TestWorker:0x0000010138e6c0>
+Test worker run #<TestWorker:0x00000101421f10>
+Test worker run #<TestWorker:0x00000101421da8>
+Test worker run #<TestWorker:0x00000101bc16a8>
+Test worker run #<TestWorker:0x00000101bc1680>
+Test worker run #<TestWorker:0x00000101530ed8>
+Test worker run #<TestWorker:0x00000101530eb0>
+Test worker run #<TestWorker:0x000001014f0900>
+Test worker run #<TestWorker:0x000001014f08d8>
+Test worker run #<TestWorker:0x000001013f64f0>
+Test worker run #<TestWorker:0x000001013f64c8>
+Test worker run #<TestWorker:0x00000101402228>
+Test worker run #<TestWorker:0x00000101402200>
+Test worker run #<TestWorker:0x00000101466908>
+Test worker run #<TestWorker:0x000001014668e0>
+Test worker run #<TestWorker:0x00000101d84a58>
+Test worker run #<TestWorker:0x00000101d84a30>
+Test worker run #<TestWorker:0x000001029eb878>
+Test worker run #<TestWorker:0x000001029eb850>
+Test worker run #<TestWorker:0x000001016a2e38>
+Test worker run #<TestWorker:0x000001016a2e10>
+Test worker run #<TestWorker:0x00000101ca7928>
+Test worker run #<TestWorker:0x00000101ca7900>
+Test worker run #<TestWorker:0x00000102946af8>
+Test worker run #<TestWorker:0x00000102946ad0>
+Test worker run #<TestWorker:0x00000102b0e728>
+Test worker run #<TestWorker:0x00000102b0e700>
+Test worker run #<TestWorker:0x0000010122fe28>
+Test worker run #<TestWorker:0x0000010122fe00>
+Test worker run #<TestWorker:0x00000100cd4000>
+Test worker run #<TestWorker:0x00000100cd3fd8>
+Test worker run #<TestWorker:0x00000102a803b0>
+Test worker run #<TestWorker:0x00000102a80388>
+Test worker run #<TestWorker:0x00000102a4edb0>
+Test worker run #<TestWorker:0x00000102a4ed88>
+Test worker run #<TestWorker:0x000001028bd168>
+Test worker run #<TestWorker:0x000001028bd140>
+Test worker run #<TestWorker:0x000001012e5278>
+Test worker run #<TestWorker:0x000001012e5250>
+Test worker run #<TestWorker:0x0000010292ce28>
+Test worker run #<TestWorker:0x0000010292ce00>
+Test worker run #<TestWorker:0x00000100f4dae8>
+Test worker run #<TestWorker:0x00000100f4dac0>
+Test worker run #<TestWorker:0x00000102a4a418>
+Test worker run #<TestWorker:0x00000102a4a3f0>
+Test worker run #<TestWorker:0x0000010280f2e8>
+Test worker run #<TestWorker:0x0000010280f2c0>
+Test worker run #<TestWorker:0x0000010288ddf0>
+Test worker run #<TestWorker:0x0000010288ddc8>
+Test worker run #<TestWorker:0x00000101da8430>
+Test worker run #<TestWorker:0x00000101da8408>
+Test worker run #<TestWorker:0x000001017484c8>
+Test worker run #<TestWorker:0x000001017484a0>
+Test worker run #<TestWorker:0x0000010162fb68 @foo="bar">
+Test worker run #<TestWorker:0x0000010162fb18 @foo="bar">
+Test worker run #<TestWorker:0x000001013bc778 @foo="bar">
+Test worker run #<TestWorker:0x000001013bc728 @foo="bar">
+Test worker run #<TestWorker:0x00000100d7d920 @foo="bar">
+Test worker run #<TestWorker:0x00000100d7d8d0 @foo="bar">
+Test worker run #<TestWorker:0x00000102a94450 @foo="bar">
+Test worker run #<TestWorker:0x00000102a94400 @foo="bar">
+Test worker run #<TestWorker:0x00000102a891b8 @foo="bar">
+Test worker run #<TestWorker:0x00000102a89168 @foo="bar">
+Test worker run #<TestWorker:0x00000102beab60 @foo="bar">
+Test worker run #<TestWorker:0x00000102beab10 @foo="bar">
+Test worker run #<TestWorker:0x000001029b7d98 @foo="bar", @schedule_id="8d6d336eff37ab72bb263828da9eba7f">
+Test worker run #<TestWorker:0x000001029b7d48 @foo="bar", @schedule_id="d52604d0d4c172d4734a73f245ec025f">
+Test worker run #<TestWorker:0x00000102b4f340 @foo="bar">
+Test worker run #<TestWorker:0x00000102b4f2f0 @foo="bar">
+Test worker run #<TestWorker:0x0000010291f2a0 @foo="bar", @schedule_id="67d259334f141712bcbd9f827f7d79eb">
+Test worker run #<TestWorker:0x0000010291f250 @foo="bar", @schedule_id="67aa8a8dccd37f5329d6135ccc20df93">
+Test worker run #<TestWorker:0x00000102976528 @foo="bar", @schedule_id="39a4ce57f9ee992caf57350d25de51ea">
+Test worker run #<TestWorker:0x000001029764d8 @foo="bar", @schedule_id="911192e9d8e66f4040a26cbb65cb4093">
+Test worker run #<TestWorker:0x000001028729b0 @foo="bar", @schedule_id="1469b43b9fc95128ecf8b0e7c23c30a7">
+Test worker run #<TestWorker:0x00000102872960 @foo="bar", @schedule_id="d8a2f20de008fa74e58ac410e4c3bc5d">
+Test worker run #<TestWorker:0x00000100f64b30 @foo="bar", @schedule_id="5dd35626957bb0fbd374e5bd7c177b62">
+Test worker run #<TestWorker:0x00000100f64ae0 @foo="bar", @schedule_id="3dc350e174845b1a8ca490f79631b71c">
+Test worker run #<TestWorker:0x00000100cee4f0 @foo="bar", @schedule_id="51570bd10f35148a9b586241dccda16f">
+Test worker run #<TestWorker:0x00000100cee4a0 @foo="bar", @schedule_id="900c026c0aa8b8ad703cfc96651457f6">
+Test worker run #<TestWorker:0x00000102b065c8 @foo="bar", @schedule_id="f8ffdc282814ba16797f49a637812a34">
+Test worker run #<TestWorker:0x00000102b06578 @foo="bar", @schedule_id="ce85ea4b03ae12bc58b444e88f00448c">
+Test worker run #<TestWorker:0x00000100fc2ff0 @foo="bar", @schedule_id="dbf95442c73354988581f1e0f46bd01a">
+Test worker run #<TestWorker:0x00000100fc2fa0 @foo="bar", @schedule_id="7d9e59d2a877f1f693b212099a0c98e7">
+Test worker run #<TestWorker:0x0000010281dff0 @foo="bar", @schedule_id="3383ed85f110e1564cb9cad4581e95fc">
+Test worker run #<TestWorker:0x0000010281df50 @foo="bar", @schedule_id="4914ebeea477d6364b396239f407320f">
+Test worker run #<TestWorker:0x00000102ae4630 @foo="bar", @schedule_id="6d3230619373b8af7f611e2e71921575">
+Test worker run #<TestWorker:0x00000102ae45e0 @foo="bar", @schedule_id="56c6bf5d4537b8484de5d0634a47494a">
+Test worker run #<TestWorker:0x00000100e3b1c8 @foo="bar", @schedule_id="dd1638248f88d3c7f12cc63959e5173e">
+Test worker run #<TestWorker:0x00000100e3fd90 @foo="bar", @schedule_id="e8bf3abcc19c611bd2688c8cf9dce222">
+Test worker run #<TestWorker:0x00000100e3fd40 @foo="bar", @schedule_id="0aed940a940b39ff0e442ebdb489159e">
+Test worker run #<TestWorker:0x00000100fbb340 @foo="bar", @schedule_id="64162ec5c64a89052763e7b7e5df094b">
+Test worker run #<TestWorker:0x00000100fbb2f0 @foo="bar", @schedule_id="451254cf5bf1baaddba5cbb7bba32edf">
+Test worker run #<TestWorker:0x000001029ddea8 @foo="bar", @schedule_id="4e742f13c1fbd11fbd3ff6cdedbd1e1d">
+Test worker run #<TestWorker:0x000001029e2a70 @foo="bar", @schedule_id="d24d3ed4f0befd2a2118559a738b011f">
+Test worker run #<TestWorker:0x000001029e2a20 @foo="bar", @schedule_id="8bda70e467c96b31873518538841ed8c">
+Test worker run #<TestWorker:0x000001029fd1e0 @foo="bar", @schedule_id="3b65971ebbe2a2274aeeb6383f803526">
+Test worker run #<TestWorker:0x000001029fd190 @foo="bar", @schedule_id="f9312f5db1be65791babf4d4707ba1f2">
+Test worker run #<TestWorker:0x000001013f83e0 @foo="bar", @schedule_id="eec31629f6c768913f5970510893c0d2">
+Test worker run #<TestWorker:0x000001013f8390 @foo="bar", @schedule_id="fe07ec3e8cf867e01813b5e8edcf34ed">
+Test worker run #<TestWorker:0x00000101df58c0 @foo="bar", @schedule_id="738b087069b1c3d35179d7397bc4e88d">
+Test worker run #<TestWorker:0x00000101df5870 @foo="bar", @schedule_id="ae20539fb3fe4630c153cf5ca3d1301b">
+Test worker run #<TestWorker:0x00000101793798 @foo="bar", @schedule_id="14dcf7fd42356bc1229e0e9e1d7479b7">
+Test worker run #<TestWorker:0x00000101793748 @foo="bar", @schedule_id="6f79412919928de38e06aecabff9a4ff">
+Test worker run #<TestWorker:0x000001028ec760 @foo="bar", @schedule_id="4e80cb573119dcdd1a58a2233840473a">
+Test worker run #<TestWorker:0x000001028ec710 @foo="bar", @schedule_id="5f18ab8ca05fb229d71596f9f682135c">
+Test worker run #<TestWorker:0x000001016372f0 @foo="bar", @schedule_id="cab998626440a501b453276a6191494a">
+Test worker run #<TestWorker:0x000001016372a0 @foo="bar", @schedule_id="def095270b6d32c4a628129724a68bdc">
+Test worker run #<TestWorker:0x00000102899df8 @foo="bar", @schedule_id="e809ab00c84d04ae496f39001efd1791">
+Test worker run #<TestWorker:0x00000102899da8 @foo="bar", @schedule_id="b00992e133ec0d6dbd9b8c418c3c13e5">
+Test worker run #<TestWorker:0x000001014e66a8 @foo="bar", @schedule_id="1e1c80b83832f0219b08b7a3a840ace6">
+Test worker run #<TestWorker:0x000001014e6658 @foo="bar", @schedule_id="b315497c70c7367c1065818ce318d975">
+Test worker run #<TestWorker:0x00000101bf9fd0 @foo="bar", @schedule_id="49251810e92b3b747178f23ece7b3ffa">
+Test worker run #<TestWorker:0x00000101bf9f80 @foo="bar", @schedule_id="659b3d2cf137e600722b2a245380b07a">
+Test worker run #<TestWorker:0x000001015fe5e0 @foo="bar", @schedule_id="8f20b331574d48f68fdfc8f7436cb670">
+Test worker run #<TestWorker:0x000001015fe590 @foo="bar", @schedule_id="11be4eca4e7dcc5096450ed25ab5eae4">
+Test worker run #<TestWorker:0x00000101dff2d0 @foo="bar", @schedule_id="5f8690f6c365a9fc195ced2ad4de99bf">
+Test worker run #<TestWorker:0x00000101dff280 @foo="bar", @schedule_id="7fe369b39873021a882cc518ef3905ee">
+Test worker run #<TestWorker:0x0000010294a400 @foo="bar", @schedule_id="1bd29396d7619016b744dc73b466268d">
+Test worker run #<TestWorker:0x0000010294a3b0 @foo="bar", @schedule_id="5a04943f40b36415b2ea5da843aeca21">
+Test worker run #<TestWorker:0x000001028820e0 @foo="bar", @schedule_id="785753a6c81bd273005280307ee2c524">
+Test worker run #<TestWorker:0x00000102882090 @foo="bar", @schedule_id="3fad938fa4ee39625e237b3836bb3311">
+Test worker run #<TestWorker:0x000001028dec50 @foo="bar", @schedule_id="c96ee1bad18e875d04f2ec0de1c4a59f">
+Test worker run #<TestWorker:0x000001028dec00 @foo="bar", @schedule_id="9af4153d14ecad815258a2034434df54">
+Test worker run #<TestWorker:0x00000100fe75f8 @foo="bar", @schedule_id="04157db242ecacbcb0b937952dfe274a">
+Test worker run #<TestWorker:0x00000100fe75a8 @foo="bar", @schedule_id="67adadff312137459298686ba6b01e96">
+Test worker run #<TestWorker:0x00000102832d38 @foo="bar", @schedule_id="67e3340fa1985bf9ef2ee089a1771aa4">
+Test worker run #<TestWorker:0x00000102832ce8 @foo="bar", @schedule_id="c504a974592bb6aaee9a5f188072597b">
+Test worker run #<TestWorker:0x0000010292edb8 @foo="bar", @schedule_id="aea60d1c68c005de58a5fd5a059c7f72">
+Test worker run #<TestWorker:0x0000010292ed68 @foo="bar", @schedule_id="2a366d40595e9cfa7bd3117ed742bfd3">
+Test worker run #<TestWorker:0x000001015f5b20 @foo="bar", @schedule_id="1622281de3307a191e5ee63b51616cc2">

data/lib/generators/iron_cuke_generator.rb

@@ -0,0 +1,17 @@
+require 'rails/generators'
+
+class IronCukeGenerator < Rails::Generators::Base
+  desc "Generates Iron Cuke step and support files."
+
+  def self.source_root
+    File.join(File.dirname(__FILE__), 'templates')
+  end
+
+	def create_features_support
+		copy_file "features/support/iron_cuke.rb", "features/support/iron_cuke.rb"
+	end
+
+	def create_features_step_definitions
+		copy_file "features/step_definitions/iron_cuke_steps.rb", "features/step_definitions/iron_cuke_steps.rb"
+	end
+end

data/lib/generators/templates/features/step_definitions/iron_cuke_steps.rb

@@ -0,0 +1,3 @@
+When /^iron cuke runs$/ do
+  IronCuke.run
+end

data/lib/generators/templates/features/support/iron_cuke.rb

@@ -0,0 +1,10 @@
+require "iron_cuke"
+
+IronWorker.service.instance_eval do
+	extend IronWorker::TestService::Schedule
+	extend IronWorker::TestService::Queue
+end
+
+AfterStep('@iron_cuke') do
+	IronCuke.run
+end

data/lib/iron_cuke/queue.rb

@@ -0,0 +1,48 @@
+require "iron_cuke/queue_item"
+
+module IronCuke
+	module Queue
+	
+		def queued(priority = 0)
+			raise ArgumentError unless priority.between?(0,2)
+			worker_queue.select{|p, workers| p >= priority}.values.map { |p| 
+				p.map { |data| 
+					data.worker 
+				} 
+			}.flatten
+		end
+	
+		def queue(worker, options)
+			options = {:priority => 0}.merge(options)
+			raise NotImplementedError unless options[:priority].between?(0,2)
+		
+			worker_queue[options[:priority]] ||= []
+			item = IronCuke::QueueItem.new(worker, options)
+			worker_queue[options[:priority]] << item
+			worker.task_id = item.id
+			response = IronCuke::Queue.create_response(item)
+		end
+	
+		def clear_queue
+			worker_queue.clear
+		end
+	
+		protected
+	
+		def worker_queue
+			@worker_queue ||= Hash.new
+		end
+	
+		def self.create_response(item)
+			{
+			    "msg" => "Tasks",
+			    "tasks" => [
+			        {
+			            "id" => item.id
+			        }
+			    ],
+			    "status_code" => 200
+			}
+		end
+	end
+end

data/lib/iron_cuke/queue_item.rb

@@ -1,10 +1,12 @@
 require 'digest/md5'
 
-class QueueItem
-	attr_reader :worker, :options, :id
-	def initialize(worker, options)
-		@worker = worker
-		@options = options
-		@id = Digest::MD5.hexdigest(self.worker.inspect + self.options.inspect)
+module IronCuke
+	class QueueItem
+		attr_reader :worker, :options, :id
+		def initialize(worker, options)
+			@worker = worker
+			@options = options
+			@id = Digest::MD5.hexdigest(self.worker.inspect + self.options.inspect)
+		end
 	end
 end

data/lib/iron_cuke/scheduled_queue.rb

@@ -1,44 +1,46 @@
 require "iron_cuke/queue_item"
 
-module ScheduledQueue
+module IronCuke
+	module ScheduledQueue
 	
-	def schedules
-		scheduled_queue.values.map { |scheduled| scheduled.map { |data| data.worker } }.flatten
-	end
+		def schedules
+			scheduled_queue.values.map { |scheduled| scheduled.map { |data| data.worker } }.flatten
+		end
 	
-	def schedule(worker, schedule_options)
-		Raise NotImplementedError if schedule_options[:run_times] > 1
+		def schedule(worker, schedule_options)
+			raise NotImplementedError if schedule_options[:run_times] > 1
 		
-		scheduled_queue[schedule_options[:start_at]] ||= []
-		item = QueueItem.new(worker, schedule_options)
-		scheduled_queue[schedule_options[:start_at]] << item
-		worker.schedule_id = item.id
-		response = create_response(item)
-	end
+			scheduled_queue[schedule_options[:start_at]] ||= []
+			item = IronCuke::QueueItem.new(worker, schedule_options)
+			scheduled_queue[schedule_options[:start_at]] << item
+			worker.schedule_id = item.id
+			response = IronCuke::ScheduledQueue.create_response(item)
+		end
 	
-	def cancel_schedule(scheduled_task_id)
-		scheduled_queue.each { |k,v| v.delete_if{ |data| data.id == scheduled_task_id  } }
-	end
+		def cancel_schedule(scheduled_task_id)
+			scheduled_queue.each { |k,v| v.delete_if{ |data| data.id == scheduled_task_id  } }
+		end
 	
-	def clear
-		scheduled_queue.clear
-	end
+		def clear_schedules
+			scheduled_queue.clear
+		end
 	
-	protected
+		protected
 	
-	def scheduled_queue
-		@scheduled_queue ||= Hash.new
-	end
+		def scheduled_queue
+			@scheduled_queue ||= Hash.new
+		end
 	
-	def create_response(item)
-		{
-		    "msg" => "Scheduled",
-		    "schedules" => [
-		        {
-		            "id" => item.id
-		        }
-		    ],
-		    "status_code" => 200
-		}
+		def self.create_response(item)
+			{
+			    "msg" => "Scheduled",
+			    "schedules" => [
+			        {
+			            "id" => item.id
+			        }
+			    ],
+			    "status_code" => 200
+			}
+		end
 	end
 end

data/lib/iron_cuke/test_service.rb

@@ -23,5 +23,15 @@ module IronWorker
 				IronCuke.cancel_schedule(scheduled_task_id)
 			end
 		end
+		module Queue
+			def queue(name, data, options)
+				worker = name.classify.constantize.new
+				variables = JSON.parse(Base64.decode64(data[:attr_encoded])) if data[:attr_encoded].present?
+				variables.each do |k, v|
+					worker.instance_variable_set(k.to_sym, v)
+				end
+				IronCuke.queue(worker, options)
+			end
+		end
 	end
 end

data/lib/iron_cuke/version.rb

@@ -1,3 +1,3 @@
 module IronCuke
-	VERSION = "0.0.2"
+	VERSION = "0.0.3"
 end

data/lib/iron_cuke.rb

@@ -1,21 +1,52 @@
 require "iron_cuke/version"
 require "iron_cuke/scheduled_queue"
+require "iron_cuke/queue"
 require "iron_cuke/test_service"
 
 
 module IronCuke
-	extend ScheduledQueue
+	extend IronCuke::ScheduledQueue
+	extend IronCuke::Queue
 	
-	def self.run(time = nil)
-		time ||= Time.now
-		to_execute = scheduled_queue.keys.select { |run_at| run_at <= time }
-		to_execute.each do |k|
-			begin
-				scheduled_queue[k].each { |data| data.worker.run_local }
-				scheduled_queue.delete(k)
-			rescue Exception => e
-				puts e
+	class << self
+		
+		def run(*args)
+			options = {:time => Time.now, :priority => 0}
+			options.merge! args.pop if args.last.is_a? Hash
+			run_scheduled_workers(options[:time])
+			run_queued(options[:priority])
+		end	
+	
+		def clear
+			clear_queue
+			clear_schedules
+		end
+		
+		private:
+		def run_scheduled_workers(time)
+			to_execute = scheduled_queue.keys.select { |run_at| run_at <= time }
+			to_execute.each do |k|
+				begin
+					scheduled_queue[k].each { |data| data.worker.run_local }
+					scheduled_queue.delete(k)
+				rescue Exception => e
+					puts e
+				end
 			end
 		end
-	end	
+		
+		def run_queued(priority)
+			to_execute = worker_queue.keys.select { |p| p >= priority }
+			to_execute.sort{|x,y| y <=> x }.each do |p|
+				begin
+					worker_queue[p].each { |data| data.worker.run_local }
+					worker_queue.delete(p)
+				rescue Exception => e
+					puts e
+				end
+			end
+		end
+		
+	end
+	
 end

data/spec/lib/iron_cuke_spec.rb

@@ -2,11 +2,61 @@ require 'spec_helper'
 
 describe IronCuke do
 	it { should respond_to(:run) }
+	
+	it { should respond_to(:queue).with(2).arguments }
+	it { should respond_to(:queued) }
   
 	it { should respond_to(:schedule).with(2).arguments }
 	it { should respond_to(:schedules) }
 	it { should respond_to(:cancel_schedule).with(1).argument }
 
+	context "::queue" do
+		after(:each) do
+			IronCuke.clear
+		end
+		
+		context "with empty options" do
+			let!(:options) { {} }
+			
+		  it "should add a worker to queued" do
+		    worker = TestWorker.new
+		
+				expect {
+					IronCuke.queue(worker, options)
+				}.to change{IronCuke.queued.count}.by(1)
+		  end
+		
+			it "should return a response hash include status_code and list of task_ids" do
+			  worker = TestWorker.new
+				response = IronCuke.queue(worker, options)
+				response.should have_key "status_code"
+				response.should have_key "tasks"
+				response["tasks"].each do |s| s.should have_key "id" end
+			end
+		end	  
+		
+		context "with a priority" do
+			let(:priority) { 1 }
+			let!(:options) { {:priority => priority} }
+			
+		  it "should add a worker to queued with the same priority" do
+		    worker = TestWorker.new
+		
+				expect {
+					IronCuke.queue(worker, options)
+				}.to change{IronCuke.queued(priority).count}.by(1)
+		  end
+		
+			it "should return a response hash include status_code and list of task_ids" do
+			  worker = TestWorker.new
+				response = IronCuke.queue(worker, options)
+				response.should have_key "status_code"
+				response.should have_key "tasks"
+				response["tasks"].each do |s| s.should have_key "id" end
+			end
+		end
+	end
+
 	context "::schedule" do
 		after(:each) do
 			IronCuke.clear
@@ -88,30 +138,72 @@ describe IronCuke do
 	end
 	
 	context "::run" do
-		let(:current_time) { Time.now }
-		before(:each) do
-			@past_worker			=  TestWorker.new
-			@present_worker		=  TestWorker.new
-			@future_worker		=  TestWorker.new
+		context "with scheduled workers" do
+			let(:current_time) { Time.now }
+			let!(:past_worker) { TestWorker.new }
+			let!(:present_worker) { TestWorker.new }
+			let!(:future_worker) { TestWorker.new }
 			
-			IronCuke.schedule(@past_worker, {:start_at => current_time - 1.second, :run_times => 1})
-			IronCuke.schedule(@present_worker, {:start_at => current_time, :run_times => 1})
-			IronCuke.schedule(@future_worker, {:start_at => current_time + 1.second, :run_times => 1})			
-		end
+			before(:each) do
+				IronCuke.schedule(past_worker, {:start_at => current_time - 1.second, :run_times => 1})
+				IronCuke.schedule(present_worker, {:start_at => current_time, :run_times => 1})
+				IronCuke.schedule(future_worker, {:start_at => current_time + 1.second, :run_times => 1})
+			end
 		
-		after(:each) do
-			IronCuke.clear
-		end
+			after(:each) do
+				IronCuke.clear
+			end
 		
-		it "should call run for each worker with a start at time before Time.now" do
-			@past_worker.should_receive(:run_local)
-			@present_worker.should_receive(:run_local)
-			IronCuke.run(current_time)
+			it "should call run for each worker with a start at time before or equal to Time.now" do
+				past_worker.should_receive(:run_local)
+				present_worker.should_receive(:run_local)
+				IronCuke.run(:time => current_time)
+			end
+		
+			it "should not call run for each worker with a start at time after Time.now" do
+				future_worker.should_not_receive(:run_local)
+				IronCuke.run(:time => current_time)
+			end	
 		end
+		context "with queued workers" do
+			let(:high_priority) { 2 }; let(:medium_priority) { 1 }; let(:low_priority) { 0 }
+			let!(:high_priority_worker) { TestWorker.new }
+			let!(:medium_priority_worker) { TestWorker.new }
+			let!(:low_priority_worker) { TestWorker.new }
+			
+			before(:each) do
+				IronCuke.queue(high_priority_worker, {:priority => high_priority})
+				IronCuke.queue(medium_priority_worker, {:priority => medium_priority})
+				IronCuke.queue(low_priority_worker, {:priority => low_priority})
+			end
+		
+			after(:each) do
+				IronCuke.clear
+			end
 		
-		it "should call run for each worker with a start at time before Time.now" do
-			@future_worker.should_not_receive(:run_local)
-			IronCuke.run(current_time)
+			context "with no priority specified" do
+				it "should call run for all workers" do
+					high_priority_worker.should_receive(:run_local)
+					medium_priority_worker.should_receive(:run_local)
+					low_priority_worker.should_receive(:run_local)
+					IronCuke.run()
+				end
+			end
+			
+			context "with a priority" do
+				let(:priority) { medium_priority}
+				it "should call run for all workers of that priority or higher" do
+					high_priority_worker.should_receive(:run_local)
+					medium_priority_worker.should_receive(:run_local)
+					IronCuke.run(:priority => priority)
+				end
+				
+				it "should not call run for all workers with less than that priority" do
+					low_priority_worker.should_not_receive(:run_local)
+					IronCuke.run(:priority => priority)
+				end
+			end
+
 		end
 	end
 end

data/spec/spec_helper.rb

@@ -4,5 +4,4 @@ require 'ruby-debug' unless ENV["CI"]
 
 Dir[File.dirname(__FILE__) + ("/support/**/*.rb")].each {|f| require f}
 
-require "require_all"
-require_all "lib"
+require "iron_cuke"

data/spec/worker_integration/queue_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'iron_cuke/test_service'
+
+IronWorker.configure do |config|
+    config.token = 'IRON_WORKER_TOKEN'
+    config.project_id = 'IRON_WORKER_PROJECT_ID'
+end
+
+IronWorker.service.instance_eval do
+	extend IronWorker::TestService::Queue
+end
+
+describe "IronWorker::Base.queue" do
+	let!(:worker) { TestWorker.new }
+	
+  it "should add the worker to IronCuke.queue" do
+		expect {
+			worker.queue()
+		}.to change{IronCuke.queued.count}.by(1)
+  end
+
+  it "should set worker.response" do
+		expect {
+			worker.queue()
+		}.to change{worker.response}
+  end
+
+  it "should set worker.task_id" do
+		expect {
+			worker.queue()
+		}.to change{worker.task_id}
+		
+		worker.task_id.should_not be_nil
+  end
+
+	it "should add a worker with the same task id in to IronCuke.queue" do
+		worker.queue()
+		
+		IronCuke.queued.select { |w| w.task_id == worker.task_id }.should_not be_empty
+	end
+
+	context "response" do
+	  let(:response) { worker.queue() }
+		it { response["status_code"].should == 200 }
+		it { response.should have_key "tasks" }
+		it { response["tasks"].should be_kind_of Array }
+		it { response["tasks"][0].should have_key "id" }
+		it { response["tasks"][0]["id"].should_not be_nil }
+	end
+	
+	context "with options" do
+	  context "with a priority" do
+	    context "with valid priorities" do
+	      valid_priorities = (0..2)
+				valid_priorities.each do |priority|
+					context "with priority #{priority}" do
+						let!(:options) { { :priority => priority} }
+						
+						it "queues the worker in priority #{priority}" do
+							lower_priority = [valid_priorities.min, priority - 1].max
+							higher_priority = [valid_priorities.max, priority + 1].min
+							
+							expect {
+								worker.queue(options)
+							}.to change{ IronCuke.queued(priority).count}.by(1) # and to_not change{ IronCuke.queued(lower_priority).count }
+						end					  
+					end
+				end
+	    end
+	  end
+	end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iron_cuke
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,55 +9,55 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-06 00:00:00.000000000Z
+date: 2012-02-29 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: iron_worker
-  requirement: &2153342040 !ruby/object:Gem::Requirement
+  requirement: &2152301200 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.3'
   type: :runtime
   prerelease: false
-  version_requirements: *2153342040
+  version_requirements: *2152301200
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &2153341240 !ruby/object:Gem::Requirement
+  requirement: &2152299860 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.1'
   type: :runtime
   prerelease: false
-  version_requirements: *2153341240
+  version_requirements: *2152299860
 - !ruby/object:Gem::Dependency
-  name: json
-  requirement: &2153340380 !ruby/object:Gem::Requirement
+  name: rails
+  requirement: &2152277900 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153340380
+  version_requirements: *2152277900
 - !ruby/object:Gem::Dependency
-  name: require_all
-  requirement: &2153339860 !ruby/object:Gem::Requirement
+  name: json
+  requirement: &2152276200 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '1.4'
+  type: :runtime
   prerelease: false
-  version_requirements: *2153339860
+  version_requirements: *2152276200
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &2153339340 !ruby/object:Gem::Requirement
+  requirement: &2152274760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153339340
+  version_requirements: *2152274760
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2153338600 !ruby/object:Gem::Requirement
+  requirement: &2152273400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153338600
+  version_requirements: *2152273400
 - !ruby/object:Gem::Dependency
   name: git
-  requirement: &2153337400 !ruby/object:Gem::Requirement
+  requirement: &2152271840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,43 +87,32 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153337400
+  version_requirements: *2152271840
 - !ruby/object:Gem::Dependency
   name: rspec-rails
-  requirement: &2153336620 !ruby/object:Gem::Requirement
+  requirement: &2152251360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.8.0
+        version: '2.8'
   type: :development
   prerelease: false
-  version_requirements: *2153336620
-- !ruby/object:Gem::Dependency
-  name: rails
-  requirement: &2153335980 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 3.1.0
-  type: :development
-  prerelease: false
-  version_requirements: *2153335980
+  version_requirements: *2152251360
 - !ruby/object:Gem::Dependency
   name: cucumber-rails
-  requirement: &2153335400 !ruby/object:Gem::Requirement
+  requirement: &2152249960 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.1'
   type: :development
   prerelease: false
-  version_requirements: *2153335400
+  version_requirements: *2152249960
 - !ruby/object:Gem::Dependency
   name: ruby-debug19
-  requirement: &2153334700 !ruby/object:Gem::Requirement
+  requirement: &2152248320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -131,7 +120,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153334700
+  version_requirements: *2152248320
 description: iron_cuke provides a set of steps and Cucumber world objects you can
   use to simulate IronWorker while running cucumber tests.
 email:
@@ -145,11 +134,16 @@ files:
 - .rvmrc
 - Gemfile
 - License.txt
-- README
+- README.md
 - Rakefile
 - TODO.md
 - iron_cuke.gemspec
+- iron_cuke.log.0
+- lib/generators/iron_cuke_generator.rb
+- lib/generators/templates/features/step_definitions/iron_cuke_steps.rb
+- lib/generators/templates/features/support/iron_cuke.rb
 - lib/iron_cuke.rb
+- lib/iron_cuke/queue.rb
 - lib/iron_cuke/queue_item.rb
 - lib/iron_cuke/scheduled_queue.rb
 - lib/iron_cuke/test_service.rb
@@ -157,8 +151,9 @@ files:
 - spec/lib/iron_cuke_spec.rb
 - spec/spec_helper.rb
 - spec/support/test_worker.rb
+- spec/worker_integration/queue_spec.rb
 - spec/worker_integration/schedule_spec.rb
-homepage: ''
+homepage: https://github.com/yosemsweet/iron_cuke
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -181,9 +176,10 @@ rubyforge_project: iron_cuke
 rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: A small engine to help you mock out iron worker while using cucumber
+summary: A small gem to help you mock out iron worker while using cucumber
 test_files:
 - spec/lib/iron_cuke_spec.rb
 - spec/spec_helper.rb
 - spec/support/test_worker.rb
+- spec/worker_integration/queue_spec.rb
 - spec/worker_integration/schedule_spec.rb

data/README

@@ -1,34 +0,0 @@
-Development Notes and Todos:
-
-Needs to work with cucumber and rspec
-
-Notes
-Run jobs locally
-We don't need to run them asynchronously although it is awesome if they are.
-Scheduled events should fire when the timecop time says they should
-Initial pass can have a cucumber step for all jobs complete - this should not stick around for long though. ALternative is to have the ScheduledWorkerQueue run after every step
-Rspec integration test not needed, just unit test
-
-Basic model
-
-IronCuke module encapsulates access to ScheduledWorkerQueue
-
-Scheduled Workers:
-ScheduledWorkerQueue - A hash where each worker is keyed by the time they run.
-Functions
-run - runs all workers before current time (should this be run_with_time?)
-schedule - takes a worker and schedule parameters (equivalent to IronWorker service). Adds the worker into the hash at time. returns an array response equivalent to posting to iron worker. The response includes a scheduled_task_id identifying the scheduled worker
-cancel - takes scheduled_task_id and removes from schedule
-
-Workers
-stub worker.schedule to write to scheduled workers
-stub IronWorker.service.cancel_schedule to delegate to ScheduledWorkerQueue
-
-## Contribute
-* Fork the project.
-* Test drive your feature addition or bug fix.  Specs make all the difference here.
-* Commit, do not mess with Rakefile, version, or ChangeLog.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-Gem developed by Yosem Sweet and released (whenever that is) under the MIT license