259 lines
8.6 KiB
Ruby
259 lines
8.6 KiB
Ruby
require 'rails_helper'
|
|
require 'seeds_helper'
|
|
|
|
describe DockerClient, docker: true do
|
|
let(:command) { 'whoami' }
|
|
let(:docker_client) { DockerClient.new(execution_environment: FactoryGirl.build(:ruby), user: FactoryGirl.build(:admin)) }
|
|
let(:image) { double }
|
|
let(:submission) { FactoryGirl.create(:submission) }
|
|
let(:workspace_path) { '/tmp' }
|
|
|
|
describe '#bound_folders' do
|
|
context 'when executing a submission' do
|
|
before(:each) { docker_client.instance_variable_set(:@submission, submission) }
|
|
|
|
it 'returns a submission-specific mapping' do
|
|
mapping = docker_client.send(:bound_folders).first
|
|
expect(mapping).to include(submission.id.to_s)
|
|
expect(mapping).to end_with(DockerClient::CONTAINER_WORKSPACE_PATH)
|
|
end
|
|
end
|
|
|
|
context 'when executing a single command' do
|
|
it 'returns an empty mapping' do
|
|
expect(docker_client.send(:bound_folders)).to eq([])
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '.check_availability!' do
|
|
context 'when a socket error occurs' do
|
|
it 'raises an error' do
|
|
expect(Docker).to receive(:version).and_raise(Excon::Errors::SocketError.new(StandardError.new))
|
|
expect { DockerClient.check_availability! }.to raise_error(DockerClient::Error)
|
|
end
|
|
end
|
|
|
|
context 'when a timeout occurs' do
|
|
it 'raises an error' do
|
|
expect(Docker).to receive(:version).and_raise(Timeout::Error)
|
|
expect { DockerClient.check_availability! }.to raise_error(DockerClient::Error)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#clean_workspace' do
|
|
it 'removes the submission-specific directory' do
|
|
expect(docker_client).to receive(:local_workspace_path).and_return(workspace_path)
|
|
expect(FileUtils).to receive(:rm_rf).with(workspace_path)
|
|
docker_client.send(:clean_workspace)
|
|
end
|
|
end
|
|
|
|
describe '#create_container' do
|
|
let(:image_tag) { 'tag' }
|
|
before(:each) { docker_client.instance_variable_set(:@image, image) }
|
|
|
|
it 'creates a container' do
|
|
expect(image).to receive(:info).and_return({'RepoTags' => [image_tag]})
|
|
expect(Docker::Container).to receive(:create).with('Cmd' => command, 'Image' => image_tag)
|
|
docker_client.send(:create_container, command: command)
|
|
end
|
|
end
|
|
|
|
describe '#create_workspace' do
|
|
before(:each) { docker_client.instance_variable_set(:@submission, submission) }
|
|
|
|
it 'creates submission-specific directories' do
|
|
expect(docker_client).to receive(:local_workspace_path).at_least(:once).and_return(workspace_path)
|
|
expect(Dir).to receive(:mkdir).at_least(:once)
|
|
docker_client.send(:create_workspace)
|
|
end
|
|
end
|
|
|
|
describe '#create_workspace_file' do
|
|
let(:file) { FactoryGirl.build(:file, content: 'puts 42') }
|
|
let(:file_path) { File.join(workspace_path, file.name_with_extension) }
|
|
|
|
it 'creates a file' do
|
|
expect(docker_client).to receive(:local_workspace_path).and_return(workspace_path)
|
|
docker_client.send(:create_workspace_file, file: file)
|
|
expect(File.exist?(file_path)).to be true
|
|
expect(File.new(file_path, 'r').read).to eq(file.content)
|
|
File.delete(file_path)
|
|
end
|
|
end
|
|
|
|
describe '.destroy_container' do
|
|
let(:container) { docker_client.send(:create_container, {command: command}) }
|
|
after(:each) { DockerClient.destroy_container(container) }
|
|
|
|
it 'stops the container' do
|
|
expect(container).to receive(:stop).and_return(container)
|
|
end
|
|
|
|
it 'kills the container' do
|
|
expect(container).to receive(:kill)
|
|
end
|
|
|
|
it 'releases allocated ports' do
|
|
expect(container).to receive(:json).at_least(:once).and_return({'HostConfig' => {'PortBindings' => {foo: [{'HostPort' => '42'}]}}})
|
|
expect(PortPool).to receive(:release)
|
|
end
|
|
|
|
it 'deletes the container' do
|
|
expect(container).to receive(:delete)
|
|
end
|
|
end
|
|
|
|
describe '#execute_command' do
|
|
after(:each) { docker_client.send(:execute_command, command) }
|
|
|
|
it 'creates a container' do
|
|
expect(docker_client).to receive(:create_container).with(command: ['bash', '-c', command]).and_call_original
|
|
end
|
|
|
|
it 'starts the container' do
|
|
expect(docker_client).to receive(:start_container)
|
|
end
|
|
end
|
|
|
|
describe '#execute_in_workspace' do
|
|
let(:block) { Proc.new do; end }
|
|
let(:execute_in_workspace) { docker_client.send(:execute_in_workspace, submission, &block) }
|
|
after(:each) { execute_in_workspace }
|
|
|
|
it 'creates the workspace' do
|
|
expect(docker_client).to receive(:create_workspace)
|
|
end
|
|
|
|
it 'calls the block' do
|
|
expect(block).to receive(:call)
|
|
end
|
|
|
|
it 'cleans the workspace' do
|
|
expect(docker_client).to receive(:clean_workspace)
|
|
end
|
|
end
|
|
|
|
describe '#execute_run_command' do
|
|
let(:block) { Proc.new {} }
|
|
let(:filename) { submission.exercise.files.detect { |file| file.role == 'main_file' }.name_with_extension }
|
|
after(:each) { docker_client.send(:execute_run_command, submission, filename, &block) }
|
|
|
|
it 'is executed in the workspace' do
|
|
expect(docker_client).to receive(:execute_in_workspace)
|
|
end
|
|
|
|
it 'executes the run command' do
|
|
expect(docker_client).to receive(:execute_command).with(kind_of(String), &block)
|
|
end
|
|
end
|
|
|
|
describe '#execute_test_command' do
|
|
let(:filename) { submission.exercise.files.detect { |file| file.role == 'teacher_defined_test' }.name_with_extension }
|
|
after(:each) { docker_client.send(:execute_test_command, submission, filename) }
|
|
|
|
it 'is executed in the workspace' do
|
|
expect(docker_client).to receive(:execute_in_workspace)
|
|
end
|
|
|
|
it 'executes the test command' do
|
|
expect(docker_client).to receive(:execute_command).with(kind_of(String))
|
|
end
|
|
end
|
|
|
|
describe '.initialize_environment' do
|
|
let(:config) { {connection_timeout: 3, host: 'tcp://8.8.8.8:2375', workspace_root: '/'} }
|
|
|
|
context 'with complete configuration' do
|
|
before(:each) { expect(DockerClient).to receive(:config).at_least(:once).and_return(config) }
|
|
|
|
it 'does not raise an error' do
|
|
expect { DockerClient.initialize_environment }.not_to raise_error
|
|
end
|
|
end
|
|
|
|
context 'with incomplete configuration' do
|
|
before(:each) { expect(DockerClient).to receive(:config).at_least(:once).and_return({}) }
|
|
|
|
it 'raises an error' do
|
|
expect { DockerClient.initialize_environment }.to raise_error(DockerClient::Error)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#local_workspace_path' do
|
|
before(:each) { docker_client.instance_variable_set(:@submission, submission) }
|
|
|
|
it 'includes the correct workspace root' do
|
|
expect(docker_client.send(:local_workspace_path)).to start_with(DockerClient::LOCAL_WORKSPACE_ROOT.to_s)
|
|
end
|
|
|
|
it 'is submission-specific' do
|
|
expect(docker_client.send(:local_workspace_path)).to end_with(submission.id.to_s)
|
|
end
|
|
end
|
|
|
|
describe '#remote_workspace_path' do
|
|
before(:each) { docker_client.instance_variable_set(:@submission, submission) }
|
|
|
|
it 'includes the correct workspace root' do
|
|
expect(docker_client.send(:remote_workspace_path)).to start_with(DockerClient.config[:workspace_root])
|
|
end
|
|
|
|
it 'is submission-specific' do
|
|
expect(docker_client.send(:remote_workspace_path)).to end_with(submission.id.to_s)
|
|
end
|
|
end
|
|
|
|
describe '#start_container' do
|
|
let(:container) { docker_client.send(:create_container, command: command) }
|
|
let(:start_container) { docker_client.send(:start_container, container) }
|
|
|
|
it 'configures bound folders' do
|
|
expect(container).to receive(:start).with(hash_including('Binds' => kind_of(Array))).and_call_original
|
|
start_container
|
|
end
|
|
|
|
it 'configures bound ports' do
|
|
expect(container).to receive(:start).with(hash_including('PortBindings' => kind_of(Hash))).and_call_original
|
|
start_container
|
|
end
|
|
|
|
it 'starts the container' do
|
|
expect(container).to receive(:start).and_call_original
|
|
start_container
|
|
end
|
|
|
|
it 'waits for the container to terminate' do
|
|
expect(container).to receive(:wait).with(kind_of(Numeric)).and_call_original
|
|
start_container
|
|
end
|
|
|
|
context 'when a timeout occurs' do
|
|
before(:each) { expect(container).to receive(:wait).and_raise(Docker::Error::TimeoutError) }
|
|
|
|
it 'kills the container' do
|
|
expect(container).to receive(:kill)
|
|
start_container
|
|
end
|
|
|
|
it 'returns a corresponding status' do
|
|
expect(start_container[:status]).to eq(:timeout)
|
|
end
|
|
end
|
|
|
|
context 'when the container terminates timely' do
|
|
it "returns the container's output" do
|
|
expect(start_container[:stderr]).to be_blank
|
|
expect(start_container[:stdout]).to start_with('root')
|
|
end
|
|
|
|
it 'returns a corresponding status' do
|
|
expect(start_container[:status]).to eq(:ok)
|
|
end
|
|
end
|
|
end
|
|
end
|