htwkmooc/codeocean
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

use #described_class, as suggested by RuboCop

Browse Source
This commit is contained in:
Hauke Klement
2015-02-16 17:04:28 +01:00
parent 0bb5dae334
commit 8e374c6914
37 changed files with 119 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
spec/lib/assessor_spec.rb
View File

@@ -7,7 +7,7 @@ describe Assessor do
let(:test_outcome) { {count: count, passed: passed} }
context 'with a testing framework adapter' do
let(:assessor) { Assessor.new(execution_environment: FactoryGirl.build(:ruby)) }
let(:assessor) { described_class.new(execution_environment: FactoryGirl.build(:ruby)) }
it 'returns the correct score' do
expect(assessor.send(:calculate_score, test_outcome)).to eq(passed.to_f / count.to_f)
@@ -15,7 +15,7 @@ describe Assessor do
end
context 'without a testing framework adapter' do
let(:assessor) { Assessor.new(execution_environment: FactoryGirl.build(:execution_environment)) }
let(:assessor) { described_class.new(execution_environment: FactoryGirl.build(:execution_environment)) }
it 'raises an error' do
expect { assessor.send(:calculate_score, test_outcome) }.to raise_error

4
spec/lib/code_ocean/config_spec.rb
View File

@@ -7,7 +7,7 @@ describe CodeOcean::Config do
context 'with a .yml file' do
let(:path) { Rails.root.join('config', "#{filename}.yml") }
let(:read) { CodeOcean::Config.new(filename).read }
let(:read) { described_class.new(filename).read }
context 'when the file is present' do
before(:each) { File.write(path, {Rails.env.to_s => content}.to_yaml) }
@@ -27,7 +27,7 @@ describe CodeOcean::Config do
context 'with a .yml.erb file' do
let(:path) { Rails.root.join('config', "#{filename}.yml.erb") }
let(:read) { CodeOcean::Config.new(filename).read(erb: true) }
let(:read) { described_class.new(filename).read(erb: true) }
context 'when the file is present' do
before(:each) { File.write(path, {Rails.env.to_s => content}.to_yaml) }

50
spec/lib/docker_client_spec.rb
View File

