kuroko2 0.2.0

data/spec/workflow/script_parser_spec.rb

@@ -0,0 +1,119 @@
+require 'rails_helper'
+
+module Kuroko2::Workflow
+  describe ScriptParser do
+    subject(:parser) { ScriptParser.new(script) }
+
+    let(:root) { parser.parse }
+
+    describe '#parse' do
+      context 'with simple sequence' do
+        around do |example|
+          Node.register(key: :task1, klass: Task::Base)
+          Node.register(key: :task2, klass: Task::Base)
+          Node.register(key: :task3, klass: Task::Base)
+          Node.register(key: :task4, klass: Task::Base)
+
+          example.run
+
+          Node.deregister(:task1)
+          Node.deregister(:task2)
+          Node.deregister(:task3)
+          Node.deregister(:task4)
+        end
+
+        let(:script) do
+          <<-EOF
+# comment
+task1: # comment
+  task2: option
+
+task3: option # comment
+task4: OPTION='#option' # comment
+          EOF
+        end
+
+        it 'returns parsed nodes' do
+          expect(root.children.size).to eq 3
+
+          task1 = root.children.first
+          expect(task1.type).to eq :task1
+          expect(task1.children.size).to eq 1
+
+          task2 = task1.children.first
+          expect(task2.type).to eq :task2
+          expect(task2.option).to eq 'option'
+
+          task3 = root.children.second
+          expect(task3.type).to eq :task3
+          expect(task3.option).to eq 'option'
+
+          task4 = root.children.third
+          expect(task4.type).to eq :task4
+          expect(task4.option).to eq "OPTION='#option'"
+        end
+      end
+
+      context 'with nested indentation' do
+        let(:script) do
+          <<-EOF
+noop:
+  noop: option
+    noop: option
+  noop:
+    noop: option
+    noop: option
+noop:
+          EOF
+        end
+
+        it do
+          expect(root.children.size).to eq 2
+          expect(root.children.first.children.size).to eq 2
+          expect(root.children.first.children.first.children.size).to eq 1
+          expect(root.children.first.children.second.children.size).to eq 2
+        end
+      end
+
+      context 'with bad syntax' do
+        let(:script) { ':' }
+
+        it { expect { root }.to raise_error(Kuroko2::Workflow::SyntaxError) }
+      end
+
+      context 'with bad syntax' do
+        let(:script) do
+          <<-EOF
+noop
+          EOF
+        end
+
+        it { expect { root }.to raise_error(Kuroko2::Workflow::SyntaxError) }
+      end
+
+      context 'with inconsistent indentation' do
+        let(:script) do
+          <<-EOF
+noop:
+    noop: option
+  noop: option
+          EOF
+        end
+
+        it { expect { root }.to raise_error(Kuroko2::Workflow::SyntaxError) }
+      end
+
+      context 'with bad semantics' do
+        let(:script) do
+          <<-EOF
+fork:
+  timeout: a
+  noop:
+          EOF
+        end
+
+        it { expect { root }.to raise_error(Kuroko2::Workflow::AssertionError) }
+      end
+    end
+  end
+end

data/spec/workflow/shell_scanner_spec.rb

