def test_alone_two_files(self): tt = Batch(["alone", ["", ""], "diff"]) cc = tt.get_compilation_commands(["foo.%l", "bar.%l"]) self.assertEqual(cc, { "L1": fake_compilation_commands( COMPILATION_COMMAND_1, ["foo.l1", "bar.l1"], "bar_foo"), "L2": fake_compilation_commands( COMPILATION_COMMAND_2, ["foo.l2", "bar.l2"], "bar_foo"), })
def test_single_process(self): tt = Communication([1, "stub", "fifo_io"]) cc = tt.get_compilation_commands(["foo.%l"]) self.assertEqual(cc, { "L1": fake_compilation_commands( COMPILATION_COMMAND_1, ["stub.l1", "foo.l1"], "foo"), "L2": fake_compilation_commands( COMPILATION_COMMAND_2, ["stub.l2", "foo.l2"], "foo"), })
def test_grader(self): tt = Batch(["grader", ["", ""], "diff"]) cc = tt.get_compilation_commands(["foo.%l"]) self.assertEqual(cc, { "L1": fake_compilation_commands( COMPILATION_COMMAND_1, ["foo.l1", "grader.l1"], "foo"), "L2": fake_compilation_commands( COMPILATION_COMMAND_2, ["foo.l2", "grader.l2"], "foo"), })
def test_std_io(self): # Compilation commands are the same regardless of whether we use # stdin/stdout or pipes. tt = Communication([1, "stub", "std_io"]) cc = tt.get_compilation_commands(["foo.%l"]) self.assertEqual(cc, { "L1": fake_compilation_commands( COMPILATION_COMMAND_1, ["stub.l1", "foo.l1"], "foo"), "L2": fake_compilation_commands( COMPILATION_COMMAND_2, ["stub.l2", "foo.l2"], "foo"), })
def test_no_stub(self): # Submissions can be compiled as stand-alone programs, with no # stubs. tt = Communication([1, "alone", "fifo_io"]) cc = tt.get_compilation_commands(["foo.%l"]) self.assertEqual(cc, { "L1": fake_compilation_commands( COMPILATION_COMMAND_1, ["foo.l1"], "foo"), "L2": fake_compilation_commands( COMPILATION_COMMAND_2, ["foo.l2"], "foo"), })
def test_two_processes(self): # Compilation commands are the same regardless of the number of # processes. tt = Communication([2, "stub", "fifo_io"]) cc = tt.get_compilation_commands(["foo.%l"]) self.assertEqual(cc, { "L1": fake_compilation_commands( COMPILATION_COMMAND_1, ["stub.l1", "foo.l1"], "foo"), "L2": fake_compilation_commands( COMPILATION_COMMAND_2, ["stub.l2", "foo.l2"], "foo"), })
def test_many_files(self): # Communication supports multiple files in the submission format, that # are just compiled together. tt = Communication([1, "stub", "fifo_io"]) cc = tt.get_compilation_commands(["foo.%l", "bar.%l"]) self.assertEqual(cc, { "L1": fake_compilation_commands( COMPILATION_COMMAND_1, ["stub.l1", "foo.l1", "bar.l1"], "bar_foo"), "L2": fake_compilation_commands( COMPILATION_COMMAND_2, ["stub.l2", "foo.l2", "bar.l2"], "bar_foo"), })
def test_grader_success(self): # We sprinkle in also a header, that should be copied, but not the # other grader. tt, job = self.prepare(["grader", ["", ""], "diff"], files={"foo.%l": FILE_FOO_L1}, managers={"grader.l1": GRADER_L1, "grader.l2": GRADER_L2, "grader.hl1": HEADER_L1}) sandbox = self.expect_sandbox() sandbox.get_file_to_storage.return_value = "exe_digest" tt.compile(job, self.file_cacher) # Sandbox created with the correct file cacher and name. self.Sandbox.assert_called_once_with(self.file_cacher, name="compile") # For grader we need the user source, the grader, and any other # relevant manager (in this case, the header). sandbox.create_file_from_storage.assert_has_calls([ call("foo.l1", "digest of foo.l1"), call("grader.l1", "digest of grader.l1"), call("grader.hl1", "digest of grader.hl1"), ], any_order=True) self.assertEqual(sandbox.create_file_from_storage.call_count, 3) # Compilation step called correctly. self.compilation_step.assert_called_once_with( sandbox, fake_compilation_commands( COMPILATION_COMMAND_1, ["foo.l1", "grader.l1"], "foo")) # Results put in job, executable stored and sandbox deleted. self.assertResultsInJob(job) sandbox.get_file_to_storage.assert_called_once_with("foo", ANY) sandbox.cleanup.assert_called_once_with(delete=True)
def test_no_stub_but_stub_given_success(self): # A stub is given but should be ignored. tt, job = self.prepare([1, "alone", "fifo_io", "eval_manager"], {"foo.%l": FILE_FOO_L1}, {"stub.l1": STUB_L1}) sandbox = self.expect_sandbox() sandbox.get_file_to_storage.return_value = "exe_digest" tt.compile(job, self.file_cacher) # Sandbox created with the correct file cacher and name. self.Sandbox.assert_called_once_with(self.file_cacher, name="compile") # The stub is put in the sandbox because it is a manager with an # extension that hints that it could be useful for compilations. sandbox.create_file_from_storage.assert_has_calls([ call("foo.l1", "digest of foo.l1"), call("stub.l1", "digest of stub.l1") ], any_order=True) self.assertEqual(sandbox.create_file_from_storage.call_count, 2) # Compilation step called correctly, without the stub. self.compilation_step.assert_called_once_with( sandbox, fake_compilation_commands(COMPILATION_COMMAND_1, ["foo.l1"], "foo")) # Results put in job, executable stored and sandbox deleted. self.assertResultsInJob(job, True, True, TEXT, STATS_OK) sandbox.get_file_to_storage.assert_called_once_with("foo", ANY) sandbox.cleanup.assert_called_once_with(delete=True)
def test_many_files_success(self): tt, job = self.prepare([1, "stub", "fifo_io", "eval_manager"], { "foo.%l": FILE_FOO_L1, "bar.%l": FILE_BAR_L1 }, {"stub.l1": STUB_L1}) sandbox = self.expect_sandbox() sandbox.get_file_to_storage.return_value = "exe_digest" tt.compile(job, self.file_cacher) # Sandbox created with the correct file cacher and name. self.Sandbox.assert_called_once_with(self.file_cacher, name="compile") # We need all user source files in addition to the stub. sandbox.create_file_from_storage.assert_has_calls([ call("foo.l1", "digest of foo.l1"), call("bar.l1", "digest of bar.l1"), call("stub.l1", "digest of stub.l1") ], any_order=True) self.assertEqual(sandbox.create_file_from_storage.call_count, 3) # Compilation step called correctly. self.compilation_step.assert_called_once_with( sandbox, fake_compilation_commands(COMPILATION_COMMAND_1, ["stub.l1", "foo.l1", "bar.l1"], "bar_foo")) # Results put in job, executable stored and sandbox deleted. self.assertResultsInJob(job, True, True, TEXT, STATS_OK) sandbox.get_file_to_storage.assert_called_once_with("bar_foo", ANY) sandbox.cleanup.assert_called_once_with(delete=True)
def test_alone_success_two_files(self): # Same as for a missing file. tt, job = self.prepare(["alone", ["", ""], "diff"], { "foo.%l": FILE_FOO_L1, "bar.%l": FILE_BAR_L1 }) sandbox = self.expect_sandbox() sandbox.get_file_to_storage.return_value = "exe_digest" tt.compile(job, self.file_cacher) # Sandbox created with the correct file cacher and name. self.Sandbox.assert_called_once_with(self.file_cacher, name="compile") # For alone, we only need the user source file. sandbox.create_file_from_storage.assert_has_calls([ call("foo.l1", "digest of foo.l1"), call("bar.l1", "digest of bar.l1") ], any_order=True) self.assertEqual(sandbox.create_file_from_storage.call_count, 2) # Compilation step called correctly. self.compilation_step.assert_called_once_with( sandbox, fake_compilation_commands(COMPILATION_COMMAND_1, ["foo.l1", "bar.l1"], "bar_foo")) # Results put in job, executable stored and sandbox deleted. self.assertResultsInJob(job) sandbox.get_file_to_storage.assert_called_once_with("bar_foo", ANY) sandbox.cleanup.assert_called_once_with(delete=True)
def test_no_stub_but_stub_given_success(self): # A stub is given but should be ignored. tt, job = self.prepare( [1, "alone", "fifo_io"], {"foo.%l": FILE_FOO_L1}, {"stub.l1": STUB_L1}) sandbox = self.expect_sandbox() sandbox.get_file_to_storage.return_value = "exe_digest" tt.compile(job, self.file_cacher) # Sandbox created with the correct file cacher and name. self.Sandbox.assert_called_once_with(self.file_cacher, name="compile") # The stub is put in the sandbox because it is a manager with an # extension that hints that it could be useful for compilations. sandbox.create_file_from_storage.assert_has_calls( [call("foo.l1", "digest of foo.l1"), call("stub.l1", "digest of stub.l1")], any_order=True) self.assertEqual(sandbox.create_file_from_storage.call_count, 2) # Compilation step called correctly, without the stub. self.compilation_step.assert_called_once_with( sandbox, fake_compilation_commands( COMPILATION_COMMAND_1, ["foo.l1"], "foo")) # Results put in job, executable stored and sandbox deleted. self.assertResultsInJob(job, True, True, TEXT, STATS_OK) sandbox.get_file_to_storage.assert_called_once_with("foo", ANY) sandbox.cleanup.assert_called_once_with(delete=True)
def test_many_files_success(self): tt, job = self.prepare( [1, "stub", "fifo_io"], {"foo.%l": FILE_FOO_L1, "bar.%l": FILE_BAR_L1}, {"stub.l1": STUB_L1}) sandbox = self.expect_sandbox() sandbox.get_file_to_storage.return_value = "exe_digest" tt.compile(job, self.file_cacher) # Sandbox created with the correct file cacher and name. self.Sandbox.assert_called_once_with(self.file_cacher, name="compile") # We need all user source files in addition to the stub. sandbox.create_file_from_storage.assert_has_calls( [call("foo.l1", "digest of foo.l1"), call("bar.l1", "digest of bar.l1"), call("stub.l1", "digest of stub.l1")], any_order=True) self.assertEqual(sandbox.create_file_from_storage.call_count, 3) # Compilation step called correctly. self.compilation_step.assert_called_once_with( sandbox, fake_compilation_commands( COMPILATION_COMMAND_1, ["stub.l1", "foo.l1", "bar.l1"], "bar_foo")) # Results put in job, executable stored and sandbox deleted. self.assertResultsInJob(job, True, True, TEXT, STATS_OK) sandbox.get_file_to_storage.assert_called_once_with("bar_foo", ANY) sandbox.cleanup.assert_called_once_with(delete=True)
def test_no_stub_success(self): tt, job = self.prepare([1, "alone", "fifo_io", "eval_manager"], {"foo.%l": FILE_FOO_L1}, {}) sandbox = self.expect_sandbox() sandbox.get_file_to_storage.return_value = "exe_digest" tt.compile(job, self.file_cacher) # Sandbox created with the correct file cacher and name. self.Sandbox.assert_called_once_with(self.file_cacher, name="compile") sandbox.create_file_from_storage.assert_called_once_with( "foo.l1", "digest of foo.l1") # Compilation step called correctly, without the stub. self.compilation_step.assert_called_once_with( sandbox, fake_compilation_commands(COMPILATION_COMMAND_1, ["foo.l1"], "foo")) # Results put in job, executable stored and sandbox deleted. self.assertResultsInJob(job, True, True, TEXT, STATS_OK) sandbox.get_file_to_storage.assert_called_once_with("foo", ANY) sandbox.cleanup.assert_called_once_with(delete=True)
def test_alone_success(self): tt, job = self.prepare(["alone", ["", ""], "diff"], {"foo.%l": FILE_FOO_L1}) sandbox = self.expect_sandbox() sandbox.get_file_to_storage.return_value = "exe_digest" tt.compile(job, self.file_cacher) # Sandbox created with the correct file cacher and name. self.Sandbox.assert_called_once_with(self.file_cacher, name="compile") # For alone, we only need the user source file. sandbox.create_file_from_storage.assert_has_calls( [call("foo.l1", "digest of foo.l1")], any_order=True) self.assertEqual(sandbox.create_file_from_storage.call_count, 1) # Compilation step called correctly. self.compilation_step.assert_called_once_with( sandbox, fake_compilation_commands( COMPILATION_COMMAND_1, ["foo.l1"], "foo")) # Results put in job, executable stored and sandbox deleted. self.assertResultsInJob(job) sandbox.get_file_to_storage.assert_called_once_with("foo", ANY) sandbox.cleanup.assert_called_once_with(delete=True)
def test_no_stub_success(self): tt, job = self.prepare( [1, "alone", "fifo_io"], {"foo.%l": FILE_FOO_L1}, {}) sandbox = self.expect_sandbox() sandbox.get_file_to_storage.return_value = "exe_digest" tt.compile(job, self.file_cacher) # Sandbox created with the correct file cacher and name. self.Sandbox.assert_called_once_with(self.file_cacher, name="compile") sandbox.create_file_from_storage.assert_called_once_with( "foo.l1", "digest of foo.l1") # Compilation step called correctly, without the stub. self.compilation_step.assert_called_once_with( sandbox, fake_compilation_commands( COMPILATION_COMMAND_1, ["foo.l1"], "foo")) # Results put in job, executable stored and sandbox deleted. self.assertResultsInJob(job, True, True, TEXT, STATS_OK) sandbox.get_file_to_storage.assert_called_once_with("foo", ANY) sandbox.cleanup.assert_called_once_with(delete=True)