rrrspec-server 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b1b9535524848e0a99da3e43112dd61f7172857
-  data.tar.gz: bcd9b01442e53052e1d7b8fbdc2f5e8e6657f79d
+  metadata.gz: 9625ccb0410299f07a3d0ef6930c82b5098e988d
+  data.tar.gz: 53072551cd5d091fde57fe140c13fcd7bca9604e
 SHA512:
-  metadata.gz: 5c6cd8ede5b4b339b584f2bade3a4ce24b732be8b04478beecd7251234a43310b40f73e700940109dc3e06ce2eb45130cd40298018b2f7b0714765d3440c04a1
-  data.tar.gz: 0018d23b28093ea4177556bf4bb1a1e40b4ad1b10c4179c863ec42a5b27b354f584799baf0e037d96b448bd026c76a8eb9443248182cbc12e82438f39661b01c
+  metadata.gz: 59b97dbd4247ff5596a2274eb40f1b5cea27142421de0d983853087ef186e5d2bd385b8bec4c58359e8b473937bf6149a2ec55b9f36b0af63414659d8e87a189
+  data.tar.gz: 4b4089c4edd6c9d966a20333c6d8ce16bd91ed2457de6098ad2fcbabf708c90dc6efd229378b15b787741ca0748e1ac855a24f847af74d5e96c6e592ff3276af

data/lib/rrrspec/server/daemonizer.rb

@@ -17,7 +17,6 @@ module RRRSpec
       end
       Process.daemon(false, true)
       File.write(pidfile, Process.pid.to_s)
-      File.umask(0)
       setup_signal_handlers
       setup_atexit_handlers(pidfile)
       monitor_fork do

data/lib/rrrspec/server/persister.rb

@@ -71,7 +71,7 @@ module RRRSpec
             h.delete('taskset')
             h.delete('trials')
             p_task = Persistence::Task.new(h)
-            p_task.taskset_id = p_taskset
+            p_task.taskset_id = p_taskset.id
             p_task
           end
           Persistence::Task.import(p_tasks)
@@ -92,8 +92,8 @@ module RRRSpec
               slave_key = h.delete('slave')['key']
               h.delete('task')
               p_trial = Persistence::Trial.new(h)
-              p_trial.task_id = p_task
-              p_trial.slave_id = p_slaves[slave_key]
+              p_trial.task_id = p_task.id
+              p_trial.slave_id = p_slaves[slave_key].id
 
               p_trials << p_trial
             end
@@ -109,7 +109,7 @@ module RRRSpec
             h.delete('worker')
             h.delete('taskset')
             p_worker_log = Persistence::WorkerLog.new(h)
-            p_worker_log.taskset_id = p_taskset
+            p_worker_log.taskset_id = p_taskset.id
             p_worker_log
           end
           Persistence::WorkerLog.import(p_worker_logs)

data/lib/rrrspec/server/version.rb

@@ -1,5 +1,5 @@
 module RRRSpec
   module Server
-    VERSION = "0.4.2"
+    VERSION = "0.4.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rrrspec-server
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Masaya Suzuki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-30 00:00:00.000000000 Z
+date: 2016-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: database_cleaner
@@ -98,36 +98,30 @@ dependencies:
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '4.0'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 4.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '4.0'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 4.2.0
 - !ruby/object:Gem::Dependency
   name: activerecord-import
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.1
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.1
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -204,14 +198,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.18.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.18.0
 description: Execute RSpec in a distributed manner
 email:
 - draftcode@gmail.com
@@ -220,9 +214,6 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- Gemfile
-- Rakefile
 - bin/rrrspec-server
 - db/migrate/20131105050718_create_tables.rb
 - db/migrate/20140221062741_expand_log.rb
@@ -241,15 +232,6 @@ files:
 - lib/rrrspec/server/statistics_updater.rb
 - lib/rrrspec/server/version.rb
 - lib/rrrspec/server/worker_runner.rb
-- rrrspec-server.gemspec
-- spec/fixture.rb
-- spec/rrrspec/server/arbiter_spec.rb
-- spec/rrrspec/server/dispatcher_spec.rb
-- spec/rrrspec/server/log_file_persister_spec.rb
-- spec/rrrspec/server/persistent_models_spec.rb
-- spec/rrrspec/server/persister_spec.rb
-- spec/rrrspec/server/statistics_updater_spec.rb
-- spec/spec_helper.rb
 - tasks/db.rake
 homepage: https://github.com/cookpad/rrrspec
 licenses:
