3D-printing/Cura
1
0
Fork 0
mirror of https://github.com/Ultimaker/Cura.git synced 2025-07-21 05:37:50 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

Merge branch 'tests-for-um3networkplugin' into cloud-output-device

Browse source 
* tests-for-um3networkplugin:
  Fixed the failing tests
  Made the tests work with the named tuples Tests only use the _onGetRemoteMaterial
  Fixed some bugs and added the color_code field to the named tuple
This commit is contained in:
ChrisTerBeke 2018-11-20 18:57:42 +01:00
commit ff2d8b9076
No known key found for this signature in database
GPG key ID: A49F1AB9D7E0C263
3 changed files with 141 additions and 198 deletions
Download patch file Download diff file Expand all files Collapse all files

1
plugins/UM3NetworkPrinting/src/Models.py
View file

@ -23,6 +23,7 @@ LocalMaterial = namedtuple('LocalMaterial', [
'brand', 'brand',
'material', 'material',
'color_name', 'color_name',
'color_code',
'description', 'description',
'adhesion_info', 'adhesion_info',
'approximate_diameter', 'approximate_diameter',

25
plugins/UM3NetworkPrinting/src/SendMaterialJob.py
View file

@ -2,6 +2,7 @@
# Cura is released under the terms of the LGPLv3 or higher. # Cura is released under the terms of the LGPLv3 or higher.
import json import json
import os import os
import re
import urllib.parse import urllib.parse
from typing import Dict, TYPE_CHECKING, Set from typing import Dict, TYPE_CHECKING, Set
@ -19,7 +20,6 @@ from .Models import ClusterMaterial, LocalMaterial
if TYPE_CHECKING: if TYPE_CHECKING:
from .ClusterUM3OutputDevice import ClusterUM3OutputDevice from .ClusterUM3OutputDevice import ClusterUM3OutputDevice
## Asynchronous job to send material profiles to the printer. ## Asynchronous job to send material profiles to the printer.
# #
# This way it won't freeze up the interface while sending those materials. # This way it won't freeze up the interface while sending those materials.
@ -50,7 +50,7 @@ class SendMaterialJob(Job):
self._sendMissingMaterials(remote_materials_by_guid) self._sendMissingMaterials(remote_materials_by_guid)
except json.JSONDecodeError: except json.JSONDecodeError:
Logger.logException("w", "Error parsing materials from printer") Logger.logException("w", "Error parsing materials from printer")
except KeyError: except TypeError:
Logger.logException("w", "Error parsing materials from printer") Logger.logException("w", "Error parsing materials from printer")
## Determine which materials should be updated and send them to the printer. ## Determine which materials should be updated and send them to the printer.
@ -75,7 +75,8 @@ class SendMaterialJob(Job):
## From the local and remote materials, determine which ones should be synchronized. ## From the local and remote materials, determine which ones should be synchronized.
# #
# Makes a Set containing only the materials that are not on the printer yet or the ones that are newer in Cura. # Makes a Set of id's containing only the id's of the materials that are not on the printer yet or the ones that
# are newer in Cura.
# #
# \param local_materials The local materials by GUID. # \param local_materials The local materials by GUID.
# \param remote_materials The remote materials by GUID. # \param remote_materials The remote materials by GUID.
@ -83,8 +84,9 @@ class SendMaterialJob(Job):
def _determineMaterialsToSend(local_materials: Dict[str, LocalMaterial], def _determineMaterialsToSend(local_materials: Dict[str, LocalMaterial],
remote_materials: Dict[str, ClusterMaterial]) -> Set[str]: remote_materials: Dict[str, ClusterMaterial]) -> Set[str]:
return { return {
material.id for guid, material in local_materials.items() material.id
if guid not in remote_materials or material.version > remote_materials[guid].version for guid, material in local_materials.items()
if guid not in remote_materials or int(material.version) > remote_materials[guid].version
} }
## Send the materials to the printer. ## Send the materials to the printer.
@ -157,7 +159,7 @@ class SendMaterialJob(Job):
@classmethod @classmethod
def _parseReply(cls, reply: QNetworkReply) -> Dict[str, ClusterMaterial]: def _parseReply(cls, reply: QNetworkReply) -> Dict[str, ClusterMaterial]:
remote_materials = json.loads(reply.readAll().data().decode("utf-8")) remote_materials = json.loads(reply.readAll().data().decode("utf-8"))
return {material["id"]: ClusterMaterial(**material) for material in remote_materials} return {material["guid"]: ClusterMaterial(**material) for material in remote_materials}
## Retrieves a list of local materials ## Retrieves a list of local materials
# #
@ -170,12 +172,19 @@ class SendMaterialJob(Job):
material_containers = container_registry.findContainersMetadata(type = "material") material_containers = container_registry.findContainersMetadata(type = "material")
# Find the latest version of all material containers in the registry. # Find the latest version of all material containers in the registry.
local_materials = {} # type: Dict[str, LocalMaterial]
for material in material_containers: for material in material_containers:
try: try:
material = LocalMaterial(**material) material = LocalMaterial(**material)
# material version must be an int
if not re.match("\d+", material.version):
Logger.logException("w", "Local material {} has invalid version '{}'."
.format(material["id"], material.version))
continue
if material.GUID not in result or material.version > result.get(material.GUID).version: if material.GUID not in result or material.version > result.get(material.GUID).version:
local_materials[material.GUID] = material result[material.GUID] = material
except ValueError: except ValueError:
Logger.logException("w", "Local material {} has invalid values.".format(material["id"])) Logger.logException("w", "Local material {} has invalid values.".format(material["id"]))
return result return result

313
plugins/UM3NetworkPrinting/tests/TestSendMaterialJob.py
View file

@ -1,53 +1,23 @@
# Copyright (c) 2018 Ultimaker B.V. # Copyright (c) 2018 Ultimaker B.V.
# Cura is released under the terms of the LGPLv3 or higher. # Cura is released under the terms of the LGPLv3 or higher.
import io
import json import json
from unittest import TestCase, mock
from typing import Any, List
from unittest import TestCase
from unittest.mock import patch, call from unittest.mock import patch, call
from PyQt5.QtCore import QByteArray from PyQt5.QtCore import QByteArray
from UM.Settings.ContainerRegistry import ContainerInterface, ContainerRegistryInterface, DefinitionContainerInterface from UM.MimeTypeDatabase import MimeType
from plugins.UM3NetworkPrinting.src.ClusterUM3OutputDevice import ClusterUM3OutputDevice from cura.CuraApplication import CuraApplication
from plugins.UM3NetworkPrinting.src.SendMaterialJob import SendMaterialJob from plugins.UM3NetworkPrinting.src.SendMaterialJob import SendMaterialJob
class ContainerRegistryMock(ContainerRegistryInterface): @patch("builtins.open", lambda _, __: io.StringIO("<xml></xml>"))
@patch("UM.MimeTypeDatabase.MimeTypeDatabase.getMimeTypeForFile",
def __init__(self): lambda _: MimeType(name = "application/x-ultimaker-material-profile", comment = "Ultimaker Material Profile",
self.containersMetaData = None suffixes = ["xml.fdm_material"]))
@patch("UM.Resources.Resources.getAllResourcesOfType", lambda _: ["/materials/generic_pla_white.xml.fdm_material"])
def findContainers(self, *, ignore_case: bool = False, **kwargs: Any) -> List[ContainerInterface]:
raise NotImplementedError()
def findDefinitionContainers(self, **kwargs: Any) -> List[DefinitionContainerInterface]:
raise NotImplementedError()
@classmethod
def getApplication(cls) -> "Application":
raise NotImplementedError()
def getEmptyInstanceContainer(self) -> "InstanceContainer":
raise NotImplementedError()
def isReadOnly(self, container_id: str) -> bool:
raise NotImplementedError()
def setContainersMetadata(self, value):
self.containersMetaData = value
def findContainersMetadata(self, type):
return self.containersMetaData
class MockOutputDevice(ClusterUM3OutputDevice):
def _createFormPart(self, content_header, data, content_type=None):
return "xxx"
class TestSendMaterialJob(TestCase): class TestSendMaterialJob(TestCase):
_LOCAL_MATERIAL_WHITE = {"type": "material", "status": "unknown", "id": "generic_pla_white", _LOCAL_MATERIAL_WHITE = {"type": "material", "status": "unknown", "id": "generic_pla_white",
"base_file": "generic_pla_white", "setting_version": 5, "name": "White PLA", "base_file": "generic_pla_white", "setting_version": 5, "name": "White PLA",
"brand": "Generic", "material": "PLA", "color_name": "White", "brand": "Generic", "material": "PLA", "color_name": "White",
@ -88,11 +58,11 @@ class TestSendMaterialJob(TestCase):
job.run() job.run()
# We expect the materials endpoint to be called when the job runs. # We expect the materials endpoint to be called when the job runs.
device_mock.get.assert_called_with("materials/", on_finished=job._onGetRemoteMaterials) device_mock.get.assert_called_with("materials/", on_finished = job._onGetRemoteMaterials)
@patch("plugins.UM3NetworkPrinting.src.ClusterUM3OutputDevice") @patch("plugins.UM3NetworkPrinting.src.ClusterUM3OutputDevice")
@patch("PyQt5.QtNetwork.QNetworkReply") @patch("PyQt5.QtNetwork.QNetworkReply")
def test_sendMissingMaterials_withFailedRequest(self, reply_mock, device_mock): def test__onGetRemoteMaterials_withFailedRequest(self, reply_mock, device_mock):
reply_mock.attribute.return_value = 404 reply_mock.attribute.return_value = 404
job = SendMaterialJob(device_mock) job = SendMaterialJob(device_mock)
job._onGetRemoteMaterials(reply_mock) job._onGetRemoteMaterials(reply_mock)
@ -103,7 +73,7 @@ class TestSendMaterialJob(TestCase):
@patch("plugins.UM3NetworkPrinting.src.ClusterUM3OutputDevice") @patch("plugins.UM3NetworkPrinting.src.ClusterUM3OutputDevice")
@patch("PyQt5.QtNetwork.QNetworkReply") @patch("PyQt5.QtNetwork.QNetworkReply")
def test_sendMissingMaterials_withBadJsonAnswer(self, reply_mock, device_mock): def test__onGetRemoteMaterials_withBadJsonAnswer(self, reply_mock, device_mock):
reply_mock.attribute.return_value = 200 reply_mock.attribute.return_value = 200
reply_mock.readAll.return_value = QByteArray(b"Six sick hicks nick six slick bricks with picks and sticks.") reply_mock.readAll.return_value = QByteArray(b"Six sick hicks nick six slick bricks with picks and sticks.")
job = SendMaterialJob(device_mock) job = SendMaterialJob(device_mock)
@ -116,7 +86,7 @@ class TestSendMaterialJob(TestCase):
@patch("plugins.UM3NetworkPrinting.src.ClusterUM3OutputDevice") @patch("plugins.UM3NetworkPrinting.src.ClusterUM3OutputDevice")
@patch("PyQt5.QtNetwork.QNetworkReply") @patch("PyQt5.QtNetwork.QNetworkReply")
def test_sendMissingMaterials_withMissingGuid(self, reply_mock, device_mock): def test__onGetRemoteMaterials_withMissingGuidInRemoteMaterial(self, reply_mock, device_mock):
reply_mock.attribute.return_value = 200 reply_mock.attribute.return_value = 200
remote_material_without_guid = self._REMOTE_MATERIAL_WHITE.copy() remote_material_without_guid = self._REMOTE_MATERIAL_WHITE.copy()
del remote_material_without_guid["guid"] del remote_material_without_guid["guid"]
@ -127,151 +97,114 @@ class TestSendMaterialJob(TestCase):
# We expect the reply to be called once to try to get the printers from the list (readAll()). # We expect the reply to be called once to try to get the printers from the list (readAll()).
# Given that parsing fails we do not expect the device to be called for any follow up. # Given that parsing fails we do not expect the device to be called for any follow up.
self.assertEqual([call.attribute(0), call.readAll()], reply_mock.method_calls) self.assertEqual([call.attribute(0), call.readAll()], reply_mock.method_calls)
self.assertEqual(1, device_mock.createFormPart.call_count) self.assertEqual(0, device_mock.createFormPart.call_count)
# @patch("UM.Resources.Resources.getAllResourcesOfType", lambda _: []) @patch("cura.Settings.CuraContainerRegistry")
# @patch("PyQt5.QtNetwork.QNetworkReply") @patch("cura.CuraApplication")
# def test_sendMissingMaterials_WithInvalidVersionInLocalMaterial(self, reply_mock): @patch("plugins.UM3NetworkPrinting.src.ClusterUM3OutputDevice")
# reply_mock.attribute.return_value = 200 @patch("PyQt5.QtNetwork.QNetworkReply")
# reply_mock.readAll.return_value = QByteArray(json.dumps([self._REMOTEMATERIAL_WHITE]).encode("ascii")) def test__onGetRemoteMaterials_withInvalidVersionInLocalMaterial(self, reply_mock, device_mock, application_mock,
# container_registry_mock):
# containerRegistry = ContainerRegistryMock() reply_mock.attribute.return_value = 200
# localMaterialWhiteWithInvalidVersion = self._LOCALMATERIAL_WHITE.copy() reply_mock.readAll.return_value = QByteArray(json.dumps([self._REMOTE_MATERIAL_WHITE]).encode("ascii"))
# localMaterialWhiteWithInvalidVersion["version"] = "one"
# containerRegistry.setContainersMetadata([localMaterialWhiteWithInvalidVersion]) localMaterialWhiteWithInvalidVersion = self._LOCAL_MATERIAL_WHITE.copy()
# localMaterialWhiteWithInvalidVersion["version"] = "one"
# with mock.patch.object(Logger, "log", new=new_log): container_registry_mock.findContainersMetadata.return_value = [localMaterialWhiteWithInvalidVersion]
# with mock.patch.object(ContainerRegistry, "getInstance", lambda: containerRegistry):
# SendMaterialJob(None).sendMissingMaterials(reply_mock) application_mock.getContainerRegistry.return_value = container_registry_mock
#
# reply_mock.attribute.assert_called_with(0) with mock.patch.object(CuraApplication, "getInstance", new = lambda: application_mock):
# self.assertEqual(reply_mock.method_calls, [call.attribute(0), call.readAll()]) job = SendMaterialJob(device_mock)
# self._assertLogEntries([("e", "Material generic_pla_white has invalid version number one.")], _logentries) job._onGetRemoteMaterials(reply_mock)
#
# @patch("UM.Resources.Resources.getAllResourcesOfType", lambda _: []) self.assertEqual([call.attribute(0), call.readAll()], reply_mock.method_calls)
# @patch("PyQt5.QtNetwork.QNetworkReply") self.assertEqual([call.getContainerRegistry()], application_mock.method_calls)
# def test_sendMissingMaterials_WithMultipleLocalVersionsLowFirst(self, reply_mock): self.assertEqual([call.findContainersMetadata(type = "material")], container_registry_mock.method_calls)
# reply_mock.attribute.return_value = 200 self.assertEqual(0, device_mock.createFormPart.call_count)
# reply_mock.readAll.return_value = QByteArray(json.dumps([self._REMOTEMATERIAL_WHITE]).encode("ascii"))
# @patch("cura.Settings.CuraContainerRegistry")
# containerRegistry = ContainerRegistryMock() @patch("cura.CuraApplication")
# localMaterialWhiteWithHigherVersion = self._LOCALMATERIAL_WHITE.copy() @patch("plugins.UM3NetworkPrinting.src.ClusterUM3OutputDevice")
# localMaterialWhiteWithHigherVersion["version"] = "2" @patch("PyQt5.QtNetwork.QNetworkReply")
# containerRegistry.setContainersMetadata([self._LOCALMATERIAL_WHITE, localMaterialWhiteWithHigherVersion]) def test__onGetRemoteMaterials_withNoUpdate(self, reply_mock, device_mock, application_mock,
# container_registry_mock):
# with mock.patch.object(Logger, "log", new=new_log): application_mock.getContainerRegistry.return_value = container_registry_mock
# with mock.patch.object(ContainerRegistry, "getInstance", lambda: containerRegistry):
# SendMaterialJob(None).sendMissingMaterials(reply_mock) device_mock.createFormPart.return_value = "_xXx_"
#
# reply_mock.attribute.assert_called_with(0) container_registry_mock.findContainersMetadata.return_value = [self._LOCAL_MATERIAL_WHITE]
# self.assertEqual(reply_mock.method_calls, [call.attribute(0), call.readAll()])
# self._assertLogEntries([], _logentries) reply_mock.attribute.return_value = 200
# reply_mock.readAll.return_value = QByteArray(json.dumps([self._REMOTE_MATERIAL_WHITE]).encode("ascii"))
# @patch("UM.Resources.Resources.getAllResourcesOfType", lambda _: [])
# @patch("PyQt5.QtNetwork.QNetworkReply") with mock.patch.object(CuraApplication, "getInstance", new = lambda: application_mock):
# def test_sendMissingMaterials_MaterialMissingOnPrinter(self, reply_mock): job = SendMaterialJob(device_mock)
# reply_mock.attribute.return_value = 200 job._onGetRemoteMaterials(reply_mock)
# reply_mock.readAll.return_value = QByteArray(
# json.dumps([self._REMOTEMATERIAL_WHITE]).encode("ascii")) self.assertEqual([call.attribute(0), call.readAll()], reply_mock.method_calls)
# self.assertEqual([call.getContainerRegistry()], application_mock.method_calls)
# containerRegistry = ContainerRegistryMock() self.assertEqual([call.findContainersMetadata(type = "material")], container_registry_mock.method_calls)
# containerRegistry.setContainersMetadata([self._LOCALMATERIAL_WHITE, self._LOCALMATERIAL_BLACK]) self.assertEqual(0, device_mock.createFormPart.call_count)
# self.assertEqual(0, device_mock.postFormWithParts.call_count)
# with mock.patch.object(Logger, "log", new=new_log):
# with mock.patch.object(ContainerRegistry, "getInstance", lambda: containerRegistry): @patch("cura.Settings.CuraContainerRegistry")
# SendMaterialJob(None).sendMissingMaterials(reply_mock) @patch("cura.CuraApplication")
# @patch("plugins.UM3NetworkPrinting.src.ClusterUM3OutputDevice")
# reply_mock.attribute.assert_called_with(0) @patch("PyQt5.QtNetwork.QNetworkReply")
# self.assertEqual(reply_mock.method_calls, [call.attribute(0), call.readAll()]) def test__onGetRemoteMaterials_withUpdatedMaterial(self, reply_mock, device_mock, application_mock,
# self._assertLogEntries([], _logentries) container_registry_mock):
# application_mock.getContainerRegistry.return_value = container_registry_mock
# @patch("builtins.open", lambda a, b: io.StringIO("<xml></xml>"))
# @patch("UM.MimeTypeDatabase.MimeTypeDatabase.getMimeTypeForFile", device_mock.createFormPart.return_value = "_xXx_"
# lambda _: MimeType(name="application/x-ultimaker-material-profile", comment="Ultimaker Material Profile",
# suffixes=["xml.fdm_material"])) localMaterialWhiteWithHigherVersion = self._LOCAL_MATERIAL_WHITE.copy()
# @patch("UM.Resources.Resources.getAllResourcesOfType", lambda _: ["/materials/generic_pla_white.xml.fdm_material"]) localMaterialWhiteWithHigherVersion["version"] = "2"
# @patch("plugins.UM3NetworkPrinting.src.ClusterUM3OutputDevice") container_registry_mock.findContainersMetadata.return_value = [localMaterialWhiteWithHigherVersion]
# def test_sendMaterialsToPrinter(self, device_mock):
# device_mock._createFormPart.return_value = "_xXx_" reply_mock.attribute.return_value = 200
# with mock.patch.object(Logger, "log", new=new_log): reply_mock.readAll.return_value = QByteArray(json.dumps([self._REMOTE_MATERIAL_WHITE]).encode("ascii"))
# job = SendMaterialJob(device_mock)
# job.sendMaterialsToPrinter({"generic_pla_white"}) with mock.patch.object(CuraApplication, "getInstance", new = lambda: application_mock):
# job = SendMaterialJob(device_mock)
# self._assertLogEntries([("d", "Syncing material generic_pla_white with cluster.")], _logentries) job._onGetRemoteMaterials(reply_mock)
# self.assertEqual([call._createFormPart("name="file"; filename="generic_pla_white.xml.fdm_material"", "<xml></xml>"),
# call.postFormWithParts(on_finished=job.sendingFinished, parts = ["_xXx_"], target = "materials/")], device_mock.method_calls) self.assertEqual([call.attribute(0), call.readAll()], reply_mock.method_calls)
# self.assertEqual([call.getContainerRegistry()], application_mock.method_calls)
# @patch("PyQt5.QtNetwork.QNetworkReply") self.assertEqual([call.findContainersMetadata(type = "material")], container_registry_mock.method_calls)
# def test_sendingFinished_success(self, reply_mock) -> None: self.assertEqual(1, device_mock.createFormPart.call_count)
# reply_mock.attribute.return_value = 200 self.assertEqual(1, device_mock.postFormWithParts.call_count)
# with mock.patch.object(Logger, "log", new=new_log): self.assertEquals(
# SendMaterialJob(None).sendingFinished(reply_mock) [call.createFormPart("name=\"file\"; filename=\"generic_pla_white.xml.fdm_material\"", "<xml></xml>"),
# call.postFormWithParts(target = "materials/", parts = ["_xXx_"], on_finished = job.sendingFinished)],
# reply_mock.attribute.assert_called_once_with(0) device_mock.method_calls)
# self.assertEqual(0, len(_logentries))
# @patch("cura.Settings.CuraContainerRegistry")
# @patch("PyQt5.QtNetwork.QNetworkReply") @patch("cura.CuraApplication")
# def test_sendingFinished_failed(self, reply_mock) -> None: @patch("plugins.UM3NetworkPrinting.src.ClusterUM3OutputDevice")
# reply_mock.attribute.return_value = 404 @patch("PyQt5.QtNetwork.QNetworkReply")
# reply_mock.readAll.return_value = QByteArray(b"Six sick hicks nick six slick bricks with picks and sticks.") def test__onGetRemoteMaterials_withNewMaterial(self, reply_mock, device_mock, application_mock,
# container_registry_mock):
# with mock.patch.object(Logger, "log", new=new_log): application_mock.getContainerRegistry.return_value = container_registry_mock
# SendMaterialJob(None).sendingFinished(reply_mock)
# device_mock.createFormPart.return_value = "_xXx_"
# reply_mock.attribute.assert_called_with(0)
# self.assertEqual(reply_mock.method_calls, [call.attribute(0), call.attribute(0), call.readAll()]) container_registry_mock.findContainersMetadata.return_value = [self._LOCAL_MATERIAL_WHITE,
# self._LOCAL_MATERIAL_BLACK]
# self._assertLogEntries([
# ("e", "Received error code from printer when syncing material: 404"), reply_mock.attribute.return_value = 200
# ("e", "Six sick hicks nick six slick bricks with picks and sticks.") reply_mock.readAll.return_value = QByteArray(json.dumps([self._REMOTE_MATERIAL_BLACK]).encode("ascii"))
# ], _logentries)
# with mock.patch.object(CuraApplication, "getInstance", new = lambda: application_mock):
# @patch("PyQt5.QtNetwork.QNetworkReply") job = SendMaterialJob(device_mock)
# def test_parseReply(self, reply_mock): job._onGetRemoteMaterials(reply_mock)
# reply_mock.readAll.return_value = QByteArray(json.dumps([self._REMOTEMATERIAL_WHITE]).encode("ascii"))
# self.assertEqual([call.attribute(0), call.readAll()], reply_mock.method_calls)
# response = SendMaterialJob._parseReply(reply_mock) self.assertEqual([call.getContainerRegistry()], application_mock.method_calls)
# self.assertEqual([call.findContainersMetadata(type = "material")], container_registry_mock.method_calls)
# self.assertTrue(len(response) == 1) self.assertEqual(1, device_mock.createFormPart.call_count)
# self.assertEqual(next(iter(response.values())), ClusterMaterial(**self._REMOTEMATERIAL_WHITE)) self.assertEqual(1, device_mock.postFormWithParts.call_count)
# self.assertEquals(
# @patch("PyQt5.QtNetwork.QNetworkReply") [call.createFormPart("name=\"file\"; filename=\"generic_pla_white.xml.fdm_material\"", "<xml></xml>"),
# def test_parseReplyWithInvalidMaterial(self, reply_mock): call.postFormWithParts(target = "materials/", parts = ["_xXx_"], on_finished = job.sendingFinished)],
# remoteMaterialWithInvalidVersion = self._REMOTEMATERIAL_WHITE.copy() device_mock.method_calls)
# remoteMaterialWithInvalidVersion["version"] = "one"
# reply_mock.readAll.return_value = QByteArray(json.dumps([remoteMaterialWithInvalidVersion]).encode("ascii"))
#
# with self.assertRaises(ValueError):
# SendMaterialJob._parseReply(reply_mock)
#
# def test__getLocalMaterials(self):
# containerRegistry = ContainerRegistryMock()
# containerRegistry.setContainersMetadata([self._LOCALMATERIAL_WHITE, self._LOCALMATERIAL_BLACK])
#
# with mock.patch.object(Logger, "log", new=new_log):
# with mock.patch.object(ContainerRegistry, "getInstance", lambda: containerRegistry):
# local_materials = SendMaterialJob(None)._getLocalMaterials()
#
# self.assertTrue(len(local_materials) == 2)
#
# def test__getLocalMaterialsWithMultipleVersions(self):
# containerRegistry = ContainerRegistryMock()
# localMaterialWithNewerVersion = self._LOCALMATERIAL_WHITE.copy()
# localMaterialWithNewerVersion["version"] = 2
# containerRegistry.setContainersMetadata([self._LOCALMATERIAL_WHITE, localMaterialWithNewerVersion])
#
# with mock.patch.object(Logger, "log", new=new_log):
# with mock.patch.object(ContainerRegistry, "getInstance", lambda: containerRegistry):
# local_materials = SendMaterialJob(None)._getLocalMaterials()
#
# self.assertTrue(len(local_materials) == 1)
# self.assertTrue(list(local_materials.values())[0].version == 2)
#
# containerRegistry.setContainersMetadata([localMaterialWithNewerVersion, self._LOCALMATERIAL_WHITE])
#
# with mock.patch.object(Logger, "log", new=new_log):
# with mock.patch.object(ContainerRegistry, "getInstance", lambda: containerRegistry):
# local_materials = SendMaterialJob(None)._getLocalMaterials()
#
# self.assertTrue(len(local_materials) == 1)
# self.assertTrue(list(local_materials.values())[0].version == 2)