@@ -3,7 +3,7 @@ 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(:docker_client) { described_class.new(execution_environment: FactoryGirl.build(:ruby), user: FactoryGirl.build(:admin)) }
let(:execution_environment) { FactoryGirl.build(:ruby) }
let(:image) { double }
let(:submission) { FactoryGirl.create(:submission) }
@@ -13,27 +13,27 @@ describe DockerClient, docker: true 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)
expect { described_class.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)
expect { described_class.check_availability! }.to raise_error(DockerClient::Error)
end
end
end
describe '.create_container' do
after(:each) { DockerClient.create_container(execution_environment) }
after(:each) { described_class.create_container(execution_environment) }
it 'uses the correct Docker image' do
expect(DockerClient).to receive(:find_image_by_tag).with(execution_environment.docker_image).and_call_original
expect(described_class).to receive(:find_image_by_tag).with(execution_environment.docker_image).and_call_original
end
it 'creates a unique directory' do
expect(DockerClient).to receive(:generate_local_workspace_path).and_call_original
expect(described_class).to receive(:generate_local_workspace_path).and_call_original
expect(FileUtils).to receive(:mkdir).with(kind_of(String)).and_call_original
end
@@ -46,12 +46,12 @@ describe DockerClient, docker: true do
end
it 'configures mapped directories' do
expect(DockerClient).to receive(:mapped_directories).and_call_original
expect(described_class).to receive(:mapped_directories).and_call_original
expect_any_instance_of(Docker::Container).to receive(:start).with(hash_including('Binds' => kind_of(Array)))
end
it 'configures mapped ports' do
expect(DockerClient).to receive(:mapped_ports).with(execution_environment).and_call_original
expect(described_class).to receive(:mapped_ports).with(execution_environment).and_call_original
expect_any_instance_of(Docker::Container).to receive(:start).with(hash_including('PortBindings' => kind_of(Hash)))
end
end
@@ -89,7 +89,7 @@ describe DockerClient, docker: true do
after(:each) { File.delete(file_path) }
it 'creates a file' do
expect(DockerClient).to receive(:local_workspace_path).at_least(:once).and_return(workspace_path)
expect(described_class).to receive(:local_workspace_path).at_least(:once).and_return(workspace_path)
docker_client.send(:create_workspace_file, container: CONTAINER, file: file)
expect(File.exist?(file_path)).to be true
expect(File.new(file_path, 'r').read).to eq(file.content)
@@ -97,8 +97,8 @@ describe DockerClient, docker: true do
end
describe '.destroy_container' do
let(:container) { DockerClient.create_container(execution_environment) }
after(:each) { DockerClient.destroy_container(container) }
let(:container) { described_class.create_container(execution_environment) }
after(:each) { described_class.destroy_container(container) }
it 'stops the container' do
expect(container).to receive(:stop).and_return(container)
@@ -114,7 +114,7 @@ describe DockerClient, docker: true do
end
it 'removes the mapped directory' do
expect(DockerClient).to receive(:local_workspace_path).and_return(workspace_path)
expect(described_class).to receive(:local_workspace_path).and_return(workspace_path)
expect(FileUtils).to receive(:rm_rf).with(workspace_path)
end
@@ -173,12 +173,12 @@ describe DockerClient, docker: true do
describe '.generate_local_workspace_path' do
it 'includes the correct workspace root' do
expect(DockerClient.generate_local_workspace_path).to start_with(DockerClient::LOCAL_WORKSPACE_ROOT.to_s)
expect(described_class.generate_local_workspace_path).to start_with(DockerClient::LOCAL_WORKSPACE_ROOT.to_s)
end
it 'includes a UUID' do
expect(SecureRandom).to receive(:uuid).and_call_original
DockerClient.generate_local_workspace_path
described_class.generate_local_workspace_path
end
end
@@ -186,22 +186,22 @@ describe DockerClient, docker: true do
context 'with complete configuration' do
it 'creates the file directory' do
expect(FileUtils).to receive(:mkdir_p).with(DockerClient::LOCAL_WORKSPACE_ROOT)
DockerClient.initialize_environment
described_class.initialize_environment
end
end
context 'with incomplete configuration' do
before(:each) { expect(DockerClient).to receive(:config).at_least(:once).and_return({}) }
before(:each) { expect(described_class).to receive(:config).at_least(:once).and_return({}) }
it 'raises an error' do
expect { DockerClient.initialize_environment }.to raise_error(DockerClient::Error)
expect { described_class.initialize_environment }.to raise_error(DockerClient::Error)
end
end
end
describe '.local_workspace_path' do
let(:container) { DockerClient.create_container(execution_environment) }
let(:local_workspace_path) { DockerClient.local_workspace_path(container) }
let(:container) { described_class.create_container(execution_environment) }
let(:local_workspace_path) { described_class.local_workspace_path(container) }
it 'returns a path' do
expect(local_workspace_path).to be_a(Pathname)
@@ -214,7 +214,7 @@ describe DockerClient, docker: true do
describe '.mapped_directories' do
it 'returns a unique mapping' do
mapping = DockerClient.mapped_directories(workspace_path).first
mapping = described_class.mapped_directories(workspace_path).first
expect(mapping).to start_with(workspace_path)
expect(mapping).to end_with(DockerClient::CONTAINER_WORKSPACE_PATH)
end
@@ -225,26 +225,26 @@ describe DockerClient, docker: true do
before(:each) { execution_environment.exposed_ports = '3000' }
it 'returns a mapping' do
expect(DockerClient.mapped_ports(execution_environment)).to be_a(Hash)
expect(DockerClient.mapped_ports(execution_environment).length).to eq(1)
expect(described_class.mapped_ports(execution_environment)).to be_a(Hash)
expect(described_class.mapped_ports(execution_environment).length).to eq(1)
end
it 'retrieves available ports' do
expect(PortPool).to receive(:available_port)
DockerClient.mapped_ports(execution_environment)
described_class.mapped_ports(execution_environment)
end
end
context 'without exposed ports' do
it 'returns an empty mapping' do
expect(DockerClient.mapped_ports(execution_environment)).to eq({})
expect(described_class.mapped_ports(execution_environment)).to eq({})
end
end
end
describe '#send_command' do
let(:block) { Proc.new {} }
let(:container) { DockerClient.create_container(execution_environment) }
let(:container) { described_class.create_container(execution_environment) }
let(:send_command) { docker_client.send(:send_command, command, container, &block) }
after(:each) { send_command }

