def test_update_domain_same_names(self):
"""Test that no uniqeue name constraint error is raised when updating
and existing entity, leaving its name same.
"""
block = Block.objects.create(name='b1', order=5)
toolbox = Toolbox.objects.create(name='tb1')
ps = ProblemSet.objects.create(name='ps')
domain = Domain.objects.create(name='test1')
domain.blocks.set([block])
domain.toolboxes.set([toolbox])
domain.problemsets.set([ps])
data = {
"name": "test1",
"problemsets": [{
"id": ps.pk,
"name": "ps"
}],
"tasks": [],
"toolboxes": [{
"id": toolbox.pk,
"name": "tb1",
"blocks": []
}],
"blocks": [{
"id": block.id,
"name": "b1"
}]
}
serializer = DomainSerializer()
serializer.create_or_update(data)
domain = Domain.objects.get(name='test1')
self.assertQuerysetEqual(domain.blocks.all(), ['<Block: b1>'])
self.assertQuerysetEqual(domain.toolboxes.all(), ['<Toolbox: tb1>'])
self.assertQuerysetEqual(domain.problemsets.all(),
['<ProblemSet: ps>'])
def test_update_existing_domain_nested(self):
block = Block.objects.create(name='b1', order=5)
toolbox = Toolbox.objects.create(name='tb1')
toolbox.blocks.set([block])
domain = Domain.objects.create(name='test1')
domain.blocks.set([block])
domain.toolboxes.set([toolbox])
data = {
"name":
"test1",
"problemsets": [],
"tasks": [],
"toolboxes": [{
"id": toolbox.pk,
"name": "tb1",
"blocks": ["b2", "b3"]
}],
"blocks": [{
"id": 2,
"name": "b2"
}, {
"id": 3,
"name": "b3"
}]
}
serializer = DomainSerializer()
serializer.create_or_update(data)
domain = Domain.objects.get(name='test1')
self.assertQuerysetEqual(domain.toolboxes.all(), ['<Toolbox: tb1>'])
self.assertQuerysetEqual(domain.toolboxes.first().blocks.all(),
['<Block: b2>', '<Block: b3>'])
def test_nested_deserialization(self):
data = {
"name": "test1", "problemsets" : [], "tasks": [],
"toolboxes": [{"id": 1, "name": "tb1", "blocks": ["b1", "b2"]}],
"blocks": [{"id": 1, "name": "b1"}, {"id": 2, "name": "b2"}]}
serializer = DomainSerializer()
serializer.create_or_update(data)
domain = Domain.objects.get(name='test1')
self.assertQuerysetEqual(
domain.toolboxes.first().blocks.all(),
['<Block: b1>', '<Block: b2>'])
def test_update_existing_domain_with_toolbox(self):
toolbox = Toolbox.objects.create(name='tb1')
domain = Domain.objects.create(name='test1')
domain.toolboxes.set([toolbox])
data = {
"name": "test1",
"problemsets" : [], "tasks": [], "blocks": [],
"toolboxes": [{"id": toolbox.pk, "name": "tb1n", "blocks": []}]}
serializer = DomainSerializer()
serializer.create_or_update(data)
domain = Domain.objects.get(name='test1')
self.assertQuerysetEqual(domain.toolboxes.all(), ['<Toolbox: tb1n>'])
def load_domain_from_file(name='domain/domain.json'):
path = os.path.join(settings.REPO_DIR, 'backend', name)
with open(path) as infile:
data = json.load(infile)
task_dir = os.path.join(os.path.dirname(path), data['include']['tasks'])
inject_tasks_data(data['tasks'], task_dir)
# TODO: inject order?
serializer = DomainSerializer()
domain = serializer.create_or_update(data)
params_path = os.path.normpath(
os.path.join(os.path.dirname(path), data['include']['params']))
load_domain_params(domain, params_path)
return domain
def test_update_existing_domain(self):
block = Block.objects.create(name='b1', order=5)
domain = Domain.objects.create(name='test1')
domain.blocks.set([block])
data = {
"name": "test1",
"problemsets" : [], "tasks": [], "toolboxes": [],
"blocks": [{"id": block.id, "name": "b2"}, {"id": 3, "name": "b3"}]}
serializer = DomainSerializer()
serializer.create_or_update(data)
domain = Domain.objects.get(name='test1')
self.assertQuerysetEqual(
domain.blocks.all(),
['<Block: b2>', '<Block: b3>'])
def test_domain_with_hierarchical_ps_deserialization(self):
data = {
"name": "test1", "blocks" : [], "toolboxes": [], "tasks": [],
"problemsets": [
{"id": 1, "name": "m1", "parts": ["p1"]},
{"id": 2, "name": "p1"}]}
serializer = DomainSerializer()
serializer.create_or_update(data)
domain = Domain.objects.get(name='test1')
m1 = domain.problemsets.get(name='m1')
assert m1.name == 'm1'
assert m1.section == '1'
assert m1.parts.count() == 1
assert m1.parts.first().name == 'p1'
def test_update_existing_domain_with_toolbox(self):
toolbox = Toolbox.objects.create(name='tb1')
domain = Domain.objects.create(name='test1')
domain.toolboxes.set([toolbox])
data = {
"name": "test1",
"problemsets": [],
"tasks": [],
"blocks": [],
"toolboxes": [{
"id": toolbox.pk,
"name": "tb1n",
"blocks": []
}]
}
serializer = DomainSerializer()
serializer.create_or_update(data)
domain = Domain.objects.get(name='test1')
self.assertQuerysetEqual(domain.toolboxes.all(), ['<Toolbox: tb1n>'])
def test_update_existing_domain_nested(self):
block = Block.objects.create(name='b1', order=5)
toolbox = Toolbox.objects.create(name='tb1')
toolbox.blocks.set([block])
domain = Domain.objects.create(name='test1')
domain.blocks.set([block])
domain.toolboxes.set([toolbox])
data = {
"name": "test1", "problemsets" : [], "tasks": [],
"toolboxes": [{"id": toolbox.pk, "name": "tb1", "blocks": ["b2", "b3"]}],
"blocks": [{"id": 2, "name": "b2"}, {"id": 3, "name": "b3"}]}
serializer = DomainSerializer()
serializer.create_or_update(data)
domain = Domain.objects.get(name='test1')
self.assertQuerysetEqual(
domain.toolboxes.all(),
['<Toolbox: tb1>'])
self.assertQuerysetEqual(
domain.toolboxes.first().blocks.all(),
['<Block: b2>', '<Block: b3>'])
def test_update_existing_domain(self):
block = Block.objects.create(name='b1', order=5)
domain = Domain.objects.create(name='test1')
domain.blocks.set([block])
data = {
"name": "test1",
"problemsets": [],
"tasks": [],
"toolboxes": [],
"blocks": [{
"id": block.id,
"name": "b2"
}, {
"id": 3,
"name": "b3"
}]
}
serializer = DomainSerializer()
serializer.create_or_update(data)
domain = Domain.objects.get(name='test1')
self.assertQuerysetEqual(domain.blocks.all(),
['<Block: b2>', '<Block: b3>'])
def test_nested_deserialization(self):
data = {
"name": "test1",
"problemsets": [],
"tasks": [],
"toolboxes": [{
"id": 1,
"name": "tb1",
"blocks": ["b1", "b2"]
}],
"blocks": [{
"id": 1,
"name": "b1"
}, {
"id": 2,
"name": "b2"
}]
}
serializer = DomainSerializer()
serializer.create_or_update(data)
domain = Domain.objects.get(name='test1')
self.assertQuerysetEqual(domain.toolboxes.first().blocks.all(),
['<Block: b1>', '<Block: b2>'])
def test_update_domain_same_names(self):
"""Test that no uniqeue name constraint error is raised when updating
and existing entity, leaving its name same.
"""
block = Block.objects.create(name='b1', order=5)
toolbox = Toolbox.objects.create(name='tb1')
ps = ProblemSet.objects.create(name='ps')
domain = Domain.objects.create(name='test1')
domain.blocks.set([block])
domain.toolboxes.set([toolbox])
domain.problemsets.set([ps])
data = {
"name": "test1",
"problemsets" : [{"id": ps.pk, "name": "ps"}],
"tasks": [],
"toolboxes": [{"id": toolbox.pk, "name": "tb1", "blocks": []}],
"blocks": [{"id": block.id, "name": "b1"}]}
serializer = DomainSerializer()
serializer.create_or_update(data)
domain = Domain.objects.get(name='test1')
self.assertQuerysetEqual(domain.blocks.all(), ['<Block: b1>'])
self.assertQuerysetEqual(domain.toolboxes.all(), ['<Toolbox: tb1>'])
self.assertQuerysetEqual(domain.problemsets.all(), ['<ProblemSet: ps>'])
def test_domain_with_hierarchical_ps_deserialization(self):
data = {
"name":
"test1",
"blocks": [],
"toolboxes": [],
"tasks": [],
"problemsets": [{
"id": 1,
"name": "m1",
"parts": ["p1"]
}, {
"id": 2,
"name": "p1"
}]
}
serializer = DomainSerializer()
serializer.create_or_update(data)
domain = Domain.objects.get(name='test1')
m1 = domain.problemsets.get(name='m1')
assert m1.name == 'm1'
assert m1.section == '1'
assert m1.parts.count() == 1
assert m1.parts.first().name == 'p1'
def test_serialization(self):
block = Block.objects.create(name='b1', order=5)
toolbox = Toolbox.objects.create(name='tb1')
instruction = Instruction.objects.create(name='i1')
task = Task.objects.create(name='t1')
ps = ProblemSet.objects.create(name='ps1')
domain = Domain.objects.create(name='d1')
domain.blocks.set([block])
domain.toolboxes.set([toolbox])
domain.instructions.set([instruction])
domain.tasks.set([task])
domain.problemsets.set([ps])
serializer = DomainSerializer(domain)
assert serializer.data['name'] == 'd1'
assert serializer.data['blocks'] == [{
'id': block.id,
'name': 'b1',
'order': 5
}]
assert len(serializer.data['toolboxes']) == 1
assert len(serializer.data['tasks']) == 1
assert len(serializer.data['problemsets']) == 1
assert len(serializer.data['instructions']) == 1
def test_nested_serialization(self):
block = Block.objects.create(name='b1', order=5)
toolbox = Toolbox.objects.create(name='tb1')
toolbox.blocks.set([block])
domain = Domain.objects.create(name='d1')
domain.blocks.set([block])
domain.toolboxes.set([toolbox])
serializer = DomainSerializer(domain)
assert serializer.data == {
'name': 'd1',
'blocks': [{
'id': block.id,
'name': 'b1',
'order': 5
}],
'toolboxes': [{
'id': toolbox.id,
'name': 'tb1',
'blocks': ['b1']
}],
'tasks': [],
'problemsets': [],
'instructions': []
}
def list(self, request, format=None):
domain = get_domain()
# TODO: Don't pass request context if not needed.
serializer = DomainSerializer(domain, context={'request': request})
return Response(serializer.data)