vx-worker 0.2.0.pre28

data/spec/lib/worker/job_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe Vx::Worker::Job do
+  let(:message) { create :message, 'PerformJob' }
+  let(:job)     { described_class.new message   }
+
+  subject { job }
+
+  context "just created" do
+    its(:message)        { should eq message }
+    its(:output)         { should be_an_instance_of(Vx::Common::OutputBuffer) }
+    its(:output_counter) { should eq 0 }
+  end
+
+  context "publish_job_log_message" do
+    let(:data) { 'log' }
+    subject { job.publish_job_log_message data }
+
+    it { should be_an_instance_of(Vx::Message::JobLog) }
+    its(:job_id)   { should eq job.message.job_id }
+    its(:build_id) { should eq job.message.id     }
+    its(:tm)       { should eq 1 }
+    its(:log)      { should eq data }
+
+    it "should increment counter" do
+      expect {
+        subject
+      }.to change(job, :output_counter).by(1)
+    end
+  end
+
+  context "add_to_output" do
+    let(:data)     { 'data' }
+    let(:messages) { Vx::Worker::JobLogsConsumer.messages }
+    subject do
+      job.add_to_output(data)
+      job.output.flush
+      job
+    end
+
+    it "should delivery message" do
+      expect {
+        subject
+      }.to change(messages, :size).by(1)
+      expect(messages.first.log).to eq data
+    end
+
+    it "should increment output_counter" do
+      expect {
+        subject
+      }.to change(job, :output_counter).by(1)
+      expect(messages.first.tm).to eq 1
+    end
+  end
+
+  context "add_command_to_output" do
+    let(:data)     { 'data' }
+    let(:messages) { Vx::Worker::JobLogsConsumer.messages }
+    subject do
+      job.add_command_to_output(data)
+      job.output.flush
+      job
+    end
+
+    it "should delivery message" do
+      expect {
+        subject
+      }.to change(messages, :size).by(1)
+      expect(messages.first.log).to eq "$ #{data}\n"
+    end
+
+    it "should increment output_counter" do
+      expect {
+        subject
+      }.to change(job, :output_counter).by(1)
+      expect(messages.first.tm).to eq 1
+    end
+  end
+
+  context "add_trace_to_output" do
+    let(:data)     { 'data' }
+    let(:messages) { Vx::Worker::JobLogsConsumer.messages }
+    subject do
+      job.add_trace_to_output(data)
+      job.output.flush
+      job
+    end
+
+    it "should delivery message" do
+      expect {
+        subject
+      }.to change(messages, :size).by(1)
+      expect(messages.first.log).to eq " ===> #{data}\n"
+    end
+
+    it "should increment output_counter" do
+      expect {
+        subject
+      }.to change(job, :output_counter).by(1)
+      expect(messages.first.tm).to eq 1
+    end
+  end
+
+end

data/spec/lib/worker/local_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Vx::Worker::Local do
+  let(:options) { { } }
+  let(:job)     { create :job, options }
+  let(:local)   { described_class.new job, nil }
+  subject { local }
+
+  context "perform" do
+    subject { local.perform }
+
+    before do
+      Vx::Worker.config.run = "local"
+    end
+
+    it { should eq 0 }
+
+    context "when fail before_script" do
+      let(:options) { { before_script: "/bin/false" } }
+      it { should eq(-1) }
+    end
+
+    context "when fail script" do
+      let(:options) { { script: "/bin/false" } }
+      it { should satisfy { |n| [1,127].include?(n) } }
+    end
+  end
+
+end

data/spec/lib/worker/middlewares/log_job_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Vx::Worker::LogJob do
+  let(:exit_code)   { 0 }
+  let(:app)         { ->(_) { exit_code } }
+  let(:job)         { create :job }
+  let(:env)         { OpenStruct.new job: job }
+  let(:mid)         { described_class.new app }
+
+  subject { mid.call env }
+
+  it { should eq 0 }
+
+end
+

