shoulda-whenever 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b556da7fd43cfccee5935c3c6a63eb2fd51ec05b
+  data.tar.gz: e57ef2772b14aa2ea0b04ea4ad1ae5c34ef48d5e
+SHA512:
+  metadata.gz: fed62e52acf39bd842e32adcf34192b7a431edd89bdf938dd3b0f24617eb7e77c48f87f12f075a883d5b866728a895a17a1aa27526b40262f20dbf23ac65e9af
+  data.tar.gz: 8a59abf46d0c53c03c24609c1fca40458a9ee444d9b9f69c4ded72cccff07e7153713c8e36b58f7e55472e2c22f104da1be2192c9895435f78be30deba286301

data/.gitignore

@@ -0,0 +1,4 @@
+bin/
+vendor/
+.bundle
+.rspec

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem "rspec", "~> 3.3.0"
+gem "whenever", "~> 0.9.4"

data/Gemfile.lock

@@ -0,0 +1,27 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    chronic (0.10.2)
+    diff-lcs (1.2.5)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    whenever (0.9.4)
+      chronic (>= 0.6.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec (~> 3.3.0)
+  whenever (~> 0.9.4)

data/README.md

@@ -0,0 +1,33 @@
+# shoulda-whenever
+
+This gem was born out of a desire to test the schedule for tasks being scheduled with Whenever. Not to test if Whenever can generate the proper CRON schedule, but to test whether I can generate the proper `config/schedule.rb`. It turns out I can't sometimes.
+
+## How to use this Gem
+
+Add this to you gemfile:
+
+```ruby
+gem "shoulda-whenever", "~> 0.0.1", "https://github.com/MGerrior/shoulda-whenever.git"
+```
+
+Create a new schedule to be tested at `config/schedule.rb` (or anywhere really, but for the sake of the README, that's where it is):
+
+```ruby
+every :friday, at: "12:00 PM" do
+  runner "Notifier.send_team_lunch_email"
+end
+```
+
+Create a new test file for testing your schedule, perhaps something like `spec/schedule_spec.rb`:
+
+```ruby
+describe "Schedule" do
+  include Shoulda::Whenever
+  
+  let(:whenever) { Whenever::JobList.new(file: File.join(Rails.root, "config", "schedule.rb").to_s) }
+  
+  it "sends out the team lunch reminder email every friday at noon" do
+    expect(whenever).to schedule("Notifier.send_team_lunch_email").every(:friday).at("12:00 PM")
+  end
+end
+```

data/lib/shoulda/whenever/schedule_matcher.rb

@@ -0,0 +1,149 @@
+module Shoulda
+  module Whenever
+    def schedule(task)
+      ScheduleMatcher.new(task)
+    end
+
+    alias_method :schedule_rake, :schedule
+    alias_method :schedule_runner, :schedule
+    alias_method :schedule_command, :schedule
+
+    class ScheduleMatcher
+      attr_reader :duration, :time, :task, :roles
+
+      def initialize(task)
+        @task = task
+        @duration = nil
+        @time = nil
+        @roles = nil
+      end
+
+      def matches?(subject)
+        jobs = subject.instance_variable_get("@jobs")
+
+        jobs = filter_jobs_by_duration(jobs)
+        jobs = filter_jobs_by_time(jobs)
+        jobs = filter_jobs_by_roles(jobs)
+        jobs = filter_jobs_by_task(jobs)
+
+        jobs.any?
+      end
+
+      def filter_jobs_by_duration(jobs)
+        if duration.nil?
+          jobs.values.flatten
+        else
+          duration_to_fetch = if duration.is_a?(String) || duration.is_a?(Symbol)
+                                duration
+                              else
+                                duration.to_i
+                              end
+
+          jobs.fetch(duration_to_fetch) { [] }
+        end
+      end
+
+      def filter_jobs_by_time(jobs)
+        return jobs if time.nil?
+
+        jobs.select { |job| job.at == time }
+      end
+
+      def filter_jobs_by_roles(jobs)
+        return jobs if roles.nil? || roles.empty?
+
+        jobs.select { |job| job.roles == roles }
+      end
+
+      def filter_jobs_by_task(jobs)
+        jobs.select do |job|
+          job.instance_variable_get("@options")[:task] == task
+        end
+      end
+
+      def every(duration)
+        @duration = duration
+
+        self
+      end
+
+      def at(time)
+        @time = time
+
+        self
+      end
+
+      def with_roles(roles)
+        @roles = Array(roles)
+
+        self
+      end
+      alias_method :with_role, :with_roles
+
+      def description
+        [
+          base_description,
+          duration_description,
+          time_description,
+          roles_description
+        ].compact.join(' ')
+      end
+
+      def failure_message
+        [
+          base_failure_message,
+          duration_description,
+          time_description,
+          roles_description
+        ].compact.join(' ')
+      end
+
+      def failure_message_when_negated
+        [
+          base_failure_message_when_negated,
+          duration_description,
+          time_description,
+          roles_description
+        ].compact.join(' ')
+      end
+
+      private
+
+      def base_description
+        "schedule \"#{ task }\""
+      end
+
+      def duration_description
+        unless duration.nil?
+          if duration.is_a?(String) || duration.is_a?(Symbol)
+            "every \"#{ duration }\""
+          else
+            "every #{ duration.to_i } seconds"
+          end
+        end
+      end
+
+      def time_description
+        unless time.nil?
+          "at \"#{ time }\""
+        end
+      end
+
+      def roles_description
+        unless roles.nil? || roles.empty?
+          role_names = roles.map { |role| "\"#{ role }\"" }.join(", ")
+
+          "with #{ role_names } role(s)"
+        end
+      end
+
+      def base_failure_message
+        "expected to schedule \"#{ task }\""
+      end
+
+      def base_failure_message_when_negated
+        "expected not to schedule \"#{ task }\""
+      end
+    end
+  end
+end

data/lib/shoulda/whenever/version.rb

@@ -0,0 +1,5 @@
+module Shoulda
+  module Whenever
+    VERSION = "0.0.1".freeze
+  end
+end

data/lib/shoulda/whenever.rb

@@ -0,0 +1,6 @@
+require "shoulda/whenever/schedule_matcher"
+
+module Shoulda
+  module Whenever
+  end
+end

data/lib/shoulda.rb

@@ -0,0 +1,4 @@
+require "shoulda/whenever"
+
+module Shoulda
+end

data/shoulda-whenever.gemspec

@@ -0,0 +1,23 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), "lib")
+require 'shoulda/whenever/version'
+
+Gem::Specification.new do |s|
+  s.name        = "shoulda-whenever"
+  s.version     = Shoulda::Whenever::VERSION.dup
+  s.authors     = ["Matthew Gerrior"]
+  s.date        = Time.now.strftime("%Y-%m-%d")
+  s.email       = "gerrior.matthew@gmail.com"
+  s.homepage    = "http://rubygems.org/gems/shoulda-whenever"
+  s.summary     = "Shoulda style matchers for whenever gem"
+  s.license     = "MIT"
+  s.description = "This gem is designed to make it easier to test that the schedule you built with the 'whenever' gem is accurate."
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.add_development_dependency "rspec", "~> 3.3.0"
+  s.add_development_dependency "whenever", "~> 0.9.4"
+end