@@ -271,16 +253,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Execute RSpec in a distributed manner
-test_files:
-- spec/fixture.rb
-- spec/rrrspec/server/arbiter_spec.rb
-- spec/rrrspec/server/dispatcher_spec.rb
-- spec/rrrspec/server/log_file_persister_spec.rb
-- spec/rrrspec/server/persistent_models_spec.rb
-- spec/rrrspec/server/persister_spec.rb
-- spec/rrrspec/server/statistics_updater_spec.rb
-- spec/spec_helper.rb
+test_files: []

data/.rspec

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

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'rrrspec-client', path: '../'
-gemspec

data/Rakefile

@@ -1,2 +0,0 @@
-require "bundler/gem_tasks"
-load File.expand_path('../tasks/db.rake', __FILE__)

data/rrrspec-server.gemspec

@@ -1,40 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'rrrspec/server/version'
-require 'pathname'
-
-Gem::Specification.new do |spec|
-  spec.name          = "rrrspec-server"
-  spec.version       = RRRSpec::Server::VERSION
-  spec.authors       = ["Masaya Suzuki"]
-  spec.email         = ["draftcode@gmail.com"]
-  spec.description   = "Execute RSpec in a distributed manner"
-  spec.summary       = "Execute RSpec in a distributed manner"
-  spec.homepage      = "https://github.com/cookpad/rrrspec"
-  spec.license       = "MIT"
-
-  gemspec_dir = File.expand_path('..', __FILE__)
-  spec.files  = `git ls-files`.split($/).
-    map { |f| File.absolute_path(f) }.
-    select { |f| f.start_with?(gemspec_dir) }.
-    map { |f| Pathname(f).relative_path_from(Pathname(gemspec_dir)).to_s }
-  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 "database_cleaner", "~> 1.2.0"
-  spec.add_development_dependency "mysql2"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "sqlite3"
-  spec.add_development_dependency "timecop"
-  spec.add_dependency "activerecord", ">= 4.0", "< 4.2"
-  spec.add_dependency "activerecord-import", "~> 0.4.1"
-  spec.add_dependency "activesupport"
-  spec.add_dependency "bundler"
-  spec.add_dependency "facter"
-  spec.add_dependency "redis"
-  spec.add_dependency "rrrspec-client"
-  spec.add_dependency "thor"
-end

data/spec/fixture.rb

@@ -1,32 +0,0 @@
-module RRRSpec
-  def self.finished_fullset
-    worker = Worker.create('default')
-    taskset = Taskset.create(
-      'testuser', 'echo 1', 'echo 2', 'default', 'default', 3, 3, 5, 5
-    )
-    task = Task.create(taskset, 10, 'spec/test_spec.rb')
-    taskset.add_task(task)
-    taskset.enqueue_task(task)
-    ActiveTaskset.add(taskset)
-    worker_log = WorkerLog.create(worker, taskset)
-    worker_log.set_rsync_finished_time
-    worker_log.append_log('worker_log log body')
-    worker_log.set_setup_finished_time
-    slave = Slave.create
-    taskset.add_slave(slave)
-    slave.append_log('slave log body')
-    trial = Trial.create(task, slave)
-    trial.start
-    trial.finish('pending', 'stdout body', 'stderr body', 10, 2, 0)
-    task.update_status('pending')
-    taskset.incr_succeeded_count
-    taskset.finish_task(task)
-    taskset.update_status('succeeded')
-    taskset.set_finished_time
-    ActiveTaskset.remove(taskset)
-    slave.update_status('normal_exit')
-    worker_log.set_finished_time
-
-    return worker, taskset, task, worker_log, slave, trial
-  end
-end

data/spec/rrrspec/server/arbiter_spec.rb