data/spec/lib/worker/middlewares/run_script_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Vx::Worker::RunScript do
+  let(:exit_code)     { 0 }
+  let(:app)           { ->(_) { exit_code } }
+  let(:script)        { "echo script" }
+  let(:before_script) { "echo before_script" }
+  let(:after_script)  { "echo after_script" }
+  let(:job)           { create :job,
+                          script: script,
+                          before_script: before_script,
+                          after_script: after_script }
+  let(:env)           { OpenStruct.new job: job }
+  let(:mid)           { described_class.new app }
+  let(:connector_mid) { Vx::Worker::StartConnector.new(mid) }
+
+  subject { connector_mid.call env }
+
+  shared_examples "run script" do
+
+    it "should be" do
+      expect(subject).to eq 0
+      job.release
+      expect(all_job_log_output).to match("script")
+      expect(all_job_log_output).to match("after_script")
+    end
+
+    context "when script failed" do
+      let(:script) { "false" }
+      it "should be" do
+        expect(subject).to eq(1)
+        job.release
+        expect(all_job_log_output).to match("after_script")
+      end
+    end
+
+    context "when  before_script failed" do
+      let(:before_script) { "false" }
+      it "should be" do
+        expect(subject).to eq(-1)
+        job.release
+        expect(all_job_log_output).to match("after_script")
+      end
+    end
+  end
+
+  context "local connector" do
+    before do
+      Vx::Worker.config.run = "local"
+    end
+
+    it_should_behave_like "run script"
+  end
+
+  context "local connector", docker: true do
+    before do
+      Vx::Worker.config.run = "docker"
+    end
+
+    it_should_behave_like "run script"
+  end
+end
+

data/spec/lib/worker/middlewares/start_connector_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Vx::Worker::StartConnector do
+  let(:exit_code)   { 0 }
+  let(:app)         { ->(_) { exit_code } }
+  let(:job)         { create :job }
+  let(:env)         { OpenStruct.new job: job }
+  let(:mid)         { described_class.new app }
+
+  subject { mid.call env }
+
+  context "local connector" do
+    before do
+      Vx::Worker.config.run = "local"
+    end
+
+    it "should successfully start" do
+      expect(subject).to eq 0
+      expect(env.connector).to be
+    end
+  end
+
+  context "docker connector", docker: true do
+    before do
+      Vx::Worker.config.run = "docker"
+    end
+
+    it "should successfully start" do
+      expect(subject).to eq 0
+      expect(env.connector).to be
+    end
+  end
+end
+

data/spec/lib/worker/middlewares/timeout_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Vx::Worker::Timeout do
+  let(:exit_code) { 0 }
+  let(:app)       { ->(_) { exit_code } }
+  let(:env)       { OpenStruct.new }
+  let(:mid)       { described_class.new app }
+
+  subject { mid.call env }
+
+  it { should eq 0 }
+
+  context "when timeout happened" do
+    let(:app) { ->(_) { sleep 1 ; exit_code } }
+
+    before do
+      mock(mid)._timeout { 0.1 }
+    end
+
+    it "should raise" do
+      expect {
+        subject
+      }.to raise_error(Timeout::Error)
+    end
+  end
+
+end
+

data/spec/lib/worker/middlewares/update_job_status_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Vx::Worker::UpdateJobStatus do
+  let(:exit_code)   { 0 }
+  let(:app)         { ->(_) { exit_code } }
+  let(:job)         { create :job }
+  let(:env)         { OpenStruct.new job: job }
+  let(:mid)         { described_class.new app }
+  let(:messages)    { Vx::Worker::JobStatusConsumer.messages }
+
+  subject { mid.call env }
+
+  it "should delivery 2 messages" do
+    expect {
+      subject
+    }.to change(messages, :size).by(2)
+  end
+
+  { 0 => 3, 1 => 4, -1 => 5 }.each do |code, status|
+    context "when exit code is #{code}" do
+      let(:exit_code) { code }
+      it { should eq code }
+
+      context "messages" do
+        before { mid.call env }
+
+        context "first" do
+          subject { messages.first }
+          it_should_behave_like "UpdateJobStatus message" do
+            its(:status) { should eq 2 }
+          end
+        end
+
+        context "last" do
+          subject { messages.last }
+          it_should_behave_like "UpdateJobStatus message" do
+            its(:status) { should eq status }
+          end
+        end
+
+      end
+    end
+  end
+
+  context "when raise exception" do
+    let(:app) { ->(_) { raise "Ignore Me" } }
+    it { should eq(-1) }
+
+    context "messages" do
+      before { mid.call env }
+
+      context "first" do
+        subject { messages.first }
+        it_should_behave_like "UpdateJobStatus message" do
+          its(:status) { should eq 2 }
+        end
+      end
+
+      context "last" do
+        subject { messages.last }
+        it_should_behave_like "UpdateJobStatus message" do
+          its(:status) { should eq 5 }
+        end
+      end
+    end
+
+    context "Timeout::Error" do
+      let(:app) { ->(_) { raise Timeout::Error.new("Timeout Ignore Me") } }
+
+      it { should eq(-1) }
+    end
+  end
+
+end
+