46
spec/lib/docker_container_pool_spec.rb
View File

@@ -14,20 +14,20 @@ describe DockerContainerPool do
end
it 'uses thread-safe data structures' do
expect(DockerContainerPool.instance_variable_get(:@containers)).to be_a(ThreadSafe::Hash)
expect(DockerContainerPool.instance_variable_get(:@containers)[@execution_environment.id]).to be_a(ThreadSafe::Array)
expect(described_class.instance_variable_get(:@containers)).to be_a(ThreadSafe::Hash)
expect(described_class.instance_variable_get(:@containers)[@execution_environment.id]).to be_a(ThreadSafe::Array)
end
describe '.clean_up' do
before(:each) { DockerContainerPool.instance_variable_set(:@refill_task, double) }
after(:each) { DockerContainerPool.clean_up }
before(:each) { described_class.instance_variable_set(:@refill_task, double) }
after(:each) { described_class.clean_up }
it 'stops the refill task' do
expect(DockerContainerPool.instance_variable_get(:@refill_task)).to receive(:shutdown)
expect(described_class.instance_variable_get(:@refill_task)).to receive(:shutdown)
end
it 'destroys all containers' do
DockerContainerPool.instance_variable_get(:@containers).each do |key, value|
described_class.instance_variable_get(:@containers).each do |key, value|
value.each do |container|
expect(DockerClient).to receive(:destroy_container).with(container)
end
@@ -38,46 +38,46 @@ describe DockerContainerPool do
describe '.get_container' do
context 'when active' do
before(:each) do
expect(DockerContainerPool).to receive(:config).and_return(active: true)
expect(described_class).to receive(:config).and_return(active: true)
end
context 'with an available container' do
before(:each) { DockerContainerPool.instance_variable_get(:@containers)[@execution_environment.id].push(container) }
before(:each) { described_class.instance_variable_get(:@containers)[@execution_environment.id].push(container) }
it 'takes a container from the pool' do
expect(DockerContainerPool).not_to receive(:create_container).with(@execution_environment)
expect(DockerContainerPool.get_container(@execution_environment)).to eq(container)
expect(described_class).not_to receive(:create_container).with(@execution_environment)
expect(described_class.get_container(@execution_environment)).to eq(container)
end
end
context 'without an available container' do
before(:each) do
expect(DockerContainerPool.instance_variable_get(:@containers)[@execution_environment.id]).to be_empty
expect(described_class.instance_variable_get(:@containers)[@execution_environment.id]).to be_empty
end
it 'creates a new container' do
expect(DockerContainerPool).to receive(:create_container).with(@execution_environment)
DockerContainerPool.get_container(@execution_environment)
expect(described_class).to receive(:create_container).with(@execution_environment)
described_class.get_container(@execution_environment)
end
end
end
context 'when inactive' do
before(:each) do
expect(DockerContainerPool).to receive(:config).and_return(active: false)
expect(described_class).to receive(:config).and_return(active: false)
end
it 'creates a new container' do
expect(DockerContainerPool).to receive(:create_container).with(@execution_environment)
DockerContainerPool.get_container(@execution_environment)
expect(described_class).to receive(:create_container).with(@execution_environment)
described_class.get_container(@execution_environment)
end
end
end
describe '.quantities' do
it 'maps execution environments to quantities of available containers' do
expect(DockerContainerPool.quantities.keys).to eq(ExecutionEnvironment.all.map(&:id))
expect(DockerContainerPool.quantities.values.uniq).to eq([0])
expect(described_class.quantities.keys).to eq(ExecutionEnvironment.all.map(&:id))
expect(described_class.quantities.values.uniq).to eq([0])
end
end
@@ -86,15 +86,15 @@ describe DockerContainerPool do
let(:maximum_refill_count) { 5 }
before(:each) do
expect(DockerContainerPool).to receive(:config).and_return(config)
expect(described_class).to receive(:config).and_return(config)
expect(config).to receive(:[]).with(:maximum_refill_count).and_return(maximum_refill_count)
end
after(:each) { DockerContainerPool.refill }
after(:each) { described_class.refill }
it 'regards all execution environments' do
ExecutionEnvironment.all.each do |execution_environment|
expect(DockerContainerPool.instance_variable_get(:@containers)).to receive(:[]).with(execution_environment.id).and_call_original
expect(described_class.instance_variable_get(:@containers)).to receive(:[]).with(execution_environment.id).and_call_original
end
end
@@ -103,7 +103,7 @@ describe DockerContainerPool do
it 'complies with the maximum batch size' do
expect_any_instance_of(Concurrent::Future).to receive(:execute) do |future|
expect(DockerContainerPool).to receive(:create_container).with(@execution_environment).exactly(maximum_refill_count).times
expect(described_class).to receive(:create_container).with(@execution_environment).exactly(maximum_refill_count).times
future.instance_variable_get(:@task).call
end
end
@@ -123,7 +123,7 @@ describe DockerContainerPool do
end
describe '.start_refill_task' do
after(:each) { DockerContainerPool.start_refill_task }
after(:each) { described_class.start_refill_task }
it 'creates an asynchronous task' do
expect(Concurrent::TimerTask).to receive(:new).and_call_original

