def test_can_store_data(self):
node = factory.make_node()
name = factory.getRandomString()
data = factory.getRandomBytes()
factory.make_node_commission_result(node=node, name=name, data=data)
ncr = NodeCommissionResult.objects.get(name=name)
self.assertAttributes(ncr, dict(node=node, data=data))
def test_start_commissioning_clears_node_commissioning_results(self):
node = factory.make_node(status=NODE_STATUS.DECLARED)
NodeCommissionResult.objects.store_data(
node, factory.getRandomString(),
random.randint(0, 10),
Bin(factory.getRandomBytes()))
node.start_commissioning(factory.make_admin())
self.assertItemsEqual([], node.nodecommissionresult_set.all())
def test_start_commissioning_ignores_other_commissioning_results(self):
node = factory.make_node()
filename = factory.getRandomString()
data = factory.getRandomBytes()
script_result = random.randint(0, 10)
NodeCommissionResult.objects.store_data(
node, filename, script_result, Bin(data))
other_node = factory.make_node(status=NODE_STATUS.DECLARED)
other_node.start_commissioning(factory.make_admin())
self.assertEqual(
data, NodeCommissionResult.objects.get_data(node, filename))
def test_store_data_updates_existing(self):
node = factory.make_node()
name = factory.getRandomString(255)
script_result = randint(0, 10)
factory.make_node_commission_result(node=node, name=name)
data = factory.getRandomBytes(1024 * 1024)
NodeCommissionResult.objects.store_data(
node, name=name, script_result=script_result, data=Bin(data))
self.assertAttributes(
NodeCommissionResult.objects.get(node=node),
dict(name=name, data=data))
def test_store_data(self):
node = factory.make_node()
name = factory.getRandomString(255)
data = factory.getRandomBytes(1024 * 1024)
script_result = randint(0, 10)
result = NodeCommissionResult.objects.store_data(
node, name=name, script_result=script_result, data=Bin(data))
result_in_db = NodeCommissionResult.objects.get(node=node)
self.assertAttributes(result_in_db, dict(name=name, data=data))
# store_data() returns the model object.
self.assertEqual(result, result_in_db)
def test_inject_result_stores_data(self):
node = factory.make_node()
name = factory.make_name("result")
output = factory.getRandomBytes()
exit_status = next(factory.random_octets)
inject_result(node, name, output, exit_status)
self.assertThat(
NodeCommissionResult.objects.get(node=node, name=name),
MatchesStructure.byEquality(
node=node, name=name, script_result=exit_status,
data=output))
def test_inject_result_calls_hook(self):
node = factory.make_node()
name = factory.make_name("result")
output = factory.getRandomBytes()
exit_status = next(factory.random_octets)
hook = Mock()
self.patch(
cs_module, "BUILTIN_COMMISSIONING_SCRIPTS",
{name: {"hook": hook}})
inject_result(node, name, output, exit_status)
hook.assert_called_once_with(
node=node, output=output, exit_status=exit_status)
def test_inject_result_stores_data(self):
node = factory.make_node()
name = factory.make_name("result")
output = factory.getRandomBytes()
exit_status = next(factory.random_octets)
inject_result(node, name, output, exit_status)
self.assertThat(
NodeCommissionResult.objects.get(node=node, name=name),
MatchesStructure.byEquality(node=node,
name=name,
script_result=exit_status,
data=output))
def test_inject_result_calls_hook(self):
node = factory.make_node()
name = factory.make_name("result")
output = factory.getRandomBytes()
exit_status = next(factory.random_octets)
hook = Mock()
self.patch(cs_module, "BUILTIN_COMMISSIONING_SCRIPTS",
{name: {
"hook": hook
}})
inject_result(node, name, output, exit_status)
hook.assert_called_once_with(node=node,
output=output,
exit_status=exit_status)
def test_signalling_stores_files_for_any_status(self):
statuses = ['WORKING', 'OK', 'FAILED']
filename = factory.getRandomString()
nodes = {
status: factory.make_node(status=NODE_STATUS.COMMISSIONING)
for status in statuses}
for status, node in nodes.items():
client = make_node_client(node=node)
script_result = random.randint(0, 10)
call_signal(
client, status=status,
script_result=script_result,
files={filename: factory.getRandomBytes()})
self.assertEqual(
{status: filename for status in statuses},
{
status: NodeCommissionResult.objects.get(node=node).name
for status, node in nodes.items()})
def test_signalling_stores_files_for_any_status(self):
statuses = ['WORKING', 'OK', 'FAILED']
filename = factory.getRandomString()
nodes = {
status: factory.make_node(status=NODE_STATUS.COMMISSIONING)
for status in statuses
}
for status, node in nodes.items():
client = make_node_client(node=node)
script_result = random.randint(0, 10)
call_signal(client,
status=status,
script_result=script_result,
files={filename: factory.getRandomBytes()})
self.assertEqual(
{status: filename
for status in statuses}, {
status: NodeCommissionResult.objects.get(node=node).name
for status, node in nodes.items()
})
def test_POST_creates_commissioning_script(self):
# This uses Piston's built-in POST code, so there are no tests for
# corner cases (like "script already exists") here.
name = factory.make_name('script')
content = factory.getRandomBytes()
# Every uploaded file also has a name. But this is completely
# unrelated to the name we give to the commissioning script.
response = self.client.post(
self.get_url(), {
'name': name,
'content': factory.make_file_upload(content=content),
})
self.assertEqual(httplib.OK, response.status_code)
returned_script = json.loads(response.content)
self.assertEqual((name, b64encode(content).decode("ascii")),
(returned_script['name'], returned_script['content']))
stored_script = CommissioningScript.objects.get(name=name)
self.assertEqual(content, stored_script.content)