@@ -0,0 +1,47 @@
+require 'rails_helper'
+
+module Kuroko2::Workflow
+  describe ShellScanner do
+    subject(:scanner) { ShellScanner.new(text) }
+
+    describe '#strip_comment' do
+      let(:text) { 'foo # bar' }
+
+      it 'strips text after #' do
+        expect(scanner.strip_comment).to eq('foo ')
+      end
+
+      context 'given nil' do
+        let(:text) { nil }
+
+        it 'returns nil' do
+          expect(scanner.strip_comment).to eq(nil)
+        end
+      end
+
+      context 'given string literal including #' do
+        let(:text) { 'FOO="b\"ar#baz" # comment' }
+
+        it 'preserves # in string literal' do
+          expect(scanner.strip_comment).to eq('FOO="b\"ar#baz" ')
+        end
+      end
+
+      context 'given string literal including # in single quotes' do
+        let(:text) { %q[FOO='b\'ar#baz' # comment] }
+
+        it 'preserves # in string literal' do
+          expect(scanner.strip_comment).to eq(%q[FOO='b\'ar#baz' ])
+        end
+      end
+
+      context 'given unmatched quote' do
+        let(:text) { %q["' # foo] }
+
+        it 'returns text until #' do
+          expect(scanner.strip_comment).to eq(%q["' ])
+        end
+      end
+    end
+  end
+end

data/spec/workflow/task/auto_skip_error_spec.rb

@@ -0,0 +1,35 @@
+require 'rails_helper'
+
+module Kuroko2::Workflow::Task
+  describe AutoSkipError do
+    describe '#execute' do
+      let(:node) { Kuroko2::Workflow::Node.new('auto_skip_error', 'true') }
+      let(:token) { build(:token, context: {}) }
+
+      subject { AutoSkipError.new(node, token).execute }
+
+      it "sets AUTO_SKIP_ERROR context" do
+        subject
+        expect(token.context).to eq({ 'AUTO_SKIP_ERROR' => true })
+      end
+
+      context 'Without options' do
+        let(:node) { Kuroko2::Workflow::Node.new('auto_skip_error') }
+
+        it "sets AUTO_SKIP_ERROR context to false" do
+          subject
+          expect(token.context).to eq({ 'AUTO_SKIP_ERROR' => false })
+        end
+      end
+
+      context 'With false options' do
+        let(:node) { Kuroko2::Workflow::Node.new('auto_skip_error', 'false') }
+
+        it "sets AUTO_SKIP_ERROR context to false" do
+          subject
+          expect(token.context).to eq({ 'AUTO_SKIP_ERROR' => false })
+        end
+      end
+    end
+  end
+end

data/spec/workflow/task/env_spec.rb

@@ -0,0 +1,47 @@
+require 'rails_helper'
+
+module Kuroko2::Workflow::Task
+  describe Env do
+    describe '#execute' do
+      let(:token) { build(:token, script: 'env:', context: { 'ENV' => { 'EXISTING' => 'true' } }) }
+
+      context 'with valid syntax' do
+        before { Env.new(node, token).execute }
+        subject { token.context }
+
+        context 'with nil option' do
+          let(:node) { Kuroko2::Workflow::Node.new(:env) }
+
+          context 'with exisiting env' do
+            it { is_expected.to eq({ 'ENV' => { 'EXISTING' => 'true' } }) }
+          end
+
+          context 'without exisiting env' do
+            let(:token) { build(:token, script: 'env:') }
+
+            it { is_expected.to eq({}) }
+          end
+        end
+
+        context 'with valid option' do
+          let(:node) { Kuroko2::Workflow::Node.new(:env, 'A=1 B=2') }
+
+          it { is_expected.to eq({ 'ENV' => { 'A' => '1', 'B' => '2', 'EXISTING' => 'true' } }) }
+        end
+
+        context 'with quote' do
+          let(:node) { Kuroko2::Workflow::Node.new(:env, 'A="B=2 C=3"  D="E=5 F=\"6"' " G='\\'7'") }
+
+          it { is_expected.to eq({ 'ENV' => { 'A' => 'B=2 C=3', 'D' => 'E=5 F="6', 'G' => "'7", 'EXISTING' => 'true' } }) }
+        end
+      end
+
+      context 'with invalid syntax' do
+        let(:node) { Kuroko2::Workflow::Node.new(:env, 'A="B=2 C=3" D="E=5 F=\"6') }
+
+        it { expect { Env.new(node, token).execute }.to raise_error(Kuroko2::Workflow::AssertionError) }
+      end
+    end
+
+  end
+end

data/spec/workflow/task/execute_spec.rb

@@ -0,0 +1,127 @@
+require 'rails_helper'
+
+module Kuroko2::Workflow::Task
+  describe Execute do
+    subject { Execute.new(node, token).execute }
+
+    let(:context) { { 'ENV' => { 'NAME' => 'alice' } } }
+    let(:node) { Kuroko2::Workflow::Node.new(:execute, shell) }
+
+    let(:token) { create(:token, path: '/', script: 'execute:', context: context, job_definition: definition, job_instance: instance) }
+    let(:execution) { Kuroko2::Execution.take }
+    let(:definition) { create(:job_definition, script: "execute: echo HELLO\n") }
+    let(:instance) do
+      create(:job_instance, job_definition: definition).tap do |instance|
+        instance.tokens.destroy
+      end
+    end
+
+    context 'with shell script' do
+      let(:shell) { 'echo $NAME' }
+
+      specify do
+        is_expected.to eq :pass
+
+        expect(Kuroko2::Execution.all.size).to eq 1
+        expect(execution.token).to eql token
+        expect(execution.shell).to eq shell
+        expect(execution.context['ENV']).to eq context['ENV']
+      end
+    end
+
+    context 'with successfully completed' do
+      before do
+        create(:execution, token: token)
+      end
+
+      let(:shell) { 'echo $NAME' }
+
+      specify do
+        is_expected.to eq :next
+
+        expect(Kuroko2::Execution.all.size).to eq 0
+        expect(Kuroko2::Log.all.count).to eq 1
+      end
+    end
+
+    context 'With TIMEOUT' do
+      let(:shell) { 'sleep 5 && echo $NAME' }
+      let(:pid) { 1 }
+      let(:hostname) { 'myhost' }
+
+      around do |example|
+        Execute.new(node, token).execute
+
+        execution = Kuroko2::Execution.of(token).take
+        execution.update!(pid: pid)
+        create(:worker, hostname: hostname, execution_id: execution.id)
+
+        token.context['TIMEOUT'] = '1' # 1 minute
+        Timecop.travel(2.minutes.since) { example.run }
+      end
+
+      it 'creates ProcessSignal' do
+        expect { Execute.new(node, token).execute }.to change { Kuroko2::ProcessSignal.where(pid: execution.pid, hostname: hostname).count }.from(0).to(1)
+      end
+    end
+
+    context 'if job passed EXPECTED_TIME' do
+      let(:shell) { 'sleep 5 && echo $NAME' }
+
+      context 'Without EXPECTED_TIME_NOTIFIED_AT' do
+        around do |example|
+          Execute.new(node, token).execute
+          Kuroko2::Execution.of(token).take.update!(pid: 1)
+
+          Timecop.travel((24.hours + 1.second).since) { example.run }
+        end
+
+        it 'alerts warnings' do
+          expect(Kuroko2::Workflow::Notifier).to receive(:notify).with(:long_elapsed_time, token.job_instance)
+
+          Execute.new(node, token).execute
+          is_expected.to eq :pass
+          Execute.new(node, token).execute
+          expect(token.context['EXPECTED_TIME_NOTIFIED_AT']).to be_present
+        end
+      end
+
+      context 'With EXPECTED_TIME_NOTIFIED_AT' do
+        around do |example|
+          Execute.new(node, token).execute
+          Kuroko2::Execution.of(token).take.update!(pid: 1)
+
+          Timecop.travel((24.hours + 1.second).since) do
+            token.context['EXPECTED_TIME_NOTIFIED_AT'] = notified_time
+            example.run
+          end
+        end
+
+        context 'When EXPECTED_TIME_NOTIFIED_AT is now' do
+          let(:notified_time) { Time.now }
+
+          it 'does not alert warnings' do
+            expect(Kuroko2::Workflow::Notifier).not_to receive(:notify)
+            Execute.new(node, token).execute
+            is_expected.to eq :pass
+            Execute.new(node, token).execute
+            expect(token.context['EXPECTED_TIME_NOTIFIED_AT']).to be_present
+          end
+        end
+
+        context 'When EXPECTED_TIME_NOTIFIED_AT is 1 hours ago' do
+          let(:notified_time) { (1.hours + 1.second).ago }
+
+          it 'alert warnings' do
+            expect(Kuroko2::Workflow::Notifier).to receive(:notify).with(:long_elapsed_time, token.job_instance)
+
+            Execute.new(node, token).execute
+            is_expected.to eq :pass
+            Execute.new(node, token).execute
+            expect(token.context['EXPECTED_TIME_NOTIFIED_AT']).to be_present
+          end
+        end
+      end
+    end
+  end
+end

data/spec/workflow/task/expected_time_spec.rb

@@ -0,0 +1,52 @@
+require 'rails_helper'
+
+module Kuroko2::Workflow::Task
+  describe ExpectedTime do
+    describe '#execute' do
+      let(:node) { Kuroko2::Workflow::Node.new('expected_time', '100') }
+      let(:token) { build(:token, context: {}) }
+
+      subject { ExpectedTime.new(node, token).execute }
+
+      it "sets EXPECTED_TIME context" do
+        subject
+        expect(token.context).to eq({ 'EXPECTED_TIME' => 100 })
+      end
+
+      context 'With %d+h type' do
+        let(:node) { Kuroko2::Workflow::Node.new('expected_time', '10h') }
+
+        it "sets EXPECTED_TIME context" do
+          subject
+          expect(token.context).to eq({ 'EXPECTED_TIME' => 10*60 })
+        end
+      end
+
+      context 'With %d+m type' do
+        let(:node) { Kuroko2::Workflow::Node.new('expected_time', '10m') }
+
+        it "sets EXPECTED_TIME context" do
+          subject
+          expect(token.context).to eq({ 'EXPECTED_TIME' => 10 })
+        end
+      end
+
+      context 'Without options' do
+        let(:node) { Kuroko2::Workflow::Node.new('expected_time') }
+
+        it "does not sets EXPECTED_TIME context" do
+          subject
+          expect(token.context).to eq({})
+        end
+      end
+
+      context 'With non integer value' do
+        let(:node) { Kuroko2::Workflow::Node.new('expected_time', 'abc') }
+
+        it "raises error" do
+          expect { subject }.to raise_error(Kuroko2::Workflow::AssertionError)
+        end
+      end
+    end
+  end
+end

data/spec/workflow/task/fork_spec.rb

@@ -0,0 +1,30 @@
+require 'rails_helper'
+
+module Kuroko2::Workflow::Task
+  describe Fork do
+    let(:node) { Kuroko2::Workflow::ScriptParser.new(token.script).parse.find(token.path) }
+    let(:definition) { create(:job_definition) }
+    let(:instance) { create(:job_instance, job_definition: definition) }
+
+    let(:token) do
+      Kuroko2::Token.create(uuid: SecureRandom.uuid, path: '/0-fork', job_definition: definition, job_instance: instance, script: <<-EOF)
+fork:
+  noop: noop1
+  noop: noop2
+      EOF
+    end
+
+    describe '#execute' do
+      subject(:task) { Fork.new(node, token) }
+      let(:children) { token.children }
+
+      it do
+        expect(task.execute).to eq :pass
+
+        expect(children.size).to eq 2
+        expect(children.first.script).to eq "noop: noop1\n"
+        expect(children.second.script).to eq "noop: noop2\n"
+      end
+    end
+  end
+end

data/spec/workflow/task/queue_spec.rb

@@ -0,0 +1,45 @@
+require 'rails_helper'
+
+module Kuroko2::Workflow::Task
+  describe Queue do
+    describe '#execute' do
+      subject { token.context['QUEUE'] }
+
+      let(:token) { build(:token, script: 'queue:') }
+      let(:queue) { Kuroko2::Execution::DEFAULT_QUEUE }
+
+      before do
+        Kuroko2::Worker.create!(hostname: 'test', worker_id: 1, queue: queue, working: true)
+      end
+
+      context 'valid case' do
+        before { Kuroko2::Workflow::Task::Queue.new(node, token).execute }
+
+        context 'with default queue' do
+          let(:node) { Kuroko2::Workflow::Node.new(:queue) }
+
+          it { is_expected.to eq queue }
+        end
+
+        context 'with given queue' do
+          let(:queue) { 'queue_name' }
+          let(:node) { Kuroko2::Workflow::Node.new(:queue, queue) }
+
+          it { is_expected.to eq queue }
+        end
+      end
+
+      context 'with invalid queue' do
+        let(:node) { Kuroko2::Workflow::Node.new(:queue, '!invalid!') }
+
+        it { expect { Kuroko2::Workflow::Task::Queue.new(node, token).validate }.to raise_error(Kuroko2::Workflow::AssertionError) }
+      end
+
+      context 'with no existance queue' do
+        let(:node) { Kuroko2::Workflow::Node.new(:queue, 'invalid') }
+
+        it { expect { Kuroko2::Workflow::Task::Queue.new(node, token).validate }.to raise_error(Kuroko2::Workflow::AssertionError) }
+      end
+    end
+  end
+end

data/spec/workflow/task/rails_env_spec.rb

@@ -0,0 +1,30 @@
+require 'rails_helper'
+
+module Kuroko2::Workflow::Task
+  describe RailsEnv do
+    describe '#execute' do
+      let(:rails_env) { 'test' }
+      let(:node) { Kuroko2::Workflow::Node.new(:rails_env, rails_env) }
+      let(:token) { build(:token, context: {}) }
+
+      subject { RailsEnv.new(node, token).execute }
+
+      context 'with valid rails_env' do
+        it "sets RAILS_ENV" do
+          subject
+          expect(token.context).to eq({ 'RAILS_ENV' => 'test' })
+        end
+      end
+
+      context 'with invalid rails_env' do
+        let(:rails_env){ 'production' }
+        it { expect{ subject }.to raise_error(Kuroko2::Workflow::AssertionError) }
+      end
+
+      context 'with not exists rails_env' do
+        let(:rails_env){ 'xxxxxxx' }
+        it { expect{ subject }.to raise_error(Kuroko2::Workflow::AssertionError) }
+      end
+    end
+  end
+end

data/spec/workflow/task/sleep_spec.rb

@@ -0,0 +1,22 @@
+require 'rails_helper'
+
+module Kuroko2::Workflow::Task
+  describe Queue do
+    describe '#execute' do
+      around do |example|
+        Timecop.freeze(Time.at(time)) do
+          example.run
+        end
+      end
+      before { Sleep.new(node, token).execute }
+
+      let(:token) { build(:token, script: 'sleep:') }
+      let(:node) { Kuroko2::Workflow::Node.new(:sleep, seconds.to_s) }
+
+      let(:seconds) { 10 }
+      let(:time) { 1000000000 }
+
+      it { expect(token.context['SLEEP']).to eq (time + seconds) }
+    end
+  end
+end

data/spec/workflow/task/sub_process_spec.rb

@@ -0,0 +1,32 @@
+require 'rails_helper'
+
+module Kuroko2::Workflow::Task
+  describe SubProcess do
+    let(:definition) { create(:job_definition) }
+    let(:sub_definition) { create(:job_definition) }
+
+    let(:instance) do
+      create(:job_instance, job_definition: definition).tap do |instance|
+        instance.tokens.first.destroy
+      end
+    end
+
+    let(:node) { Kuroko2::Workflow::Node.new(:sub_process, sub_definition.id.to_s) }
+    let(:token) { create(:token, job_definition: definition, job_instance: instance) }
+
+    let(:sub_instance) { sub_definition.job_instances.first }
+
+    describe '#execute' do
+      subject(:task) { SubProcess.new(node, token) }
+
+      it do
+        expect(task.execute).to eq :pass
+        expect(Kuroko2::Token.count).to eq 2
+        expect(task.execute).to eq :pass
+
+        sub_instance.touch(:finished_at)
+        expect(task.execute).to eq :next
+      end
+    end
+  end
+end