@@ -1,497 +0,0 @@
-require 'spec_helper'
-
-module RRRSpec
-  module Server
-    RSpec.describe Arbiter do
-      before do
-        RRRSpec.configuration = Configuration.new
-        RRRSpec.configuration.redis = @redis
-      end
-
-      let(:taskset) do
-        Taskset.create(
-          'testuser', 'echo 1', 'echo 2', 'default', 'default', 3, 3, 5, 5
-        )
-      end
-
-      let(:task1) do
-        Task.create(taskset, 10, 'spec/test_spec.rb')
-      end
-
-      before do
-        ActiveTaskset.add(taskset)
-      end
-
-      describe '.cancel' do
-        context 'with the taskset running' do
-          before { taskset.update_status('running') }
-
-          it 'cancels the taskset' do
-            Arbiter.cancel(taskset)
-            expect(taskset.status).to eq('cancelled')
-            expect(taskset).to be_queue_empty
-            expect(taskset.finished_at).not_to be_nil
-            expect(ActiveTaskset.list).not_to include(taskset)
-            expect(PersisterQueue).not_to be_empty
-          end
-        end
-
-        context 'with the taskset failed' do
-          before { taskset.update_status('failed') }
-
-          it 'does nothing' do
-            Arbiter.cancel(taskset)
-            expect(taskset.status).not_to eq('cancelled')
-            expect(ActiveTaskset.list).not_to include(taskset)
-            expect(PersisterQueue).not_to be_empty
-          end
-        end
-      end
-
-      describe '.check' do
-        before do
-          taskset.add_task(task1)
-          taskset.enqueue_task(task1)
-        end
-
-        context 'when the taskset is succeeded or failed or cancelled' do
-          before { taskset.update_status('failed') }
-          it 'does nothing' do
-            Arbiter.check(taskset)
-            expect(ActiveTaskset.list).not_to include(taskset)
-            expect(PersisterQueue).not_to be_empty
-          end
-        end
-
-        context 'with the taskset running' do
-          before { taskset.update_status('running') }
-
-          context 'with tasks_left having item' do
-            it 'calls check_task' do
-              expect(Arbiter).to receive(:check_task)
-              Arbiter.check(taskset)
-            end
-          end
-
-          context 'with tasks_left non-empty after check_task' do
-            context 'with the queue empty' do
-              before do
-                taskset.dequeue_task(0)
-              end
-              it 'calls requeue_speculative' do
-                expect(Arbiter).to receive(:requeue_speculative)
-                Arbiter.check(taskset)
-              end
-            end
-
-            context 'with the queue non-empty' do
-              it 'does nothing' do
-                Arbiter.check(taskset)
-                expect(taskset.status).to eq('running')
-                expect(taskset.finished_at).to be_blank
-                expect(ActiveTaskset.list).to include(taskset)
-                expect(PersisterQueue).to be_empty
-              end
-            end
-          end
-
-          context 'with tasks_left empty after check_task' do
-            before { taskset.finish_task(task1) }
-
-            context 'with all tasks succeeded' do
-              before { taskset.incr_succeeded_count }
-
-              it 'marks the taskset as succeeded' do
-                Arbiter.check(taskset)
-                expect(taskset.status).to eq("succeeded")
-                expect(taskset.finished_at).not_to be_blank
-                expect(ActiveTaskset.list).not_to include(taskset)
-                expect(PersisterQueue).not_to be_empty
-              end
-            end
-
-            context 'with some tasks failed' do
-              before { taskset.incr_failed_count }
-
-              it 'marks the taskset as failed' do
-                Arbiter.check(taskset)
-                expect(taskset.status).to eq("failed")
-                expect(taskset.finished_at).not_to be_nil
-                expect(ActiveTaskset.list).not_to include(taskset)
-                expect(PersisterQueue).not_to be_empty
-              end
-            end
-          end
-        end
-      end
-
-      describe '.check_task' do
-        before do
-          taskset.add_task(task1)
-          taskset.enqueue_task(task1)
-        end
-
-        let(:logger) { TimedLogger.new(taskset) }
-        let(:slave) { Slave.create }
-
-        context 'with some trials running' do
-          let(:trial1) { Trial.create(task1, slave) }
-
-          before do
-            trial1.start
-          end
-
-          context 'with the slave alive' do
-            before { slave.heartbeat(30) }
-
-            it 'does nothing' do
-              Arbiter.check_task(logger, taskset, task1)
-              expect(trial1.status).to be_blank
-            end
-          end
-
-          context 'with the slave failed' do
-            it 'marks error' do
-              Arbiter.check_task(logger, taskset, task1)
-              expect(trial1.status).to eq('error')
-            end
-          end
-        end
-
-        context 'with a trial passed' do
-          let(:trial1) { Trial.create(task1, slave) }
-          let(:trial2) { Trial.create(task1, slave) }
-
-          before do
-            trial1.start
-            trial1.finish('passed', '', '', nil, nil, nil)
-            trial2.start
-            trial2.finish('error', '', '', nil, nil, nil)
-          end
-
-          it 'sets status passed' do
-            Arbiter.check_task(logger, taskset, task1)
-            expect(task1.status).to eq('passed')
-            expect(taskset.tasks_left).not_to include(task1)
-            expect(taskset.succeeded_count).to eq(1)
-            expect(taskset.failed_count).to eq(0)
-          end
-        end
-
-        context 'with a trial pending' do
-          let(:trial1) { Trial.create(task1, slave) }
-          let(:trial2) { Trial.create(task1, slave) }
-
-          before do
-            trial1.start
-            trial1.finish('pending', '', '', nil, nil, nil)
-            trial2.start
-            trial2.finish('error', '', '', nil, nil, nil)
-          end
-
-          it 'sets status pending' do
-            Arbiter.check_task(logger, taskset, task1)
-            expect(task1.status).to eq('pending')
-            expect(taskset.tasks_left).not_to include(task1)
-            expect(taskset.succeeded_count).to eq(1)
-            expect(taskset.failed_count).to eq(0)
-          end
-        end
-
-        context 'with the task fully tried' do
-          let(:trial1) { Trial.create(task1, slave) }
-          let(:trial2) { Trial.create(task1, slave) }
-          let(:trial3) { Trial.create(task1, slave) }
-
-          before do
-            trial1.start
-            trial1.finish('error', '', '', nil, nil, nil)
-            trial2.start
-            trial2.finish('error', '', '', nil, nil, nil)
-            trial3.start
-            trial3.finish('error', '', '', nil, nil, nil)
-          end
-
-          it 'marks failed' do
-            Arbiter.check_task(logger, taskset, task1)
-            expect(task1.status).to eq('failed')
-            expect(taskset.tasks_left).not_to include(task1)
-            expect(taskset.succeeded_count).to eq(0)
-            expect(taskset.failed_count).to eq(1)
-          end
-        end
-
-        context 'when re-triable' do
-          let(:trial1) { Trial.create(task1, slave) }
-          let(:trial2) { Trial.create(task1, slave) }
-
-          before do
-            trial1.start
-            trial1.finish('error', '', '', nil, nil, nil)
-            trial2.start
-            trial2.finish('error', '', '', nil, nil, nil)
-          end
-
-          it 'does nothing' do
-            Arbiter.check_task(logger, taskset, task1)
-            expect(task1.status).to be_blank
-            expect(taskset.tasks_left).to include(task1)
-            expect(taskset.succeeded_count).to eq(0)
-            expect(taskset.failed_count).to eq(0)
-          end
-        end
-      end
-
-      describe '.requeue_speculative' do
-        let(:logger) { TimedLogger.new(taskset) }
-        let(:slave) { Slave.create }
-
-        let(:task2) do
-          Task.create(taskset, 10, 'spec/test_spec2.rb')
-        end
-
-        before do
-          taskset.add_task(task1)
-          taskset.add_task(task2)
-        end
-
-        context 'with some no-running-trial tasks' do
-          let(:trial1_1) { Trial.create(task1, slave) }
-
-          before do
-            trial1_1.start
-          end
-
-          it 'enqueues one no-running-trial task' do
-            Arbiter.requeue_speculative(logger, taskset, [task1, task2])
-            expect(taskset).not_to be_queue_empty
-            expect(taskset.dequeue_task(0)).to eq(task2)
-          end
-        end
-
-        context 'with all tasks running' do
-          let(:trial1_1) { Trial.create(task1, slave) }
-          let(:trial1_2) { Trial.create(task2, slave) }
-          let(:trial2_2) { Trial.create(task2, slave) }
-
-          before do
-            trial1_1.start
-            trial1_2.start
-            trial2_2.start
-          end
-
-          it 'enqueues one least tried task' do
-            Arbiter.requeue_speculative(logger, taskset, [task1, task2])
-            expect(taskset).not_to be_queue_empty
-            expect(taskset.dequeue_task(0)).to eq(task1)
-          end
-        end
-      end
-
-      describe '.fail' do
-        context 'with the taskset running' do
-          before { taskset.update_status('running') }
-
-          it 'fails the taskset' do
-            Arbiter.fail(taskset)
-            expect(taskset.status).to eq('failed')
-            expect(taskset).to be_queue_empty
-            expect(taskset.finished_at).not_to be_nil
-            expect(ActiveTaskset.list).not_to include(taskset)
-            expect(PersisterQueue).not_to be_empty
-          end
-        end
-
-        context 'with the taskset cancelled' do
-          before { taskset.update_status('cancelled') }
-
-          it 'does nothing' do
-            Arbiter.fail(taskset)
-            expect(taskset.status).not_to eq('failed')
-            expect(ActiveTaskset.list).not_to include(taskset)
-            expect(PersisterQueue).not_to be_empty
-          end
-        end
-      end
-
-      describe '.trial' do
-        before do
-          taskset.add_task(task1)
-          taskset.enqueue_task(task1)
-        end
-
-        before do
-          taskset.dequeue_task(0)
-        end
-
-        let(:slave) { Slave.create }
-        let(:trial) { Trial.create(task1, slave) }
-
-        context 'when the task is already finished' do
-          before { task1.update_status('passed') }
-
-          it 'does nothing' do
-            Arbiter.trial(trial)
-            expect(trial.status).to be_nil
-            expect(task1.status).to eq('passed')
-          end
-        end
-
-        context 'with the trial not-running' do
-          context 'with maximally retried' do
-            let(:trial2) { Trial.create(task1, slave) }
-            let(:trial3) { Trial.create(task1, slave) }
-
-            before do
-              trial2.finish('error', '', '', nil, nil, nil)
-              trial3.finish('error', '', '', nil, nil, nil)
-            end
-
-            it 'finishes the trial and marks the task failed' do
-              Arbiter.trial(trial)
-              expect(trial.status).to eq('error')
-              expect(task1.status).to eq('failed')
-              expect(taskset.tasks_left).not_to include(task1)
-              expect(taskset).to be_queue_empty
-              expect(taskset.succeeded_count).to eq(0)
-              expect(taskset.failed_count).to eq(1)
-            end
-          end
-
-          context 'when re-triable' do
-            it 'finishes the trial and requeues the task' do
-              Arbiter.trial(trial)
-              expect(trial.status).to eq('error')
-              expect(task1.status).to be_nil
-              expect(taskset.tasks_left).to include(task1)
-              expect(taskset.dequeue_task(0)).to eq(task1)
-              expect(taskset.succeeded_count).to eq(0)
-              expect(taskset.failed_count).to eq(0)
-            end
-          end
-        end
-
-        context 'with the trial passed' do
-          before do
-            trial.finish('passed', '', '', nil, nil, nil)
-          end
-
-          it 'marks the task as passed' do
-            Arbiter.trial(trial)
-            expect(task1.status).to eq('passed')
-            expect(taskset.tasks_left).not_to include(task1)
-            expect(taskset).to be_queue_empty
-            expect(taskset.succeeded_count).to eq(1)
-            expect(taskset.failed_count).to eq(0)
-          end
-        end
-
-        context 'with the trial pending' do
-          before { trial.finish('pending', '', '', 0, 1, 0) }
-
-          it 'marks the task as pending' do
-            Arbiter.trial(trial)
-            expect(task1.status).to eq('pending')
-            expect(taskset.tasks_left).not_to include(task1)
-            expect(taskset).to be_queue_empty
-            expect(taskset.succeeded_count).to eq(1)
-            expect(taskset.failed_count).to eq(0)
-          end
-        end
-
-        context 'with the trial failed' do
-          before { trial.finish('failed', '', '', 0, 0, 1) }
-
-          context 'with another trial running' do
-            let(:trial2) { Trial.create(task1, slave) }
-
-            before { trial2 }
-
-            context 'maximally retried' do
-              let(:trial3) { Trial.create(task1, slave) }
-              let(:trial4) { Trial.create(task1, slave) }
-
-              before do
-                trial3
-                trial4
-              end
-
-              context 'enough to judge failed' do
-                before do
-                  trial3.finish('error', '', '', nil, nil, nil)
-                  trial4.finish('error', '', '', nil, nil, nil)
-                end
-
-                it 'finishes the trial and marks the task failed' do
-                  Arbiter.trial(trial)
-                  expect(trial.status).to eq('failed')
-                  expect(task1.status).to eq('failed')
-                  expect(taskset.tasks_left).not_to include(task1)
-                  expect(taskset).to be_queue_empty
-                  expect(taskset.succeeded_count).to eq(0)
-                  expect(taskset.failed_count).to eq(1)
-                end
-              end
-
-              context 'not-enough to judge failed' do
-                it 'does nothing' do
-                  Arbiter.trial(trial)
-                  expect(task1.status).to be_blank
-                  expect(taskset.tasks_left).to include(task1)
-                  expect(taskset).to be_queue_empty
-                  expect(taskset.succeeded_count).to eq(0)
-                  expect(taskset.failed_count).to eq(0)
-                end
-              end
-            end
-
-            context 'retriable' do
-              before do
-                trial2.finish('error', '', '', nil, nil, nil)
-              end
-
-              it 'requeue the task' do
-                Arbiter.trial(trial)
-                expect(task1.status).to be_nil
-                expect(taskset.tasks_left).to include(task1)
-                expect(taskset.dequeue_task(0)).to eq(task1)
-                expect(taskset.succeeded_count).to eq(0)
-                expect(taskset.failed_count).to eq(0)
-              end
-            end
-          end
-
-          context 'maximally retried' do
-            let(:trial2) { Trial.create(task1, slave) }
-            let(:trial3) { Trial.create(task1, slave) }
-
-            before do
-              trial2.finish('error', '', '', nil, nil, nil)
-              trial3.finish('error', '', '', nil, nil, nil)
-            end
-
-            it 'marks the task as failed' do
-              Arbiter.trial(trial)
-              expect(task1.status).to eq('failed')
-              expect(taskset.tasks_left).not_to include(task1)
-              expect(taskset).to be_queue_empty
-              expect(taskset.succeeded_count).to eq(0)
-              expect(taskset.failed_count).to eq(1)
-            end
-          end
-
-          context 'when re-triable' do
-            it 'requeue the task' do
-              Arbiter.trial(trial)
-              expect(task1.status).to be_nil
-              expect(taskset.tasks_left).to include(task1)
-              expect(taskset.dequeue_task(0)).to eq(task1)
-              expect(taskset.succeeded_count).to eq(0)
-              expect(taskset.failed_count).to eq(0)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rrrspec/server/dispatcher_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-module RRRSpec
-  module Server
-    RSpec.describe Dispatcher do
-      before do
-        RRRSpec.configuration = Configuration.new
-        RRRSpec.configuration.redis = @redis
-      end
-
-      describe '#work' do
-        context 'when the worker no longer exists' do
-          let(:worker) { Worker.create('default', 'hostname1') }
-          before { worker }
-
-          it 'evicts the worker' do
-            Dispatcher.work
-            expect(Worker.list).not_to include(worker)
-          end
-        end
-
-        context 'a worker exists' do
-          let(:taskset) do
-            Taskset.create(
-              'testuser', 'echo 1', 'echo 2', 'default', 'default', 3, 3, 5, 5
-            )
-          end
-
-          let(:worker1) { Worker.create('default', 'hostname1') }
-          let(:worker2) { Worker.create('default', 'hostname2') }
-          let(:worker3) { Worker.create('default', 'hostname3') }
-          let(:worker4) { Worker.create('default', 'hostname4') }
-
-          before do
-            ActiveTaskset.add(taskset)
-            worker1.update_current_taskset(taskset)
-            worker1.heartbeat(30)
-            worker2.heartbeat(30)
-            worker3.heartbeat(30)
-            worker4.heartbeat(30)
-          end
-
-          it 'assignes worker upto the max_workers' do
-            Dispatcher.work
-            expect(worker1).to be_queue_empty
-            workers = [worker1, worker2, worker3, worker4]
-            expect(workers.count { |worker| worker.queue_empty? }).to eq(2)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rrrspec/server/log_file_persister_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-module RRRSpec
-  module Server
-    class TestClass
-      include LogFilePersister
-      def self.after_save(&block); end
-      save_as_file :log, suffix: 'log'
-
-      attr_accessor :key
-    end
-
-    RSpec.describe LogFilePersister do
-      before do
-        RRRSpec.configuration = ServerConfiguration.new
-        RRRSpec.configuration.execute_log_text_path = '/tmp/log_path'
-      end
-
-      describe '#log_log_path' do
-        subject { TestClass.new }
-
-        it 'subsitutes colons in the key' do
-          subject.key = 'rrrspec:test'
-          expect(subject.log_log_path).to eq('/tmp/log_path/rrrspec/test_log.log')
-        end
-
-        it 'subsitutes slashes in the key' do
-          subject.key = 'rrrspec:test/path'
-          expect(subject.log_log_path).to eq('/tmp/log_path/rrrspec/test_path_log.log')
-        end
-      end
-    end
-  end
-end