data/spec/lib/worker_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Vx::Worker do
+
+  context ".perform" do
+    let(:job) { create :job }
+    let(:run) { :docker }
+    subject { described_class.perform job, '/tmp' }
+
+    before do
+      described_class.configure do |c|
+        c.run = run
+      end
+    end
+
+    context "when run at :docker" do
+      let(:run) { :docker }
+      let(:docker) { 'docker' }
+      before do
+        mock(Vx::Worker::Docker).new(job, '/tmp') { docker }
+        mock(docker).perform { true }
+      end
+
+      it { should be }
+    end
+
+    context "when run at :local" do
+      let(:run) { :local }
+      let(:local) { 'local' }
+      before do
+        mock(Vx::Worker::Local).new(job, '/tmp') { local }
+        mock(local).perform { true }
+      end
+
+      it { should be }
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require File.expand_path '../../lib/vx/worker', __FILE__
+
+Bundler.require(:test)
+require 'rspec/autorun'
+require 'vx/common/amqp/testing'
+require 'vx/message/testing'
+
+Dir[File.expand_path("../..", __FILE__) + "/spec/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.mock_with :rr
+
+  config.before(:each) do
+    Vx::Common::AMQP::Testing.clear
+    Vx::Worker.reset_config!
+
+    Vx::Worker.configure do |c|
+=begin
+      c.docker.ssh.port = 2223
+      c.docker.ssh.host = 'localhost'
+      c.docker.create_options = {
+        'PortSpecs' => ['2022:22']
+      }
+=end
+    end
+  end
+end

data/spec/support/all_job_log_output.rb

@@ -0,0 +1,3 @@
+def last_job_log_message
+  Vx::Worker::JobLogsConsumer.messages.last
+end

data/spec/support/create.rb

@@ -0,0 +1,19 @@
+require 'yaml'
+
+def create(who, *args)
+
+  options = args.last.is_a?(Hash) ? args.pop : {}
+
+  case who
+
+  when :message
+    name  = args.shift
+    klass = Vx::Message.const_get name
+    klass.test_message options
+
+  when :job
+    message = options[:message] || create(:message, 'PerformJob', options)
+    Vx::Worker::Job.new message
+
+  end
+end

data/spec/support/last_job_logs_message.rb

@@ -0,0 +1,3 @@
+def all_job_log_output
+  Vx::Worker::JobLogsConsumer.messages.map{|i| i.log }.join("\n")
+end

data/spec/support/shared_examples/update_job_status_message_spec.rb

@@ -0,0 +1,6 @@
+shared_examples "UpdateJobStatus message" do
+  its(:build_id) { should eq job.message.id }
+  its(:job_id)   { should eq job.message.job_id }
+  its(:matrix)   { should eq job.message.matrix_keys }
+  its(:tm)       { should be }
+end

data/vx-worker.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require File.expand_path('../lib/vx/worker/version.rb', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = "vx-worker"
+  spec.version       = Vx::Worker::VERSION
+  spec.authors       = ["Dmitry Galinsky"]
+  spec.email         = ["dima.exe@gmail.com"]
+  spec.description   = %q{ ci worker }
+  spec.summary       = %q{ ci worker }
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_runtime_dependency 'vx-common',               "= #{Vx::Worker::VERSION}"
+  spec.add_runtime_dependency 'vx-message',              "= #{Vx::Worker::VERSION}"
+  spec.add_runtime_dependency 'vx-container_connector',  "= #{Vx::Worker::VERSION}"
+  spec.add_runtime_dependency 'vx-common-amqp', '~> 0.2.5'
+  spec.add_runtime_dependency 'hashr',          '= 0.0.22'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rr"
+end