def test_determine_grade_solution():
cell = create_solution_cell('test', "code", "foo")
with pytest.raises(ValueError):
utils.determine_grade(cell)
cell = create_solution_cell('test', "markdown", "foo")
with pytest.raises(ValueError):
utils.determine_grade(cell)
def test_determine_grade_solution():
cell = create_solution_cell('test', "code", "foo")
with pytest.raises(ValueError):
utils.determine_grade(cell)
cell = create_solution_cell('test', "markdown", "foo")
with pytest.raises(ValueError):
utils.determine_grade(cell)
def test_compute_checksum_cell_type():
# does the cell type make a difference?
cell1 = create_grade_cell("hello", "code", "foo", 1)
cell2 = create_grade_cell("hello", "markdown", "foo", 1)
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
cell1 = create_solution_cell("hello", "code", "foo")
cell2 = create_solution_cell("hello", "markdown", "foo")
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
def test_compute_checksum_identical():
# is the same for two identical cells?
cell1 = create_grade_cell("hello", "code", "foo", 1)
cell2 = create_grade_cell("hello", "code", "foo", 1)
assert utils.compute_checksum(cell1) == utils.compute_checksum(cell2)
cell1 = create_solution_cell("hello", "code", "foo")
cell2 = create_solution_cell("hello", "code", "foo")
assert utils.compute_checksum(cell1) == utils.compute_checksum(cell2)
def test_compute_checksum_cell_type():
# does the cell type make a difference?
cell1 = create_grade_cell("hello", "code", "foo", 1)
cell2 = create_grade_cell("hello", "markdown", "foo", 1)
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
cell1 = create_solution_cell("hello", "code", "foo")
cell2 = create_solution_cell("hello", "markdown", "foo")
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
def test_compute_checksum_identical():
# is the same for two identical cells?
cell1 = create_grade_cell("hello", "code", "foo", 1)
cell2 = create_grade_cell("hello", "code", "foo", 1)
assert utils.compute_checksum(cell1) == utils.compute_checksum(cell2)
cell1 = create_solution_cell("hello", "code", "foo")
cell2 = create_solution_cell("hello", "code", "foo")
assert utils.compute_checksum(cell1) == utils.compute_checksum(cell2)
def test_checksum_solution_cell_type(self, preprocessor):
"""Test that the checksum is computed for solution cells of different cell types"""
cell1 = create_solution_cell("", "code", "foo")
cell1 = preprocessor.preprocess_cell(cell1, {}, 0)[0]
cell2 = create_solution_cell("", "markdown", "foo")
cell2 = preprocessor.preprocess_cell(cell2, {}, 0)[0]
assert cell1.metadata.nbgrader["checksum"] == compute_checksum(cell1)
assert cell2.metadata.nbgrader["checksum"] == compute_checksum(cell2)
assert cell1.metadata.nbgrader["checksum"] != cell2.metadata.nbgrader["checksum"]
def test_checksum_solution_source(self, preprocessor):
"""Test that the checksum is computed for solution cells with different sources"""
cell1 = create_solution_cell("a", "code")
cell1 = preprocessor.preprocess_cell(cell1, {}, 0)[0]
cell2 = create_solution_cell("b", "code")
cell2 = preprocessor.preprocess_cell(cell2, {}, 0)[0]
assert cell1.metadata.nbgrader["checksum"] == compute_checksum(cell1)
assert cell2.metadata.nbgrader["checksum"] == compute_checksum(cell2)
assert cell1.metadata.nbgrader["checksum"] != cell2.metadata.nbgrader["checksum"]
def test_checksum_solution_cell_type(self, preprocessor):
"""Test that the checksum is computed for solution cells of different cell types"""
cell1 = create_solution_cell("", "code", "foo")
cell1 = preprocessor.preprocess_cell(cell1, {}, 0)[0]
cell2 = create_solution_cell("", "markdown", "foo")
cell2 = preprocessor.preprocess_cell(cell2, {}, 0)[0]
assert cell1.metadata.nbgrader["checksum"] == compute_checksum(cell1)
assert cell2.metadata.nbgrader["checksum"] == compute_checksum(cell2)
assert cell1.metadata.nbgrader["checksum"] != cell2.metadata.nbgrader[
"checksum"]
def test_duplicate_solution_cell(self, preprocessor):
cell1 = create_solution_cell("hello", "code", "foo")
cell2 = create_solution_cell("goodbye", "code", "foo")
nb = new_notebook()
nb.cells.append(cell1)
nb.cells.append(cell2)
nb, resources = preprocessor.preprocess(nb, {})
assert nb.cells[0].metadata.nbgrader == {}
assert nb.cells[1].metadata.nbgrader != {}
def test_duplicate_solution_cell(self, preprocessor):
cell1 = create_solution_cell("hello", "code", "foo")
cell2 = create_solution_cell("goodbye", "code", "foo")
nb = new_notebook()
nb.cells.append(cell1)
nb.cells.append(cell2)
nb, resources = preprocessor.preprocess(nb, {})
assert nb.cells[0].metadata.nbgrader == {}
assert nb.cells[1].metadata.nbgrader != {}
def test_invalid_solution_cell_id(self, preprocessor):
"""Check that an error is raised when the solution id is invalid"""
resources = dict(grade_ids=[])
cell = create_solution_cell("", "code", "")
with pytest.raises(RuntimeError):
preprocessor.preprocess_cell(cell, resources, 0)
cell = create_solution_cell("", "code", "a b")
with pytest.raises(RuntimeError):
preprocessor.preprocess_cell(cell, resources, 0)
cell = create_solution_cell("", "code", "a\"b")
with pytest.raises(RuntimeError):
preprocessor.preprocess_cell(cell, resources, 0)
cell = create_solution_cell("", "code", "abc-ABC_0")
preprocessor.preprocess_cell(cell, resources, 0)
def test_invalid_solution_cell_id(self, preprocessor):
"""Check that an error is raised when the solution id is invalid"""
resources = dict(grade_ids=[])
cell = create_solution_cell("", "code", "")
with pytest.raises(RuntimeError):
preprocessor.preprocess_cell(cell, resources, 0)
cell = create_solution_cell("", "code", "a b")
with pytest.raises(RuntimeError):
preprocessor.preprocess_cell(cell, resources, 0)
cell = create_solution_cell("", "code", "a\"b")
with pytest.raises(RuntimeError):
preprocessor.preprocess_cell(cell, resources, 0)
cell = create_solution_cell("", "code", "abc-ABC_0")
preprocessor.preprocess_cell(cell, resources, 0)
def test_comment_unchanged_code(self, preprocessors, gradebook, resources):
"""Is an unchanged code cell given the correct comment?"""
cell = create_solution_cell("hello", "code")
nb = new_notebook()
nb.cells.append(cell)
preprocessors[0].preprocess(nb, resources)
gradebook.add_submission("ps0", "bar")
preprocessors[1].preprocess(nb, resources)
comment = gradebook.find_comment(0, "test", "ps0", "bar")
assert comment.comment == "No response."
def test_overwrite_solution_checksum(self, preprocessors, resources):
"""Is the checksum overwritten for solution cells?"""
cell = create_solution_cell("hello", "code", "foo")
cell.metadata.nbgrader['checksum'] = compute_checksum(cell)
nb = new_notebook()
nb.cells.append(cell)
nb, resources = preprocessors[0].preprocess(nb, resources)
cell.metadata.nbgrader["checksum"] = "1234"
nb, resources = preprocessors[1].preprocess(nb, resources)
assert cell.metadata.nbgrader["checksum"] == compute_checksum(cell)
def test_save_markdown_solution_cell(self, preprocessor, resources):
cell = create_solution_cell("hello", "markdown")
nb = new_notebook()
nb.cells.append(cell)
nb, resources = preprocessor.preprocess(nb, resources)
gb = preprocessor.gradebook
solution_cell = gb.find_solution_cell(0, "test", "ps0")
assert solution_cell.source == "hello"
assert solution_cell.checksum == cell.metadata.nbgrader["checksum"]
assert solution_cell.cell_type == "markdown"
def test_non_nbgrader_cell_blank_grade_id(self, preprocessor):
resources = dict(grade_ids=[])
cell = create_grade_cell("", "code", "", 1)
cell.metadata.nbgrader['grade'] = False
new_cell, _ = preprocessor.preprocess_cell(cell, resources, 0)
assert 'grade_id' not in new_cell.metadata.nbgrader
resources = dict(grade_ids=[])
cell = create_solution_cell("", "code", "")
cell.metadata.nbgrader['solution'] = False
new_cell, _ = preprocessor.preprocess_cell(cell, resources, 0)
assert 'grade_id' not in new_cell.metadata.nbgrader
def test_save_unchanged_code(self, preprocessors, gradebook, resources):
"""Is an unchanged code cell given the correct comment?"""
cell = create_solution_cell("hello", "code", "foo")
cell.metadata.nbgrader['checksum'] = compute_checksum(cell)
nb = new_notebook()
nb.cells.append(cell)
preprocessors[0].preprocess(nb, resources)
gradebook.add_submission("ps0", "bar")
preprocessors[1].preprocess(nb, resources)
preprocessors[2].preprocess(nb, resources)
assert cell.metadata.nbgrader['comment'] == "No response."
def test_dont_overwrite_solution_source(self, preprocessors, resources):
"""Is the source not overwritten for solution cells?"""
cell = create_solution_cell("hello", "code", "foo")
cell.metadata.nbgrader["checksum"] = compute_checksum(cell)
nb = new_notebook()
nb.cells.append(cell)
nb, resources = preprocessors[0].preprocess(nb, resources)
cell.source = "hello!"
nb, resources = preprocessors[1].preprocess(nb, resources)
assert cell.source == "hello!"
def test_save_unchanged_code(self, preprocessors, gradebook, resources):
"""Is an unchanged code cell given the correct comment?"""
cell = create_solution_cell("hello", "code", "foo")
cell.metadata.nbgrader['checksum'] = compute_checksum(cell)
nb = new_notebook()
nb.cells.append(cell)
preprocessors[0].preprocess(nb, resources)
gradebook.add_submission("ps0", "bar")
preprocessors[1].preprocess(nb, resources)
preprocessors[2].preprocess(nb, resources)
assert cell.metadata.nbgrader['comment'] == "No response."
def test_overwrite_solution_cell_type(self, preprocessors, resources):
"""Is the cell type overwritten for solution cells?"""
cell = create_solution_cell("hello", "code", "foo")
cell.metadata.nbgrader['checksum'] = compute_checksum(cell)
nb = new_notebook()
nb.cells.append(cell)
nb, resources = preprocessors[0].preprocess(nb, resources)
cell.cell_type = "markdown"
nb, resources = preprocessors[1].preprocess(nb, resources)
assert cell.cell_type == "code"
def test_compute_checksum_source():
# does the source make a difference?
cell1 = create_grade_cell("print('hello')", "code", "foo", 1)
cell2 = create_grade_cell("print( 'hello' )", "code", "foo", 1)
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
cell1 = create_grade_cell("print('hello')", "code", "foo", 1)
cell2 = create_grade_cell("print( 'hello!' )", "code", "foo", 1)
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
cell1 = create_grade_cell("print('hello')", "markdown", "foo", 1)
cell2 = create_grade_cell("print( 'hello' )", "markdown", "foo", 1)
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
cell1 = create_solution_cell("print('hello')", "code", "foo")
cell2 = create_solution_cell("print( 'hello' )", "code", "foo")
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
cell1 = create_solution_cell("print('hello')", "code", "foo")
cell2 = create_solution_cell("print( 'hello!' )", "code", "foo")
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
cell1 = create_solution_cell("print('hello')", "markdown", "foo")
cell2 = create_solution_cell("print( 'hello' )", "markdown", "foo")
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
def test_compute_checksum_source():
# does the source make a difference?
cell1 = create_grade_cell("print('hello')", "code", "foo", 1)
cell2 = create_grade_cell("print( 'hello' )", "code", "foo", 1)
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
cell1 = create_grade_cell("print('hello')", "code", "foo", 1)
cell2 = create_grade_cell("print( 'hello!' )", "code", "foo", 1)
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
cell1 = create_grade_cell("print('hello')", "markdown", "foo", 1)
cell2 = create_grade_cell("print( 'hello' )", "markdown", "foo", 1)
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
cell1 = create_solution_cell("print('hello')", "code", "foo")
cell2 = create_solution_cell("print( 'hello' )", "code", "foo")
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
cell1 = create_solution_cell("print('hello')", "code", "foo")
cell2 = create_solution_cell("print( 'hello!' )", "code", "foo")
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
cell1 = create_solution_cell("print('hello')", "markdown", "foo")
cell2 = create_solution_cell("print( 'hello' )", "markdown", "foo")
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
def test_comment_changed_code(self, preprocessors, gradebook, resources):
"""Is a changed code cell given the correct comment?"""
cell = create_solution_cell("hello", "code", "foo")
cell.metadata.nbgrader['checksum'] = compute_checksum(cell)
nb = new_notebook()
nb.cells.append(cell)
preprocessors[0].preprocess(nb, resources)
gradebook.add_submission("ps0", "bar")
cell.source = "hello!"
preprocessors[1].preprocess(nb, resources)
comment = gradebook.find_comment("foo", "test", "ps0", "bar")
assert comment.auto_comment is None
def test_comment_changed_code(self, preprocessors, gradebook, resources):
"""Is a changed code cell given the correct comment?"""
cell = create_solution_cell("hello", "code", "foo")
cell.metadata.nbgrader['checksum'] = compute_checksum(cell)
nb = new_notebook()
nb.cells.append(cell)
preprocessors[0].preprocess(nb, resources)
gradebook.add_submission("ps0", "bar")
cell.source = "hello!"
preprocessors[1].preprocess(nb, resources)
comment = gradebook.find_comment("foo", "test", "ps0", "bar")
assert comment.auto_comment is None
def test_save_changed_code(self, preprocessors, gradebook, resources):
"""Is an unchanged code cell given the correct comment?"""
cell = create_solution_cell("hello", "code")
nb = new_notebook()
nb.cells.append(cell)
preprocessors[0].preprocess(nb, resources)
gradebook.add_submission("ps0", "bar")
cell.source = "hello!"
preprocessors[1].preprocess(nb, resources)
preprocessors[2].preprocess(nb, resources)
comment = gradebook.find_comment(0, "test", "ps0", "bar")
assert cell.metadata.nbgrader['comment'] == comment.to_dict()
assert cell.metadata.nbgrader['comment']['comment'] == None
def test_save_code_solution_cell(self, preprocessor, resources):
cell = create_solution_cell("hello", "code", "foo")
cell.metadata.nbgrader['checksum'] = compute_checksum(cell)
nb = new_notebook()
nb.cells.append(cell)
nb, resources = preprocessor.preprocess(nb, resources)
gb = preprocessor.gradebook
gb.find_solution_cell("foo", "test", "ps0")
source_cell = gb.find_source_cell("foo", "test", "ps0")
assert source_cell.source == "hello"
assert source_cell.checksum == cell.metadata.nbgrader["checksum"]
assert source_cell.cell_type == "code"
assert not source_cell.locked
def test_save_markdown_solution_cell(self, preprocessor, resources):
cell = create_solution_cell("hello", "markdown", "foo")
cell.metadata.nbgrader['checksum'] = compute_checksum(cell)
nb = new_notebook()
nb.cells.append(cell)
nb, resources = preprocessor.preprocess(nb, resources)
gb = preprocessor.gradebook
gb.find_solution_cell("foo", "test", "ps0")
source_cell = gb.find_source_cell("foo", "test", "ps0")
assert source_cell.source == "hello"
assert source_cell.checksum == cell.metadata.nbgrader["checksum"]
assert source_cell.cell_type == "markdown"
assert not source_cell.locked
def test_compute_checksum_solution_cell():
# does it make a difference if solution=True?
cell1 = create_solution_cell("hello", "code", "foo")
cell2 = create_solution_cell("hello", "code", "foo")
cell2.metadata.nbgrader["solution"] = False
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
def test_compute_checksum_solution_cell():
# does it make a difference if solution=True?
cell1 = create_solution_cell("hello", "code", "foo")
cell2 = create_solution_cell("hello", "code", "foo")
cell2.metadata.nbgrader["solution"] = False
assert utils.compute_checksum(cell1) != utils.compute_checksum(cell2)
def test_compute_checksum_utf8():
utils.compute_checksum(create_solution_cell("\u03b8", "markdown", "foo"))