data/spec/rrrspec/server/persistent_models_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-module RRRSpec
-  module Server
-    module Persistence
-      RSpec.describe Taskset do
-        before do
-          RRRSpec.configuration = ServerConfiguration.new
-          RRRSpec.configuration.redis = @redis
-          RRRSpec.configuration.execute_log_text_path = Dir.mktmpdir
-        end
-
-        before do
-          @worker, @taskset, @task, @worker_log, @slave, @trial =
-            RRRSpec.finished_fullset
-          Persister.persist(@taskset)
-        end
-
-        describe '#as_nodetail_json' do
-          it 'produces a json object' do
-            h = @taskset.to_h
-            h.delete('slaves')
-            h.delete('tasks')
-            h.delete('worker_logs')
-
-            expect(
-              JSON.parse(JSON.generate(Taskset.first.as_nodetail_json()))
-            ).to eq(
-              JSON.parse(JSON.generate(h))
-            )
-          end
-        end
-
-        describe '#as_full_json' do
-          it 'produces a json object' do
-            h = @taskset.to_h
-            h['slaves'] = [@slave.to_h]
-
-            task_h = @task.to_h
-            task_h['trials'] = [@trial.to_h]
-            h['tasks'] = [task_h]
-
-            h['worker_logs'] = [@worker_log.to_h]
-
-            expect(
-              JSON.parse(JSON.generate(Taskset.first.as_full_json()))
-            ).to eq(
-              JSON.parse(JSON.generate(h))
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rrrspec/server/persister_spec.rb

@@ -1,125 +0,0 @@
-require 'spec_helper'
-
-module RRRSpec
-  module Server
-    RSpec.describe Persister do
-      before do
-        RRRSpec.configuration = ServerConfiguration.new
-        RRRSpec.configuration.redis = @redis
-        RRRSpec.configuration.execute_log_text_path = Dir.mktmpdir
-      end
-
-      before do
-        @worker, @taskset, @task, @worker_log, @slave, @trial =
-          RRRSpec.finished_fullset
-      end
-
-      after do
-        FileUtils.remove_entry_secure(RRRSpec.configuration.execute_log_text_path)
-      end
-
-      describe '.persist' do
-        let(:task_json) do
-          {
-            taskset: {key: @taskset.key},
-            estimate_sec: @task.estimate_sec,
-            key: @task.key,
-            spec_file: @task.spec_file,
-            status: @task.status,
-            trials: [{key: @trial.key}],
-          }
-        end
-
-        let(:slave_json) do
-          {
-            key: @slave.key,
-            log: @slave.log,
-            status: @slave.status,
-            trials: [{key: @trial.key}],
-          }
-        end
-
-        def log_path_of(filename)
-          File.join(RRRSpec.configuration.execute_log_text_path, filename)
-        end
-
-        let(:taskset_log_name)  { @taskset.key.gsub(/\//, '_').gsub(/:/, '/') + "_log.log" }
-        let(:worker_log_name)   { @worker_log.key.gsub(/\//, '_').gsub(/:/, '/') + "_worker_log.log" }
-        let(:slave_log_name)    { @slave.key.gsub(/\//, '_').gsub(/:/, '/') + "_slave_log.log" }
-        let(:trial_stdout_name) { @trial.key.gsub(/\//, '_').gsub(/:/, '/') + "_stdout.log" }
-        let(:trial_stderr_name) { @trial.key.gsub(/\//, '_').gsub(/:/, '/') + "_stderr.log" }
-
-        def eq_json(actual, expected)
-          expect(
-            JSON.parse(JSON.generate(actual))
-          ).to eq(
-            JSON.parse(JSON.generate(expected))
-          )
-        end
-
-        def check_persistence
-          Persister.persist(@taskset)
-          p_taskset = Persistence::Taskset.first
-          eq_json(p_taskset.as_short_json, @taskset)
-
-          expect(p_taskset.tasks.size).to eq(1)
-          p_task = p_taskset.tasks.first
-          eq_json(p_task.as_short_json, task_json)
-
-          trial = @task.trials[0]
-          expect(p_task.trials.size).to eq(1)
-          p_trial = p_task.trials.first
-          eq_json(p_trial.as_short_json, @trial)
-
-          expect(p_taskset.slaves.size).to eq(1)
-          p_slave = p_taskset.slaves.first
-          eq_json(p_slave.as_short_json, slave_json)
-
-          expect(p_taskset.worker_logs.size).to eq(1)
-          p_worker_log = p_taskset.worker_logs.first
-          eq_json(p_worker_log.as_short_json, @worker_log)
-        end
-
-        it 'persists the whole taskset' do
-          check_persistence
-        end
-
-        context 'when logs are too long' do
-          before do
-            RRRSpec.redis.hset(@trial.key, 'stdout', 'out' * 30000)
-          end
-
-          it 'saves full logs to the files' do
-            Persister.persist(@taskset)
-            expect(File.read(log_path_of(trial_stdout_name))).to eq(@trial.stdout)
-          end
-        end
-
-
-        it 'creates log text files' do
-          Persister.persist(@taskset)
-
-          expect(File.read(log_path_of(taskset_log_name))).to eq(@taskset.log)
-          expect(File.read(log_path_of(worker_log_name))).to eq(@worker_log.log)
-          expect(File.read(log_path_of(slave_log_name))).to eq(@slave.log)
-          expect(File.read(log_path_of(trial_stdout_name))).to eq(@trial.stdout)
-          expect(File.read(log_path_of(trial_stderr_name))).to eq(@trial.stderr)
-        end
-
-        context "trial is finished after the taskset's finish" do
-          before do
-            @late_trial = Trial.create(@task, @slave)
-            @late_trial.start
-            Timecop.freeze(Time.now+1) do
-              @late_trial.finish('error', '', '', nil, nil, nil)
-            end
-          end
-
-          it "does not persist trials finished after taskset's finish" do
-            check_persistence
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rrrspec/server/statistics_updater_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-module RRRSpec
-  module Server
-    RSpec.describe StatisticsUpdater do
-      before do
-        RRRSpec.configuration = ServerConfiguration.new
-        RRRSpec.configuration.redis = @redis
-
-        @worker, @taskset, @task, @worker_log, @slave, @trial =
-          RRRSpec.finished_fullset
-      end
-
-      describe '.update_estimate_sec' do
-        before { Persister.persist(@taskset) }
-
-        xit 'updates estimation of the time taken to finish the tasks' do
-          pending "sqlite3 doesn't have UNIT_TIMESTAMP function"
-          Persister.update_estimate_sec(@taskset)
-          expect(RRRSpec::TasksetEstimation.estimate_secs(@taskset.taskset_class)).to eq(
-            {"spec/test_spec.rb" => 0}
-          )
-        end
-      end
-    end
-  end
-end
-

data/spec/spec_helper.rb

@@ -1,76 +0,0 @@
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-require 'rrrspec/server'
-require 'tmpdir'
-require 'database_cleaner'
-require 'timecop'
-require 'fixture'
-
-RSpec.configure do |config|
-  config.raise_errors_for_deprecations!
-  config.disable_monkey_patching!
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-
-  # 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'
-
-  pid = nil
-  config.before(:suite) do
-    pid = Kernel.spawn("redis-server --port 9999 --save ''",
-                       in: '/dev/null', out: '/dev/null', err: '/dev/null')
-    redis = Redis.new(port: 9999)
-    retry_count = 1
-    loop do
-      begin
-        redis.client.connect
-        break
-      rescue Redis::CannotConnectError
-        if retry_count < 10
-          retry_count += 1
-          sleep 0.01
-          retry
-        end
-        raise
-      end
-    end
-  end
-
-  config.before(:each) do
-    @redis = Redis.new(port: 9999)
-    @redis.flushall
-
-    RRRSpec.configuration = nil
-    RRRSpec.flushredis
-    RRRSpec.hostname = 'testhostname'
-  end
-
-  config.after(:suite) do
-    Process.kill('KILL', pid) if pid
-  end
-
-  config.before(:suite) do
-    ActiveRecord::Base.establish_connection(
-      adapter: "sqlite3", database: ":memory:"
-    )
-    ActiveRecord::Migration.verbose = false
-    ActiveRecord::Migrator.up "db/migrate"
-    DatabaseCleaner.strategy = :transaction
-    DatabaseCleaner.clean_with(:truncation)
-  end
-
-  config.before(:each) do
-    DatabaseCleaner.start
-  end
-
-  config.after(:each) do
-    DatabaseCleaner.clean
-  end
-end