clockwork-test 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9e5400764eb671ac7bd63e5fbd30ffd6d173f65d
+  data.tar.gz: e73c3fa5290e7683b17f89b7e0f1b3c206a56bdb
+SHA512:
+  metadata.gz: 48a656be5270cfac4ea3821b8fa55f8db3c67fc2abca37147fd7eefe3105110c90849447d5cb688549dd6b38a38a6e1ad1ad2ae9e3b6611d157f82296263331a
+  data.tar.gz: 82fdef73b35c494bfc44a3239c94affca04e4ded03d0627576c6591e55a7e9e8d8b10e4a9e7fbbfeeadf800c5e53fed87dc6fc78a6af187599d79b8689c3efa4

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,14 @@
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2
+  - ruby-head
+script:
+  - bundle exec rspec
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in clockwork-test.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Kevin Murphy
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,190 @@
+# Clockwork::Test
+
+[![Build Status](https://travis-ci.org/kevin-j-m/clockwork-test.svg?branch=master)](https://travis-ci.org/kevin-j-m/clockwork-test)
+
+[Clockwork](https://rubygems.org/gems/clockwork) is a scheduler process for running scheduled jobs. These scheduled jobs are likely of critical importance to your application. You need to ensure that the jobs run when they should, as often as they should, and with the proper behavior when run.
+
+`Clockwork::Test` includes additional functionality that makes testing of your `clock.rb` file easy. This gem can help make sure that you have scheduled your events appropriately, including testing `if:` or `at:` conditions, as well as allowing you to run assertions against the code that is executed when a job is run.
+
+`Clockwork::Test` has been verified against the latest release of clockwork at the time of its development, which is version 1.2.0. It does not require any specific test framework to be used with it, though all examples will use `rspec`.
+
+## Installation
+
+Add this to your application's Gemfile:
+
+```ruby
+group :test do
+  gem 'clockwork-test'
+end
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install clockwork-test
+
+## Example Tests
+
+Given the following `clock.rb` file:
+
+```ruby
+require "clockwork"
+
+module Clockwork
+  configure do |config|
+    config[:tz] = "US/Eastern"
+  end
+
+  handler { |job| logger.info "Running #{job}" }
+
+  every(1.minute, "Run a job") do
+    "Here's a running job"
+  end
+end
+```
+
+The following tests may be run against it:
+
+```ruby
+describe Clockwork do
+  after(:each) { Clockwork::Test.clear! }
+
+  it "runs the job once" do
+    Clockwork::Test.run(max_ticks: 1)
+
+    expect(Clockwork::Test.ran_job?("Run a job")).to be_truthy
+    expect(Clockwork::Test.times_run("Run a job")).to eq 1
+    expect(Clockwork::Test.block_for("Run a job").call).to eq "Here's a running job"
+  end
+
+  it "runs the job every minute over the course of an hour" do
+    start_time = Time.new(2015, 11, 2, 2, 0, 0)
+    end_time = Time.new(2015, 11, 2, 3, 0, 0)
+
+    Clockwork::Test.run(start_time: start_time, end_time: end_time, tick_speed:
+1.minute)
+
+    expect(Clockwork::Test.times_run("Run a job").to eq 60
+  end
+
+  describe "RSpec Custom Matcher" do
+    subject(:clockwork) { Clockwork::Test }
+
+    before { Clockwork::Test.run(max_ticks: 1) }
+
+    it { should have_run("Run a job") }
+    it { should have_run("Run a job").once }
+
+    it { should_not have_run("Run a job").exactly(2).times }
+  end
+end
+```
+
+## Usage
+
+Replacing any calls to `Clockwork` with `Clockwork::Test` in your tests should perform as expected, with the one caveat that a job running in `Clockwork::Test` will not actually execute its event's handler code. That is suppressed, but made available via the `block_for` method.
+
+### Running Clockwork in Tests
+
+A call to `Clockwork.run` will run the clockwork process until it is signaled to stop, such as by receiving the `SIGINT` signal. `Clockwork::Test.run` provides two ways to easily stop the current execution:
+
+1. After a particular number of clock ticks (See the `max_ticks` configuration setting).
+3. After a moment in time has been reached (See the `end_time` configuration setting).
+
+Either of these methods can be used by passing the proper configuration option into the `run` method of `Clockwork::Test`. If both are provided, whichever occurs first will be used to halt execution.
+
+### Configuration Settings
+
+#### max_ticks
+
+Setting the `max_ticks` will determine the number of times that clockwork will run any events scheduled at that time. This is commonly used to let clockwork execute once, to then see if particular jobs are triggered right when clockwork starts up.
+
+#### start_time
+
+This is the time that you would like the clock file to start processing it. This may be used with either the `max_ticks` or `end_time` option to halt execution of the run loop.
+
+If the `start_time` option is used, `Time.now` will be modified to the `start_time` at the beginning of execution of `Clockwork::Test.run`, and will be returned to the proper time at the conclusion of the run.
+
+#### end_time
+
+This specifies the time at which execution of clockwork should terminate. The run loop will continue until the `end_time` is reached, provided the `max_ticks` has not been exceeded, if that is provided.
+
+This is commonly used along with `start_time` and `tick_speed` to quickly see if jobs run as often as expected over a certain period of time.
+
+#### tick_speed
+
+`tick_speed` should be provided as a unit of time, such as `1.minute` or `3.hours`. It is the amount of time that the test will progress time to on every subsequent clock tick.
+
+If `tick_speed` is set to `1.minute` and the current time is `13:00`, the first tick will occur at `13:00`, and the second will appear occur at `13:01`.
+
+This can be used in concert with `start_time` and `end_time` to quickly simulate moving across a large period of time, without having to wait for the full time period to occur in reality.
+
+Note that `tick_speed` should not be set any higher than the minimum amount of granularity used in the clock file under test. Should the `tick_speed` be set to a higher amount, the number of times a job is run, or if the job is run at all, is subject to inconsistent and inaccurate results.
+
+For example, with a `tick_speed` of `30.minutes` and a job that runs every `1.minute` over the course of an hour, the `times_ran` for that job will *not* be 60. It will be 2, assuming minimal passage of time in evaluating the actual clock tick.
+
+#### file
+
+The location of the clock file to test. This defaults to `"./config/clock.rb"` if a value is not provided.
+
+### Assertions Against Test Runs
+
+After running your clock file with `Clockwork::Test.run`, you can use the following methods to assert the clock file ran as expected:
+
+#### ran_job?
+
+`ran_job?` lets you know if a particular job ran during previous executions of `Clockwork::Test.run`.
+
+If the job "test_job" has run, `ran_job?("test_job")` will be true; otherwise, the method will return false.
+
+#### times_run
+
+`times_run` provides the number of times a job has run during previous executions of `Clockwork::Test.run`.
+
+If the job "test_job" never ran, `times_run("test_job")` will be 0; otherwise, it will be the number of times that the event was executed.
+
+#### block_for
+
+`block_for` returns the block that would be handled and run on each execution of a job. This can be useful for ensuring that the block you associated with an event does whatever it is that you expect it to do.
+
+If the job "test_job" never ran, `block_for("test_job")` will return an empty proc; otherwise, the block of code that the event would run is returned, which can then be `call`ed to test.
+
+### RSpec Matchers
+
+`Clockwork::Test` includes a rspec test matcher to check if a job has been run.
+
+To use, add the following to your `spec_helper.rb`:
+
+```ruby
+RSpec.configure do |config|
+  config.include(Clockwork::Test::RSpec::Matchers)
+end
+```
+
+The `have_run` matcher checks if a job by the name provided has been run, and allows for a specific number of times to be checked against.
+
+`expect(Clockwork::Test).to have_run("Job Name").exactly(42).times`
+
+You can alternatively pass the number of times in as an optional argument in the `have_run` method, as such:
+
+`expect(Clockwork::Test).to have_run("Job Name", times: 42)`
+
+Chaining `once` to `have_run` will check that the job was run one time only.
+
+If you do not pass the number of times, either with a chained method call or as an optional argument to `have_run`, the matcher will just check if the job was run at all. It provides no assertion as to how often it was run, just that it's at least once.
+
+### Resetting the clock
+
+After each invocation of `Clockwork::Test.run` and assertions made against it, `Clockwork::Test.clear!` should be called. This will wipe all history away and load up the clock file fresh on the next `run`. Failure to do so across tests will carry over past history, which will cause the number of times a job has run to be incorrect and subject to a test ordering bug.
+
+## Contributing
+
+1. Fork it ( https://github.com/kevin-j-m/clockwork-test/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Run the tests (`rspec`) and ensure they pass
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/clockwork-test.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'clockwork/test/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "clockwork-test"
+  spec.version       = Clockwork::Test::VERSION
+  spec.authors       = ["Kevin Murphy"]
+  spec.email         = ["murphy.kevin.mail@gmail.com"]
+  spec.summary       = "Test clockwork scheduled jobs"
+  spec.description   = "Run clockwork jobs in a test environment and assert jobs are run as expected"
+  spec.homepage      = "https://github.com/kevin-j-m/clockwork-test"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-its"
+
+  spec.add_runtime_dependency "clockwork"
+  spec.add_runtime_dependency "timecop"
+end

data/lib/clockwork/test/event.rb

@@ -0,0 +1,12 @@
+module Clockwork
+  module Test
+    class Event < Clockwork::Event
+      attr_reader :block
+
+      private
+
+      def execute
+      end
+    end
+  end
+end

data/lib/clockwork/test/job_history.rb

@@ -0,0 +1,40 @@
+module Clockwork
+  module Test
+    class JobHistory
+      def initialize(prior_history = {}, prior_work = {})
+        @history = prior_history
+        @work_done = prior_work
+      end
+
+      def jobs
+        history.keys
+      end
+
+      def ran_job?(job)
+        jobs.include?(job)
+      end
+
+      def times_run(job)
+        history[job] || 0
+      end
+
+      def block_for(job)
+        work_done[job] || Proc.new {}
+      end
+
+      def record(new_events)
+        new_events.each do |event|
+          job = event.job
+
+          prior_runs = times_run(job)
+          history[job] = prior_runs > 0 ? prior_runs + 1 : 1
+          work_done[job] = event.block
+        end
+      end
+
+      private
+
+      attr_reader :history, :work_done
+    end
+  end
+end

data/lib/clockwork/test/manager.rb

@@ -0,0 +1,89 @@
+module Clockwork
+  module Test
+    class Manager < Clockwork::Manager
+      attr_reader :total_ticks, :max_ticks, :end_time
+
+      def initialize(opts = {})
+        super()
+        @history = JobHistory.new
+
+        @total_ticks = 0
+        @max_ticks = opts[:max_ticks]
+        @end_time = opts[:end_time]
+        config[:logger].level = Logger::ERROR
+      end
+
+      def run(opts = {})
+        @max_ticks = opts[:max_ticks] if opts[:max_ticks]
+        @end_time = opts[:end_time] if opts[:end_time]
+        @tick_speed = opts[:tick_speed]
+
+        if opts[:start_time]
+          @time_altered = true
+          Timecop.travel(opts[:start_time])
+        end
+
+        super()
+
+        Timecop.return if @time_altered
+      end
+
+      def ran_job?(job)
+        history.ran_job?(job)
+      end
+
+      def times_run(job)
+        history.times_run(job)
+      end
+
+      def block_for(job)
+        history.block_for(job)
+      end
+
+      private
+
+      attr_reader :history
+
+      def loop(&block)
+        while 1 == 1 do
+          update_job_history
+
+          block.call
+
+          @total_ticks += 1
+          break if ticks_exceeded? || time_exceeded?
+        end
+      end
+
+      def sleep(interval)
+        if @tick_speed
+          Timecop.travel(Time.now + @tick_speed)
+        else
+          super
+        end
+      end
+
+      def register(period, job, block, options)
+        event = ::Clockwork::Test::Event.new(self, period, job, block || handler, options)
+        @events << event
+        event
+      end
+
+      def update_job_history
+        history.record(events_run_now)
+      end
+
+      def events_run_now
+        events_to_run(Time.now)
+      end
+
+      def ticks_exceeded?
+        max_ticks && total_ticks >= max_ticks
+      end
+
+      def time_exceeded?
+        end_time && Time.now >= end_time
+      end
+    end
+  end
+end

data/lib/clockwork/test/rspec/matchers/have_run.rb

@@ -0,0 +1,67 @@
+module Clockwork
+  module Test
+    module RSpec
+      module Matchers
+        class HaveRun
+          def initialize(job_name = nil, opts = {})
+            @job_name = job_name
+            @times_run = opts[:times] || 1
+            @exactly = false
+          end
+
+          def matches?(clock_test)
+            if @exactly
+              clock_test.manager.times_run(@job_name) == @times_run
+            else
+              clock_test.manager.ran_job?(@job_name)
+            end
+          end
+
+          def once
+            @times_run = 1
+            @exactly = true
+
+            self
+          end
+
+          def exactly(times)
+            @times_run = times
+            @exactly = true
+
+            self
+          end
+
+          def times(times = nil)
+            if times
+              @times_run = times
+              @exactly = true
+            end
+
+            self
+          end
+
+          def time(times = nil)
+            if times
+              @times_run = times
+              @exactly = true
+            end
+
+            self
+          end
+
+          def description
+            "run \"#{@job_name}\" #{@times_run} #{@times_run == 1 ? 'time' : 'times'}"
+          end
+
+          def failure_message
+            "expected Clockwork::Test to have " + description
+          end
+
+          def failure_message_when_negated
+            "expected Clockwork::Test to not have run \"#{@job_name}\"."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clockwork/test/rspec/matchers.rb

@@ -0,0 +1,13 @@
+require "clockwork/test/rspec/matchers/have_run"
+
+module Clockwork
+  module Test
+    module RSpec
+      module Matchers
+        def have_run(job, opts = {})
+          Matchers::HaveRun.new(job, opts)
+        end
+      end
+    end
+  end
+end

data/lib/clockwork/test/version.rb

@@ -0,0 +1,5 @@
+module Clockwork
+  module Test
+    VERSION = "0.1.0"
+  end
+end

data/lib/clockwork/test.rb

@@ -0,0 +1,74 @@
+require "clockwork"
+require "timecop"
+
+require "clockwork/test/event"
+require "clockwork/test/job_history"
+require "clockwork/test/manager"
+require "clockwork/test/version"
+require "clockwork/test/rspec/matchers"
+
+module Clockwork
+  module Methods
+    def every(period, job, options={}, &block)
+      ::Clockwork.manager.every(period, job, options, &block)
+      ::Clockwork::Test.manager.every(period, job, options, &block)
+    end
+  end
+
+  module Test
+    class << self
+      def included(klass)
+        klass.send "include", Methods
+        klass.extend Methods
+
+        klass.send "include", ::Clockwork::Methods
+        klass.extend ::Clockwork::Methods
+      end
+
+      def manager
+        @manager ||= Clockwork::Test::Manager.new
+      end
+
+      def manager=(manager)
+        @manager = manager
+      end
+    end
+
+    module Methods
+      def run(opts = {})
+        file = opts[:file] || "./config/clock.rb"
+
+        run_opts = {
+          max_ticks: opts[:max_ticks],
+          start_time: opts[:start_time],
+          end_time: opts[:end_time],
+          tick_speed: opts[:tick_speed]
+        }
+
+        # TODO parse file rather than loading it
+        # and overloading Clockwork::Methods::every
+        load file
+
+        manager.run(run_opts)
+      end
+
+      def clear!
+        Clockwork::Test.manager = Clockwork::Test::Manager.new
+      end
+
+      def ran_job?(job)
+        manager.ran_job?(job)
+      end
+
+      def times_run(job)
+        manager.times_run(job)
+      end
+
+      def block_for(job)
+        manager.block_for(job)
+      end
+    end
+
+    extend Methods, ::Clockwork::Methods
+  end
+end

data/spec/acceptance/clock_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe "Clockwork" do
+  let(:clock_file) { "spec/fixtures/clock.rb" }
+  let(:test_job_name) { "Run a job" }
+
+  after(:each) { Clockwork::Test.clear! }
+
+  describe "Run a job" do
+    before { Clockwork::Test.run(file: clock_file, max_ticks: 1) }
+
+    it "runs the test job in the file" do
+      expect(Clockwork::Test.ran_job?(test_job_name)).to be_truthy
+    end
+
+    it "knows the job ran a single time" do
+      expect(Clockwork::Test.times_run(test_job_name)).to eq 1
+    end
+
+    it "retains a record of the work that the job would have done" do
+      expect(Clockwork::Test.block_for(test_job_name).call).to eq "Here's a running job"
+    end
+  end
+
+  describe "Custom matchers" do
+    subject(:clockwork) { Clockwork::Test }
+
+    before { Clockwork::Test.run(file: clock_file, max_ticks: 1) }
+
+    it { should have_run(test_job_name) }
+    it { should have_run(test_job_name).once }
+
+    it { should_not have_run(test_job_name).exactly(2).times }
+
+    it "works as an explicit expectation as well" do
+      expect(Clockwork::Test).to have_run(test_job_name)
+      expect(Clockwork::Test).to_not have_run(test_job_name).exactly(2).times
+    end
+
+    context "running multiple times" do
+      before { Clockwork::Test.run(file: clock_file, max_ticks: 2, tick_speed: 1.minute) }
+
+      it { should have_run(test_job_name).exactly(2).times }
+      it { should have_run(test_job_name) }
+      it { should have_run(test_job_name).times(2) }
+      it { should have_run(test_job_name).exactly(2) }
+      it { should have_run(test_job_name, times: 2) }
+    end
+  end
+end

data/spec/clockwork/test/job_history_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+require "clockwork/test/job_history"
+
+describe Clockwork::Test::JobHistory do
+  subject(:history) { Clockwork::Test::JobHistory.new(prior_history, prior_work) }
+  let(:prior_history) { {} }
+  let(:prior_work) { {} }
+
+  describe "#jobs" do
+    let(:prior_history) do
+      {
+        "#{first_job}" => 1,
+        "#{second_job}" => 1
+      }
+    end
+
+    let(:first_job) { "job1" }
+    let(:second_job) { "job2" }
+
+    its(:jobs) { should include first_job, second_job }
+  end
+
+  describe "#ran_job?" do
+    let(:prior_history) { { "#{first_job}" => 1 } }
+    let(:first_job) { "job1" }
+    let(:second_job) { "job2" }
+
+    it "finds history of a job that ran" do
+      expect(history.ran_job?(first_job)).to be_truthy
+    end
+
+    it "does not find history of a job never run" do
+      expect(history.ran_job?(second_job)).to be_falsey
+    end
+  end
+
+  describe "#times_run" do
+    let(:prior_history) { { "#{first_job}" => number_of_first_job_runs } }
+    let(:first_job) { "job1" }
+    let(:number_of_first_job_runs) { 42 }
+    let(:second_job) { "job2" }
+
+    it "finds the number of times a previously job has run" do
+      expect(history.times_run(first_job)).to eq number_of_first_job_runs
+    end
+
+    it "finds no runs for a job it has no history of" do
+      expect(history.times_run(second_job)).to eq 0
+    end
+  end
+
+  describe "#block_for" do
+    let(:prior_work) { { "#{job}" => block } }
+    let(:job) { "job" }
+    let(:block) { Proc.new { "Running #{job}" } }
+
+    it "recalls the block that was run for a previously run job" do
+      expect(history.block_for(job).call).to eq "Running #{job}"
+    end
+
+    it "does nothing for a job that was not run" do
+      expect(history.block_for("not_run").call).to be_nil
+    end
+  end
+
+  describe "#record" do
+    let(:events) { [first_event, second_event] }
+
+    let(:first_event) { double(job: first_job, block: first_block) }
+    let(:first_job) { "job1" }
+    let(:first_block) { Proc.new { "Running #{first_job}" } }
+
+    let(:second_event) { double(job: second_job, block: second_block) }
+    let(:second_job) { "job2" }
+    let(:second_block) { Proc.new {} }
+
+    before { history.record(events) }
+
+    it "keeps a record of the job occurring" do
+      expect(history.jobs).to include first_job, second_job
+    end
+
+    it "knows the work the job would perform" do
+      expect(history.block_for(first_job).call).to eq "Running #{first_job}"
+    end
+
+    context "recording jobs that already ran" do
+      let(:prior_history) { { "#{first_job}" => 1 } }
+
+      it "increments the counter of the job already recording and adds a new entry for the job never recorded prior" do
+        expect(history.times_run(first_job)).to eq 2
+        expect(history.times_run(second_job)).to eq 1
+      end
+    end
+  end
+end

data/spec/clockwork/test/manager_spec.rb

@@ -0,0 +1,176 @@
+require "spec_helper"
+require "clockwork/test/manager"
+
+describe Clockwork::Test::Manager do
+  subject(:manager) { Clockwork::Test::Manager.new(opts) }
+  let(:opts) { {} }
+
+  context "initial state" do
+    its(:total_ticks) { should eq 0 }
+    its(:max_ticks) { should be_nil }
+    its(:end_time) { should be_nil }
+
+    context "providing a maximum number of ticks" do
+      let(:opts) { { max_ticks: max_ticks } }
+      let(:max_ticks) { 42 }
+
+      its(:max_ticks) { should eq max_ticks }
+    end
+
+    context "providing a time the clock should stop" do
+      let(:opts) { { end_time: end_time } }
+      let(:end_time) { Time.current }
+
+      its(:end_time) { should eq end_time }
+    end
+  end
+
+  describe "#run" do
+    context "limiting the number of ticks" do
+      let(:opts) { { max_ticks: max_ticks } }
+      let(:max_ticks) { 1 }
+
+      it "only runs the number of times specified" do
+        manager.run
+        expect(manager.total_ticks).to eq 1
+      end
+
+      context "specifying number of ticks in the method invocation" do
+        let(:method_max_ticks) { 3 }
+
+        it "runs the number of times specified in the run call" do
+          manager.run(max_ticks: method_max_ticks)
+          expect(manager.total_ticks).to eq method_max_ticks
+        end
+      end
+    end
+
+    context "limiting the time the clock should run" do
+      let(:opts) { { end_time: end_time } }
+      let(:end_time) { Time.current + 2.seconds }
+
+      it "stops running after reaching the end time" do
+        manager.run
+        expect(Time.current).to be_within(1.second).of(end_time)
+        expect(manager.total_ticks).to be > 0
+      end
+
+      context "specifying the end time in the method invocation" do
+        let(:method_end_time) { Time.current + 4.seconds }
+
+        it "stops running after reaching the end time specified in the call" do
+          manager.run(end_time: method_end_time)
+          expect(Time.current).to be_within(1.second).of(method_end_time)
+          expect(manager.total_ticks).to be > 0
+        end
+      end
+    end
+
+    context "recording job history" do
+      let(:opts) { { max_ticks: max_ticks } }
+      let(:max_ticks) { 1 }
+      let(:job_name) { "Test job" }
+
+      before do
+        manager.handler { }
+        manager.every(1.minute, job_name)
+        manager.run
+      end
+
+      it "knows the job has run" do
+        expect(manager.ran_job?(job_name)).to be_truthy
+      end
+
+      it "finds a single run of the job" do
+        expect(manager.times_run(job_name)).to eq 1
+      end
+    end
+
+    context "modifying when the test is run" do
+      let(:opts) { { max_ticks: max_ticks } }
+      let(:max_ticks) { 1 }
+      let(:job_name) { "Test job" }
+      let(:start_time) { Time.new(2000) }
+
+      before do
+        manager.handler { }
+        manager.every(1.minute, job_name, if: lambda { |t| t.year == 2000 })
+        manager.run(start_time: start_time)
+      end
+
+      it "runs the jobs at the time specified" do
+        expect(manager.ran_job?(job_name)).to be_truthy
+      end
+
+      it "resets time at the conclusion of the run" do
+        expect(Time.now.year).to be > 2000
+      end
+    end
+
+    context "speeding up the test run" do
+      let(:start_time) { Time.new(2015, 11, 2, 2, 0, 0) }
+      let(:end_time) { Time.new(2015, 11, 2, 3, 0, 0) }
+      let(:tick_speed) { 1.minute }
+      let(:job_name) { "Test job" }
+
+      before do
+        manager.handler { }
+        manager.every(1.minute, job_name)
+        manager.run(start_time: start_time, end_time: end_time, tick_speed: tick_speed)
+      end
+
+      it "runs the job as often as expected" do
+        expect(manager.times_run(job_name)).to eq 60
+      end
+
+      context "speeding up time" do
+        let(:tick_speed) { 30.minutes }
+        it "runs the job fewer times than it otherwise would" do
+          expect(manager.times_run(job_name)).to be < 60
+        end
+      end
+    end
+  end
+
+  describe "#ran_job?" do
+    let(:history) { double("history") }
+    let(:job) { double("job") }
+
+    it "determines if the job has run from the job history" do
+      allow(manager).to receive(:history).and_return(history)
+
+      expect(history).to receive(:ran_job?).with(job)
+      manager.ran_job?(job)
+    end
+  end
+
+  describe "#times_run" do
+    let(:history) { double("history") }
+    let(:job) { double("job") }
+
+    it "determines the number of times the job has run from the history" do
+      allow(manager).to receive(:history).and_return(history)
+
+      expect(history).to receive(:times_run).with(job)
+      manager.times_run(job)
+    end
+  end
+
+  describe "#block_for" do
+    let(:opts) { { max_ticks: max_ticks } }
+    let(:max_ticks) { 1 }
+    let(:job_name) { "Test job" }
+    before do
+      manager.every(1.minute, job_name) { "Running #{job_name}" }
+      manager.run
+    end
+
+    it "recalls the block that was run for a previously run job" do
+      expect(manager.block_for(job_name).call).to eq "Running #{job_name}"
+    end
+
+    it "does nothing for a job that was not run" do
+      expect(manager.block_for("not_run").call).to be_nil
+    end
+  end
+end

data/spec/clockwork/test_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Clockwork::Test do
+  let(:clock_file) { "spec/fixtures/clock.rb" }
+  let(:test_job_name) { "Run a job" }
+  let(:test_job_output) { "Here's a running job" }
+
+  it "has a version number" do
+    expect(Clockwork::Test::VERSION).not_to be nil
+  end
+
+  describe ".run" do
+    before { Clockwork::Test.run(file: clock_file, max_ticks: 1) }
+    after { Clockwork::Test.clear! }
+
+    it "runs the test job in the file" do
+      expect(Clockwork::Test.ran_job?(test_job_name)).to be_truthy
+    end
+
+    it "knows the job ran a single time" do
+      expect(Clockwork::Test.times_run(test_job_name)).to eq 1
+    end
+
+    it "retains a record of the work that the job would have done" do
+      expect(Clockwork::Test.block_for(test_job_name).call).to eq test_job_output
+    end
+  end
+end

data/spec/fixtures/clock.rb

@@ -0,0 +1,13 @@
+require "clockwork"
+
+module Clockwork
+  configure do |config|
+    config[:tz] = "US/Eastern"
+  end
+
+  handler { |job| logger.info "Running #{job}" }
+
+  every(1.minute, "Run a job") do
+    "Here's a running job"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'clockwork/test'
+
+require 'pry'
+require 'rspec/its'
+
+RSpec.configure do |config|
+  config.include(Clockwork::Test::RSpec::Matchers)
+end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: clockwork-test
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kevin Murphy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: clockwork
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Run clockwork jobs in a test environment and assert jobs are run as expected
+email:
+- murphy.kevin.mail@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- clockwork-test.gemspec
+- lib/clockwork/test.rb
+- lib/clockwork/test/event.rb
+- lib/clockwork/test/job_history.rb
+- lib/clockwork/test/manager.rb
+- lib/clockwork/test/rspec/matchers.rb
+- lib/clockwork/test/rspec/matchers/have_run.rb
+- lib/clockwork/test/version.rb
+- spec/acceptance/clock_spec.rb
+- spec/clockwork/test/job_history_spec.rb
+- spec/clockwork/test/manager_spec.rb
+- spec/clockwork/test_spec.rb
+- spec/fixtures/clock.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kevin-j-m/clockwork-test
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Test clockwork scheduled jobs
+test_files:
+- spec/acceptance/clock_spec.rb
+- spec/clockwork/test/job_history_spec.rb
+- spec/clockwork/test/manager_spec.rb
+- spec/clockwork/test_spec.rb
+- spec/fixtures/clock.rb
+- spec/spec_helper.rb