2
spec/lib/junit_adapter_spec.rb
View File

@@ -1,7 +1,7 @@
require 'rails_helper'
describe JunitAdapter do
let(:adapter) { JunitAdapter.new }
let(:adapter) { described_class.new }
describe '#parse_output' do
context 'with failed tests' do

20
spec/lib/nonce_store_spec.rb
View File

@@ -6,36 +6,36 @@ describe NonceStore do
describe '.add' do
it 'stores a nonce in the cache' do
expect(Rails.cache).to receive(:write)
NonceStore.add(nonce)
described_class.add(nonce)
end
end
describe '.delete' do
it 'deletes a nonce from the cache' do
expect(Rails.cache).to receive(:write)
NonceStore.add(nonce)
NonceStore.delete(nonce)
expect(NonceStore.has?(nonce)).to be false
described_class.add(nonce)
described_class.delete(nonce)
expect(described_class.has?(nonce)).to be false
end
end
describe '.has?' do
it 'returns true for present nonces' do
NonceStore.add(nonce)
expect(NonceStore.has?(nonce)).to be true
described_class.add(nonce)
expect(described_class.has?(nonce)).to be true
end
it 'returns false for expired nonces' do
Lti.send(:remove_const, 'MAXIMUM_SESSION_AGE')
Lti::MAXIMUM_SESSION_AGE = 1
NonceStore.add(nonce)
expect(NonceStore.has?(nonce)).to be true
described_class.add(nonce)
expect(described_class.has?(nonce)).to be true
sleep(Lti::MAXIMUM_SESSION_AGE)
expect(NonceStore.has?(nonce)).to be false
expect(described_class.has?(nonce)).to be false
end
it 'returns false for absent nonces' do
expect(NonceStore.has?(nonce)).to be false
expect(described_class.has?(nonce)).to be false
end
end
end

32
spec/lib/port_pool_spec.rb
View File