data/spec/shoulda/whenever/schedule_matcher_spec.rb

@@ -0,0 +1,228 @@
+require "spec_helper"
+require "whenever"
+require "shoulda/whenever/schedule_matcher"
+require "rspec/matchers/fail_matchers"
+
+describe Shoulda::Whenever::ScheduleMatcher do
+  include Shoulda::Whenever
+  include RSpec::Matchers::FailMatchers
+
+  let(:whenever) { Whenever::JobList.new(string: schedule_string) }
+
+  describe "#description" do
+    context "basic schedule check" do
+      it "includes the task being scheduled" do
+        expect(described_class.new("rake:every:10:minutes").description).to eq("schedule \"rake:every:10:minutes\"")
+      end
+    end
+
+    context "with a duration" do
+      it "includes the duration at which the task is being scheduled" do
+        expect(
+          described_class.new("rake:every:10:minutes")
+          .every(Whenever::NumericSeconds.seconds(10, "minutes"))
+                         .description
+        ).to eq("schedule \"rake:every:10:minutes\" every 600 seconds")
+      end
+    end
+
+    context "with a time to run" do
+      it "includes the time at which the task is scheduled to run" do
+        expect(
+          described_class.new("rake:every:10:minutes")
+                         .at("12:00 PM")
+                         .description
+        ).to eq("schedule \"rake:every:10:minutes\" at \"12:00 PM\"")
+      end
+    end
+
+    context "with a cron schedule" do
+      it "includes the schedule" do
+        expect(
+          described_class.new("rake:every:1:day:at:noon")
+                         .every("0 0 27-31 * *")
+                         .description
+        ).to eq("schedule \"rake:every:1:day:at:noon\" every \"0 0 27-31 * *\"")
+      end
+    end
+
+    context "with a symbol schedule" do
+      it "includes the schedule" do
+        expect(
+          described_class.new("rake:every:1:day:at:noon")
+                         .every(:friday)
+                         .description
+        ).to eq("schedule \"rake:every:1:day:at:noon\" every \"friday\"")
+      end
+    end
+
+    context "with a role" do
+      it "includes the role" do
+        expect(
+          described_class.new("rake:every:day").with_role(:app).description
+        ).to eq("schedule \"rake:every:day\" with \"app\" role(s)")
+      end
+    end
+
+    context "with multiple roles" do
+      it "includes the roles" do
+        expect(
+          described_class.new("rake:every:day").with_roles([:app, :database, :redis]).description
+        ).to eq("schedule \"rake:every:day\" with \"app\", \"database\", \"redis\" role(s)")
+      end
+    end
+  end
+
+  context "a task that is not scheduled" do
+    let(:schedule_string) { "" }
+
+    it "passes" do
+      expect(whenever).not_to schedule("MyTask.run")
+    end
+
+    it "fails" do
+      expect {
+        expect(whenever).to schedule("MyTask.run")
+      }.to fail_with("expected to schedule \"MyTask.run\"")
+    end
+  end
+
+  context "a task that is scheduled" do
+    let(:schedule_string) do
+      <<-SCHEDULE
+        every 3.hours do
+          rake "rake:every:3:hours"
+        end
+      SCHEDULE
+    end
+
+    it "passes" do
+      expect(whenever).to schedule("rake:every:3:hours")
+    end
+
+    it "fails" do
+      expect {
+        expect(whenever).not_to schedule("rake:every:3:hours")
+      }.to fail_with("expected not to schedule \"rake:every:3:hours\"")
+    end
+  end
+
+  context "a task that is scheduled after a certain duration" do
+    let(:schedule_string) do
+      <<-SCHEDULE
+        every 3.hours do
+          rake "rake:every:3:hours"
+        end
+      SCHEDULE
+    end
+
+    it "passes" do
+      expect(whenever).to schedule("rake:every:3:hours").every(Whenever::NumericSeconds.seconds(3, "hours"))
+    end
+     it "fails" do
+       expect {
+         expect(whenever).not_to schedule("rake:every:3:hours").every(Whenever::NumericSeconds.seconds(3, "hours"))
+       }.to fail_with("expected not to schedule \"rake:every:3:hours\" every 10800 seconds")
+     end
+  end
+
+  context "a task that is scheduled to run at a certain time" do
+    let(:schedule_string) do
+      <<-SCHEDULE
+        every 1.day, at: "12:00 PM" do
+          rake "rake:every:day:at:noon"
+        end
+      SCHEDULE
+    end
+
+    it "passes" do
+      expect(whenever).to schedule("rake:every:day:at:noon").every(Whenever::NumericSeconds.seconds(1, "day")).at("12:00 PM")
+    end
+
+    it "fails" do
+      expect {
+        expect(whenever).not_to schedule("rake:every:day:at:noon").every(Whenever::NumericSeconds.seconds(1, "day")).at("12:00 PM")
+      }.to fail_with("expected not to schedule \"rake:every:day:at:noon\" every 86400 seconds at \"12:00 PM\"")
+    end
+  end
+
+  context "a task that is scheduled for a certain day" do
+    let(:schedule_string) do
+      <<-SCHEDULE
+        every :friday do
+          rake "rake:every:friday"
+        end
+      SCHEDULE
+    end
+
+    it "passes" do
+      expect(whenever).to schedule("rake:every:friday").every(:friday)
+    end
+
+    it "fails" do
+      expect {
+        expect(whenever).not_to schedule("rake:every:friday").every(:friday)
+      }.to fail_with("expected not to schedule \"rake:every:friday\" every \"friday\"")
+    end
+  end
+
+  context "a task that is scheduled with cron syntax" do
+    let(:schedule_string) do
+      <<-SCHEDULE
+        every '0 0 27-31 * *'  do
+          rake "rake:end:of:month"
+        end
+      SCHEDULE
+    end
+
+    it "passes" do
+      expect(whenever).to schedule("rake:end:of:month").every("0 0 27-31 * *")
+    end
+
+    it "fails" do
+      expect {
+        expect(whenever).not_to schedule("rake:end:of:month").every("0 0 27-31 * *")
+      }.to fail_with("expected not to schedule \"rake:end:of:month\" every \"0 0 27-31 * *\"")
+    end
+  end
+
+  context "a task that is scheduled for a certain role" do
+    let(:schedule_string) do
+      <<-SCHEDULE
+        every 10.minutes, roles: [:app] do
+          rake "rake:every:10:minutes"
+        end
+      SCHEDULE
+    end
+
+    it "passes" do
+      expect(whenever).to schedule("rake:every:10:minutes").with_role(:app)
+    end
+
+    it "fails" do
+      expect {
+        expect(whenever).not_to schedule("rake:every:10:minutes").with_role(:app)
+      }.to fail_with("expected not to schedule \"rake:every:10:minutes\" with \"app\" role(s)")
+    end
+  end
+
+  context "a task that is scheduled for multiple roles" do
+    let(:schedule_string) do
+      <<-SCHEDULE
+        every 10.minutes, roles: [:app, :database] do
+          rake "rake:every:10:minutes"
+        end
+      SCHEDULE
+    end
+
+    it "passes" do
+      expect(whenever).to schedule("rake:every:10:minutes").with_roles([:app, :database])
+    end
+
+    it "fails" do
+      expect {
+        expect(whenever).not_to schedule("rake:every:10:minutes").with_roles([:app, :database])
+      }.to fail_with("expected not to schedule \"rake:every:10:minutes\" with \"app\", \"database\" role(s)")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,78 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+=end
+end

data/spec/support/schedule.rb

@@ -0,0 +1,3 @@
+every 3.hours do
+  rake "run:every:3:hours"
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: shoulda-whenever
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Matthew Gerrior
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: whenever
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.4
+description: This gem is designed to make it easier to test that the schedule you
+  built with the 'whenever' gem is accurate.
+email: gerrior.matthew@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- lib/shoulda.rb
+- lib/shoulda/whenever.rb
+- lib/shoulda/whenever/schedule_matcher.rb
+- lib/shoulda/whenever/version.rb
+- shoulda-whenever.gemspec
+- spec/shoulda/whenever/schedule_matcher_spec.rb
+- spec/spec_helper.rb
+- spec/support/schedule.rb
+homepage: http://rubygems.org/gems/shoulda-whenever
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Shoulda style matchers for whenever gem
+test_files:
+- spec/shoulda/whenever/schedule_matcher_spec.rb
+- spec/spec_helper.rb
+- spec/support/schedule.rb
+has_rdoc: