kuroko2 0.2.0

data/spec/models/job_schedule_spec.rb

@@ -0,0 +1,121 @@
+require 'rails_helper'
+
+describe Kuroko2::JobSchedule do
+
+  describe '#valid?' do
+    it 'accepts only CRON notation' do
+      expect(Kuroko2::JobSchedule.new(cron: '* * * * *')).to be_valid
+      expect(Kuroko2::JobSchedule.new(cron: '1,2-3,*,*/4,5-6/7 1,2-3,*,*/4,5-6/7 1,2-3,*,*/4,5-6/7 1,2-3,*,*/4,5-6/7 1,2-3,*,*/4,1-3/5')).to be_valid
+      expect(Kuroko2::JobSchedule.new(cron: '* * * *')).not_to be_valid
+    end
+
+    it 'accepts only valid CRON notation' do
+      expect(Kuroko2::JobSchedule.new(cron: '5-0 * * * *')).not_to be_valid
+    end
+  end
+
+  describe '#next' do
+    let(:cron) { '0,15,30,45 10 * * *' }
+    let(:definition) { create(:job_definition) }
+    let(:schedule) { create(:job_schedule, job_definition: definition, cron: cron) }
+    let(:time) { Time.new(2016, 1, 1, 10, 0) }
+
+    context 'Without suspend_schelule' do
+      it 'returns next schedule' do
+        expect(schedule.next(time)).to eq(Time.new(2016, 1, 1, 10, 15))
+      end
+    end
+
+    context 'With suspend_schelule' do
+      before do
+        create(:job_suspend_schedule, job_definition: definition, cron: '0-29 10 * * *')
+      end
+
+      it 'skips suspend time range' do
+        expect(schedule.next(time)).to eq(Time.new(2016, 1, 1, 10, 30))
+      end
+    end
+
+    context 'When suspend schelules covers all schedule' do
+      before do
+        create(:job_suspend_schedule, job_definition: definition, cron: '0-50 10 * * *')
+      end
+
+      it 'returns nil' do
+        expect(schedule.next(time)).to be_nil
+      end
+    end
+
+    context 'With invalid date' do
+      let(:cron) { '* * 31 2 *' }
+      let(:time) { Time.new(2016, 2, 28, 10, 0) }
+      xit 'occurs infinit loop (https://github.com/r7kamura/chrono/issues/2)' do
+        expect(schedule.next(time)).to eq(Time.new(2016, 1, 1, 10, 15))
+      end
+    end
+  end
+
+  describe '.launch_scheduled_jobs!' do
+    let(:definition) { create(:job_definition) }
+    let(:time_from) { Time.new(2016, 1, 1, 9, 50, 0) }
+
+    before do
+      create(:job_schedule, job_definition: definition, cron: '0 10 * * *')
+    end
+
+    context 'Without scheduled time' do
+      let(:time_to) { Time.new(2016, 1, 1, 9, 58, 0) }
+
+      it 'does not launch jobs' do
+        expect { Kuroko2::JobSchedule.launch_scheduled_jobs!(time_from, time_to) }.
+          not_to change { Kuroko2::JobInstance.count }
+      end
+    end
+
+    context 'With scheduled time' do
+      let(:time_to) { Time.new(2016, 1, 1, 10, 1, 0) }
+
+      it 'launches jobs' do
+        expect { Kuroko2::JobSchedule.launch_scheduled_jobs!(time_from, time_to) }.
+          to change { Kuroko2::JobInstance.count }.from(0).to(1)
+      end
+
+      context 'With suspended option' do
+        before do
+          definition.update!(suspended: true)
+        end
+
+        it 'does not launch jobs' do
+          expect { Kuroko2::JobSchedule.launch_scheduled_jobs!(time_from, time_to) }.
+            not_to change { Kuroko2::JobInstance.count }
+        end
+      end
+    end
+
+    context 'With job_suspend_schedule' do
+      before do
+        create(:job_schedule, job_definition: definition, cron: '* 10 * * *')
+        create(:job_suspend_schedule, cron: '0-30 10 * * *', job_definition: definition)
+      end
+
+      context 'On supended time' do
+        let(:time_from) { Time.new(2016, 1, 1, 9, 50, 0) }
+        let(:time_to)   { Time.new(2016, 1, 1, 10, 1, 0) }
+
+        it 'does not launch jobs' do
+          expect { Kuroko2::JobSchedule.launch_scheduled_jobs!(time_from, time_to) }.
+            not_to change { Kuroko2::JobInstance.count }
+        end
+      end
+
+      context 'Out of supended time' do
+        let(:time_from) { Time.new(2016, 1, 1, 10, 30, 0) }
+        let(:time_to)   { Time.new(2016, 1, 1, 10, 31, 0) }
+        it 'launches jobs' do
+          expect { Kuroko2::JobSchedule.launch_scheduled_jobs!(time_from, time_to) }.
+            to change { Kuroko2::JobInstance.count }.from(0).to(1)
+        end
+      end
+    end
+  end
+end

data/spec/models/job_suspend_schedule_spec.rb

@@ -0,0 +1,32 @@
+require 'rails_helper'
+
+describe Kuroko2::JobSuspendSchedule do
+  describe '#valid?' do
+    it 'accepts only CRON notation' do
+      expect(Kuroko2::JobSuspendSchedule.new(cron: '* * * * *')).to be_valid
+      expect(Kuroko2::JobSuspendSchedule.new(cron: '1,2-3,*,*/4,5-6/7 1,2-3,*,*/4,5-6/7 1,2-3,*,*/4,5-6/7 1,2-3,*,*/4,5-6/7 1,2-3,*,*/4,1-3/5')).to be_valid
+      expect(Kuroko2::JobSuspendSchedule.new(cron: '* * * *')).not_to be_valid
+    end
+
+    it 'accepts only valid CRON notation' do
+      expect(Kuroko2::JobSuspendSchedule.new(cron: '5-0 * * * *')).not_to be_valid
+    end
+  end
+
+  describe '#suspend_times' do
+    let(:suspend_schedule) { create(:job_suspend_schedule, cron: '* 10 * * *') }
+    let(:time_from) { Time.new(2016, 1, 1, 10, 0, 0) }
+    let(:time_to) { Time.new(2016, 1, 1, 10, 5, 0) }
+
+    it 'returns suspend times' do
+      expect(suspend_schedule.suspend_times(time_from, time_to)).to eq([
+        Time.new(2016, 1, 1, 10, 0, 0),
+        Time.new(2016, 1, 1, 10, 1, 0),
+        Time.new(2016, 1, 1, 10, 2, 0),
+        Time.new(2016, 1, 1, 10, 3, 0),
+        Time.new(2016, 1, 1, 10, 4, 0),
+        Time.new(2016, 1, 1, 10, 5, 0),
+      ])
+    end
+  end
+end

data/spec/models/memory_consumption_log_spec.rb

@@ -0,0 +1,50 @@
+require 'rails_helper'
+
+RSpec.describe Kuroko2::MemoryConsumptionLog do
+  around {|example| Timecop.freeze(Time.now) { example.run } }
+
+  describe described_class::Interval do
+    describe '#reached?' do
+      let(:interval) { described_class.new(base, count) }
+      let(:base) { Time.now }
+
+      context 'count = 0 and 2 seconds since' do
+        let(:count) { 0 }
+        let(:now) { 2.seconds.since.to_time }
+        it { expect(interval.reached?(now)).to be_truthy }
+      end
+
+      context 'count = 10 and 2 minutes since' do
+        let(:count) { 10 }
+        let(:now) { 2.minutes.since.to_time }
+        it { expect(interval.reached?(now)).to be_truthy }
+      end
+
+      context 'count = 100 and 31 minutes since' do
+        let(:count) { 100 }
+        let(:now) { 31.minutes.since.to_time }
+        it { expect(interval.reached?(now)).to be_truthy }
+      end
+    end
+
+    describe '#next' do
+      it 'returns count-up-ed Interval' do
+        a = described_class.new(Time.now)
+        b = a.next
+        expect(b).to be_a(described_class)
+
+        diff = b.count - a.count
+        expect(diff).to eq(1)
+      end
+    end
+
+    it 'behaves as certain period interval with #reached? and #next' do
+      a = described_class.new(Time.now, 100)
+      expect(a.reached?(29.minutes.since.to_time)).to be_falsy
+      expect(a.reached?(31.minutes.since.to_time)).to be_truthy
+      b = a.next
+      expect(b.reached?(59.minutes.since.to_time)).to be_falsy
+      expect(b.reached?(61.minutes.since.to_time)).to be_truthy
+    end
+  end
+end

data/spec/models/memory_expectancy_spec.rb

@@ -0,0 +1,26 @@
+require 'rails_helper'
+
+RSpec.describe Kuroko2::MemoryExpectancy do
+  let!(:definition) { create(:job_definition) }
+  let!(:instance) { create(:job_instance, job_definition: definition) }
+  let!(:expectancy) { described_class.create!(job_definition: definition) }
+
+  describe 'memory expectancy calculation' do
+    before { (1..10).each {|i| instance.log_memory_consumption(i) } }
+
+    it 'logs consumptions then calculates expectancy' do
+      expect(expectancy.expected_value).to eq(described_class::DEFAULT_VALUE)
+      expectancy.calculate!
+      expect(expectancy.reload.expected_value).not_to eq(described_class::DEFAULT_VALUE)
+    end
+  end
+
+  describe '#calculate!' do
+    before { (1..10).each {|i| instance.log_memory_consumption(i) } }
+
+    it 'uses max consumption value' do
+      expectancy.calculate!
+      expect(expectancy.expected_value).to eq(10)
+    end
+  end
+end

data/spec/models/star_spec.rb

@@ -0,0 +1,4 @@
+require 'rails_helper'
+
+describe Kuroko2::Star do
+end

data/spec/models/tick_spec.rb

@@ -0,0 +1,23 @@
+require 'rails_helper'
+
+describe Kuroko2::Tick do
+  describe '.fetch_then_update' do
+    let(:prev_now) { Time.at(123456789) }
+    let(:now) { Time.at(1234567890) }
+
+    context 'without previous tick' do
+      it do
+        expect(Kuroko2::Tick.fetch_then_update(now)).to eq now
+        expect(Kuroko2::Tick.first.at).to eq now
+      end
+    end
+    context 'with previous tick' do
+      before { create(:tick, at: prev_now) }
+
+      it do
+        expect(Kuroko2::Tick.fetch_then_update(now)).to eq prev_now
+        expect(Kuroko2::Tick.first.at).to eq now
+      end
+    end
+  end
+end

data/spec/models/token_spec.rb

@@ -0,0 +1,54 @@
+require 'rails_helper'
+
+describe Kuroko2::Token do
+  describe '#cancelable?' do
+    context 'without children' do
+      context 'working' do
+        subject! { create(:token, status: Kuroko2::Token::WORKING) }
+
+        it { is_expected.not_to be_cancelable }
+      end
+      context 'finished' do
+        subject! { create(:token, status: Kuroko2::Token::FINISHED) }
+
+        it { is_expected.not_to be_cancelable }
+      end
+      context 'failure' do
+        subject! { create(:token, status: Kuroko2::Token::FAILURE) }
+
+        it { is_expected.to be_cancelable }
+      end
+      context 'critical' do
+        subject! { create(:token, status: Kuroko2::Token::CRITICAL) }
+
+        it { is_expected.not_to be_cancelable }
+      end
+    end
+
+    context 'with children' do
+      subject!(:parent) { create(:token, status: Kuroko2::Token::WORKING) }
+
+      context 'all children are working' do
+        before { create(:token, parent_id: parent.id, status: Kuroko2::Token::WORKING) }
+        before { create(:token, parent_id: parent.id, status: Kuroko2::Token::WORKING) }
+
+        it { is_expected.not_to be_cancelable }
+      end
+
+      context 'working and failrue' do
+        before { create(:token, parent_id: parent.id, status: Kuroko2::Token::WORKING) }
+        before { create(:token, parent_id: parent.id, status: Kuroko2::Token::FAILURE) }
+
+        it { is_expected.not_to be_cancelable }
+      end
+
+      context 'finished and failure' do
+        before { create(:token, parent_id: parent.id, status: Kuroko2::Token::FINISHED) }
+        before { create(:token, parent_id: parent.id, status: Kuroko2::Token::FAILURE) }
+
+        it { is_expected.to be_cancelable }
+      end
+
+    end
+  end
+end

data/spec/models/user_spec.rb

@@ -0,0 +1,17 @@
+require 'rails_helper'
+
+describe Kuroko2::User do
+  describe '#google_account?' do
+    subject { user.google_account? }
+
+    context 'provider is google_oauth2' do
+      let(:user) { create(:user, provider: 'google_oauth2') }
+      it { is_expected.to be_truthy }
+    end
+
+    context 'provider is not google_oauth2' do
+      let(:user) { create(:user, provider: 'group_email') }
+      it { is_expected.to be_falsey }
+    end
+  end
+end

data/spec/models/worker_spec.rb

@@ -0,0 +1,5 @@
+require 'rails_helper'
+
+describe Kuroko2::Worker do
+
+end

data/spec/rails_helper.rb

@@ -0,0 +1,81 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path('../dummy/config/environment.rb', __FILE__)
+# Prevent database truncation if the environment is production
+abort("The Rails environment is running in production mode!") if Rails.env.production?
+
+require 'spec_helper'
+require 'rspec/rails'
+# Add additional requires below this line. Rails is not loaded until this point!
+require 'factory_girl_rails'
+
+require 'timecop'
+Timecop.safe_mode = true
+
+require 'webmock/rspec'
+WebMock.disable_net_connect!(allow_localhost: true)
+
+require 'capybara/rspec'
+require 'capybara/poltergeist'
+Capybara.javascript_driver = :poltergeist
+
+OmniAuth.config.test_mode = true
+
+# Requires supporting ruby files with custom matchers and macros, etc, in
+# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
+# run as spec files by default. This means that files in spec/support that end
+# in _spec.rb will both be required and run as specs, causing the specs to be
+# run twice. It is recommended that you do not name files matching this glob to
+# end with _spec.rb. You can configure this pattern with with the --pattern
+# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+# Checks for pending migrations before tests are run.
+# If you are not using ActiveRecord, you can remove this line.
+ActiveRecord::Migration.maintain_test_schema!
+
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+  config.include SignInHelper, type: :controller
+  config.include FeatureSignInHelper, type: :feature
+  config.include WaitForAjax, type: :feature
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = false
+
+  # RSpec Rails can automatically mix in different behaviours to your tests
+  # based on their file location, for example enabling you to call `get` and
+  # `post` in specs under `spec/controllers`.
+  #
+  # You can disable this behaviour by removing the line below, and instead
+  # explicitly tag your specs with their type, e.g.:
+  #
+  #     RSpec.describe UsersController, :type => :controller do
+  #       # ...
+  #     end
+  #
+  # The different available types are documented in the features, such as in
+  # https://relishapp.com/rspec/rspec-rails/docs
+  config.infer_spec_type_from_file_location!
+
+  # Filter lines from Rails gems in backtraces.
+  config.filter_rails_from_backtrace!
+  # arbitrary gems may also be filtered via:
+  # config.filter_gems_from_backtrace("gem name")
+
+  config.after(:each) do
+    Capybara.reset_sessions!
+    DatabaseRewinder.clean
+  end
+
+  config.around do |e|
+    begin
+      original_env = ENV.to_h.dup
+      e.run
+    ensure
+      ENV.replace(original_env)
+    end
+  end
+end

data/spec/requests/api/job_instances_spec.rb

@@ -0,0 +1,96 @@
+require 'rails_helper'
+
+describe 'job_instances' do
+  let(:service_name) { :test_client_name }
+  let(:secret_key)   { 'secret_key' }
+  let(:result) { JSON.parse(response.body) }
+  let(:env) do
+    {
+      accept: 'application/json',
+      authorization: "Basic #{Base64.encode64("#{service_name}:#{secret_key}")}",
+    }
+  end
+  let(:definition) do
+    create(:job_definition, script: 'execute: bundle exec rake test:execute', api_allowed: true)
+  end
+
+  describe 'GET /v1/definitions/:job_definition_name/instances/:job_instance_id' do
+    context 'with job_instance working' do
+      let(:instance) { create(:job_instance, job_definition: definition, finished_at: nil, error_at: nil, canceled_at: nil) }
+
+      it 'returns "working" as status' do
+        get "/v1/definitions/#{definition.id}/instances/#{instance.id}", params: {}, env: env
+        expect(response.status).to eq(200)
+        expect(result).to eq({
+          'id'     => instance.id,
+          'status' => 'working',
+        })
+      end
+    end
+
+    context 'with job_instance succeeded' do
+      let(:instance) { create(:job_instance, job_definition: definition, finished_at: Time.now, error_at: nil, canceled_at: nil) }
+
+      it 'returns "success" as status' do
+        get "/v1/definitions/#{definition.id}/instances/#{instance.id}", params: {}, env: env
+        expect(response.status).to eq(200)
+        expect(result).to eq({
+          'id'     => instance.id,
+          'status' => 'success',
+        })
+      end
+    end
+  end
+
+  describe 'POST /v1/definitions/:job_definition_name/instances' do
+    let(:params) { {} }
+
+    it 'creates a job_instance' do
+      expect {
+        post "/v1/definitions/#{definition.id}/instances", params: params, env: env
+      }.to change {
+        definition.job_instances.count
+      }.by(1)
+      expect(definition.job_instances.last.script).to eq(definition.script)
+      expect(result).to match({
+        'id' => a_kind_of(Integer),
+        'status' => 'working',
+      })
+    end
+
+    context 'given env parameter' do
+      let(:env_vars) do
+        { 'JOB_NAME' => 'TestJob', 'MESSAGE' => %q{["it's a job"]} }
+      end
+      let(:params) { { env: env_vars } }
+
+      it 'creates a job_instance with env task' do
+        expect {
+          post "/v1/definitions/#{definition.id}/instances", params: params, env: env
+        }.to change {
+          definition.job_instances.count
+        }.by(1)
+        expect(definition.job_instances.last.script).to eq(<<-SCRIPT.strip_heredoc.rstrip)
+          env: JOB_NAME='TestJob'
+          env: MESSAGE='["it\\'s a job"]'
+          #{definition.script}
+        SCRIPT
+      end
+    end
+
+    context 'when job_definition is not api_allowed' do
+      let(:definition) do
+        create(:job_definition, script: 'execute: bundle exec rake test:execute', api_allowed: false)
+      end
+
+      it 'does not create a job_instance' do
+        expect {
+          post "/v1/definitions/#{definition.id}/instances", params: params, env: env
+        }.to_not change {
+          definition.job_instances.count
+        }
+        expect(response.status).to eq(403)
+      end
+    end
+  end
+end

data/spec/requests/api/stats_spec.rb

@@ -0,0 +1,45 @@
+require 'rails_helper'
+
+describe 'stats api' do
+  describe 'GET /v1/stats/instance' do
+    before do
+      create(:job_instance, job_definition: create(:job_definition))
+      create(:job_instance, job_definition: create(:job_definition)).touch(:error_at)
+
+      get '/v1/stats/instance'
+    end
+
+    it 'returns instance stats json' do
+      expect(response.status).to eq(200)
+      result = JSON.parse(response.body)
+      expect(result).to eq({
+        "kuroko2.job_instances.working" => 1,
+        "kuroko2.job_instances.error" => 1,
+      })
+    end
+  end
+
+  describe 'GET /v1/stats/waiting_execution' do
+    let!(:worker) { create(:worker) }
+
+    before do
+      create(
+        :execution,
+        job_definition: create(:job_definition),
+        token: create(:token),
+        started_at: nil,
+        created_at: 4.minutes.ago,
+      )
+
+      get '/v1/stats/waiting_execution'
+    end
+
+    it 'returns waiting execution stats json' do
+      expect(response.status).to eq(200)
+      result = JSON.parse(response.body)
+      expect(result).to eq({
+        "kuroko2.executions.waiting.#{worker.queue}" => 1
+      })
+    end
+  end
+end

data/spec/return_to_validator_spec.rb

@@ -0,0 +1,28 @@
+require 'rails_helper'
+
+RSpec.describe Kuroko2::ReturnToValidator do
+  let(:validator) { described_class }
+
+  describe '.valid?' do
+    it 'accepts a valid path' do
+      expect(validator).to be_valid('/users/1')
+    end
+
+    it 'rejects absolute URI' do
+      expect(validator).to_not be_valid('http://example.net')
+    end
+
+    it 'rejects protocol-relative URI' do
+      expect(validator).to_not be_valid('//example.net')
+    end
+
+    it 'rejects non-URI' do
+      expect(validator).to_not be_valid(nil)
+      expect(validator).to_not be_valid('http:')
+    end
+
+    it 'rejects path starting with @' do
+      expect(validator).to_not be_valid('@example.net')
+    end
+  end
+end

data/spec/settings_spec.rb

@@ -0,0 +1,10 @@
+require 'rails_helper'
+
+module Kuroko2
+  describe 'Check if settings is loaded' do
+    it 'loads custom tasks' do
+      expect(Workflow::Node::TASK_REGISTORY).to have_key(:custom_task1)
+      expect(Workflow::ScriptParser.new('custom_task1:').parse).to be_a(Workflow::Node)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,49 @@
+# This file was generated by the `rails generate rspec:install` 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, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files 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|
+  # 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|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  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|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end