Add strategy for DockerContainerPool

In order to provide an alternative to Poseidon, a strategy for the
DockerContainerPool is added that is used by the runner model.

Co-authored-by: Sebastian Serth <Sebastian.Serth@hpi.de>

spec/lib/runner/strategy/docker_container_pool_spec.rb

@@ -2,14 +2,14 @@
 
 require 'rails_helper'
 
-describe Runner::Strategy::Docker do
+describe Runner::Strategy::DockerContainerPool do
   let(:runner_id) { FactoryBot.attributes_for(:runner)[:runner_id] }
   let(:execution_environment) { FactoryBot.create :ruby }
-  let(:docker) { described_class.new(runner_id, execution_environment) }
+  let(:container_pool) { described_class.new(runner_id, execution_environment) }
 
   # TODO: add tests for these methods when implemented
   it 'defines all methods all runner management strategies must define' do
-    expect(docker.public_methods).to include(*Runner::DELEGATED_STRATEGY_METHODS)
+    expect(container_pool.public_methods).to include(:destroy_at_management, :copy_files, :attach_to_execution)
     expect(described_class.public_methods).to include(:request_from_management)
   end
 end

spec/lib/runner/strategy/poseidon_spec.rb

@@ -256,15 +256,15 @@ describe Runner::Strategy::Poseidon do
   end
 
   describe '#copy_files' do
-    let(:filename) { 'main.py' }
     let(:file_content) { 'print("Hello World!")' }
-    let(:action) { -> { poseidon.copy_files({filename => file_content}) } }
-    let(:encoded_file_content) { Base64.strict_encode64(file_content) }
+    let(:file) { FactoryBot.build(:file, content: file_content) }
+    let(:action) { -> { poseidon.copy_files([file]) } }
+    let(:encoded_file_content) { Base64.strict_encode64(file.content) }
     let!(:copy_files_stub) do
       WebMock
         .stub_request(:patch, "#{Runner::BASE_URL}/runners/#{runner_id}/files")
         .with(
-          body: {copy: [{path: filename, content: encoded_file_content}]},
+          body: {copy: [{path: file.filepath, content: encoded_file_content}]},
           headers: {'Content-Type' => 'application/json'}
         )
         .to_return(body: response_body, status: response_status)

spec/models/runner_spec.rb

@@ -35,10 +35,16 @@ describe Runner do
       end
     end
 
-    {poseidon: Runner::Strategy::Poseidon, docker: Runner::Strategy::Docker}.each do |strategy, strategy_class|
+    available_strategies = {
+      poseidon: Runner::Strategy::Poseidon,
+      docker_container_pool: Runner::Strategy::DockerContainerPool,
+    }
+    available_strategies.each do |strategy, strategy_class|
       include_examples 'uses the strategy defined in the constant', strategy, strategy_class
     end
+  end
 
+  describe 'method delegation' do
     shared_examples 'delegates method sends to its strategy' do |method, *args|
       context "when sending #{method}" do
         let(:strategy) { instance_double(strategy_class) }
@@ -49,7 +55,7 @@ describe Runner do
           allow(strategy_class).to receive(:new).and_return(strategy)
         end
 
-        it "delegates the method #{method}" do
+        it 'delegates to its strategy' do
           expect(strategy).to receive(method)
           runner.send(method, *args)
         end
@@ -57,10 +63,48 @@ describe Runner do
     end
 
     include_examples 'delegates method sends to its strategy', :destroy_at_management
-    include_examples 'delegates method sends to its strategy', :copy_files, nil
     include_examples 'delegates method sends to its strategy', :attach_to_execution, nil
   end
 
+  describe '#copy_files' do
+    let(:strategy) { instance_double(strategy_class) }
+    let(:runner) { described_class.create }
+
+    before do
+      allow(strategy_class).to receive(:request_from_management).and_return(runner_id)
+      allow(strategy_class).to receive(:new).and_return(strategy)
+    end
+
+    context 'when no error is raised' do
+      it 'delegates to its strategy' do
+        expect(strategy).to receive(:copy_files).once
+        runner.copy_files(nil)
+      end
+    end
+
+    context 'when a RunnerNotFound exception is raised' do
+      before do
+        was_called = false
+        allow(strategy).to receive(:copy_files) do
+          unless was_called
+            was_called = true
+            raise Runner::Error::RunnerNotFound.new
+          end
+        end
+      end
+
+      it 'requests a new id' do
+        expect(runner).to receive(:request_new_id)
+        runner.copy_files(nil)
+      end
+
+      it 'retries to copy the files' do
+        expect(strategy).to receive(:copy_files).twice
+        runner.copy_files(nil)
+      end
+    end
+  end
+
   describe 'creation' do
     let(:user) { FactoryBot.create :external_user }
     let(:execution_environment) { FactoryBot.create :ruby }