@@ -3,27 +3,27 @@ require 'rails_helper'
describe PortPool do
describe '.available_port' do
it 'is synchronized' do
expect(PortPool.instance_variable_get(:@mutex)).to receive(:synchronize)
PortPool.available_port
expect(described_class.instance_variable_get(:@mutex)).to receive(:synchronize)
described_class.available_port
end
context 'when a port is available' do
it 'returns the port' do
expect(PortPool.available_port).to be_a(Numeric)
expect(described_class.available_port).to be_a(Numeric)
end
it 'removes the port from the list of available ports' do
port = PortPool.available_port
expect(PortPool.instance_variable_get(:@available_ports)).not_to include(port)
port = described_class.available_port
expect(described_class.instance_variable_get(:@available_ports)).not_to include(port)
end
end
context 'when no port is available' do
it 'returns the port' do
available_ports = PortPool.instance_variable_get(:@available_ports)
PortPool.instance_variable_set(:@available_ports, [])
expect(PortPool.available_port).to be_nil
PortPool.instance_variable_set(:@available_ports, available_ports)
available_ports = described_class.instance_variable_get(:@available_ports)
described_class.instance_variable_set(:@available_ports, [])
expect(described_class.available_port).to be_nil
described_class.instance_variable_set(:@available_ports, available_ports)
end
end
end
@@ -31,24 +31,24 @@ describe PortPool do
describe '.release' do
context 'when the port has been obtained earlier' do
it 'adds the port to the list of available ports' do
port = PortPool.available_port
expect(PortPool.instance_variable_get(:@available_ports)).not_to include(port)
PortPool.release(port)
expect(PortPool.instance_variable_get(:@available_ports)).to include(port)
port = described_class.available_port
expect(described_class.instance_variable_get(:@available_ports)).not_to include(port)
described_class.release(port)
expect(described_class.instance_variable_get(:@available_ports)).to include(port)
end
end
context 'when the port has not been obtained earlier' do
it 'does not add the port to the list of available ports' do
port = PortPool.instance_variable_get(:@available_ports).sample
expect { PortPool.release(port) }.not_to change { PortPool.instance_variable_get(:@available_ports).length }
port = described_class.instance_variable_get(:@available_ports).sample
expect { described_class.release(port) }.not_to change { described_class.instance_variable_get(:@available_ports).length }
end
end
context 'when the port is not included in the port range' do
it 'does not add the port to the list of available ports' do
port = nil
expect { PortPool.release(port) }.not_to change { PortPool.instance_variable_get(:@available_ports).length }
expect { described_class.release(port) }.not_to change { described_class.instance_variable_get(:@available_ports).length }
end
end
end

2
spec/lib/py_unit_adapter_spec.rb
View File

@@ -1,7 +1,7 @@
require 'rails_helper'
describe PyUnitAdapter do
let(:adapter) { PyUnitAdapter.new }
let(:adapter) { described_class.new }
let(:count) { 42 }
let(:failed) { 25 }
let(:stderr) { "Ran #{count} tests in 0.1s\n\nFAILED (failures=#{failed})" }

2
spec/lib/rspec_adapter_spec.rb
View File

@@ -1,7 +1,7 @@
require 'rails_helper'
describe RspecAdapter do
let(:adapter) { RspecAdapter.new }
let(:adapter) { described_class.new }
let(:count) { 42 }
let(:failed) { 25 }
let(:stdout) { "Finished in 0.1 seconds (files took 0.1 seconds to load)\n#{count} examples, #{failed} failures" }

2
spec/lib/sql_result_set_comparator_adapter_spec.rb
View File

@@ -1,7 +1,7 @@
require 'rails_helper'
describe SqlResultSetComparatorAdapter do
let(:adapter) { SqlResultSetComparatorAdapter.new }
let(:adapter) { described_class.new }
describe '#parse_output' do
context 'with missing tuples' do

4
spec/lib/testing_framework_adapter_spec.rb
View File

@@ -1,7 +1,7 @@
require 'rails_helper'
describe TestingFrameworkAdapter do
let(:adapter) { TestingFrameworkAdapter.new }
let(:adapter) { described_class.new }
let(:count) { 42 }
let(:failed) { 25 }
let(:passed) { 17 }
@@ -28,7 +28,7 @@ describe TestingFrameworkAdapter do
describe '.framework_name' do
it 'defaults to the class name' do
expect(adapter.class.framework_name).to eq(TestingFrameworkAdapter.name)
expect(adapter.class.framework_name).to eq(described_class.name)
end
end

2
spec/lib/whistleblower_spec.rb
View File

@@ -3,7 +3,7 @@ require 'rails_helper'
describe Whistleblower do
let(:hint) { FactoryGirl.create(:ruby_no_method_error) }
let(:stderr) { "undefined method `foo' for main:Object (NoMethodError)" }
let(:whistleblower) { Whistleblower.new(execution_environment: hint.execution_environment) }
let(:whistleblower) { described_class.new(execution_environment: hint.execution_environment) }
describe '#find_hint' do
let(:find_hint) { whistleblower.send(:find_hint, stderr) }