Beispiel #1
0
    def test_build_definition_minimal(self):
        # given
        defaults_mock = Mock()
        defaults_mock.main_program_file = "src_code.py"
        tti = CoreTaskTypeInfo("TESTTASK", RenderingTaskDefinition,
                               defaults_mock, Options, RenderingTaskBuilder)
        tti.output_file_ext = 'txt'
        task_dict = {
            'resources': {"file1.png", "file2.txt", 'file3.jpg', 'file4.txt'},
            'compute_on': 'cpu',
            'task_type': 'TESTTASK',
            'subtasks_count': 1
        }

        # when
        definition = RenderingTaskBuilder.build_definition(tti,
                                                           task_dict,
                                                           minimal=True)

        # then
        assert definition.main_scene_file in ['file2.txt', 'file4.txt']
        assert definition.task_type == "TESTTASK"
        assert definition.resources == {
            'file1.png', 'file2.txt', 'file3.jpg', 'file4.txt'
        }
Beispiel #2
0
    def test_full(self):
        # when
        definition = RenderingTaskBuilder.build_definition(
            self.tti, self.task_dict)

        # then
        assert definition.name == "NAME OF THE TASK"
        assert definition.max_price == 250000000000000000
        assert definition.timeout == 3600
        assert definition.subtask_timeout == 1500
        output_file = self.task_dict['name'] + "." + \
            self.task_dict['options']['format']
        assert definition.output_file == self.path + os.sep + output_file
Beispiel #3
0
    def test_calculate_total(self):
        definition = RenderingTaskDefinition()
        definition.optimize_total = True
        builder = RenderingTaskBuilder(root_path=self.path,
                                       dir_manager=DirManager(self.path),
                                       node_name="SOME NODE NAME",
                                       task_definition=definition)

        class Defaults(object):
            def __init__(self,
                         default_subtasks=13,
                         min_subtasks=3,
                         max_subtasks=33):
                self.default_subtasks = default_subtasks
                self.min_subtasks = min_subtasks
                self.max_subtasks = max_subtasks

        defaults = Defaults()
        assert builder._calculate_total(defaults) == 13

        defaults.default_subtasks = 17
        assert builder._calculate_total(defaults) == 17

        definition.optimize_total = False
        definition.total_subtasks = 18
        assert builder._calculate_total(defaults) == 18

        definition.total_subtasks = 2
        with self.assertLogs(logger, level="WARNING"):
            assert builder._calculate_total(defaults) == 17

        definition.total_subtasks = 3
        with self.assertNoLogs(logger, level="WARNING"):
            assert builder._calculate_total(defaults) == 3

        definition.total_subtasks = 34
        with self.assertLogs(logger, level="WARNING"):
            assert builder._calculate_total(defaults) == 17

        definition.total_subtasks = 33
        with self.assertNoLogs(logger, level="WARNING"):
            assert builder._calculate_total(defaults) == 33
Beispiel #4
0
    def test_main_scene_file(self):
        # given
        self.task_dict['resources'] = {
            "/path/to/file1.png",
            "/path/to/file2_longer_name.txt",
            "/path/to/file3.jpg",
            "/path/to/file4.txt",
        }
        self.task_dict['main_scene_file'] = "/path/to/file4.txt"

        # when
        definition = RenderingTaskBuilder.build_definition(
            self.tti, self.task_dict)

        # then
        assert definition.main_scene_file == "/path/to/file4.txt"
Beispiel #5
0
    def test_timeout_too_short(self):
        # given
        self.task_dict['timeout'] = "00:00:02"
        self.task_dict['subtask_timeout'] = "00:00:01"

        # when
        with self.assertLogs(logger_render, level="WARNING") as log_:
            definition = RenderingTaskBuilder.build_definition(
                self.tti, self.task_dict)

        # then
        assert "Timeout 2 too short for this task. Changing to %d" % \
               MIN_TIMEOUT in log_.output[0]
        assert "Subtask timeout 1 too short for this task. Changing to %d" % \
               SUBTASK_MIN_TIMEOUT in log_.output[1]
        assert definition.timeout == MIN_TIMEOUT
        assert definition.subtask_timeout == SUBTASK_MIN_TIMEOUT
Beispiel #6
0
    def test_main_scene_no_match(self):
        # given
        self.task_dict['resources'] = {
            "/path/to/file1.png",
            "/path/to/file2.txt",
            "/path/to/file3.jpg",
            "/path/to/file4.txt",
        }
        self.task_dict['main_scene_file'] = "/path/to/file5.txt"

        # when
        definition = RenderingTaskBuilder.build_definition(
            self.tti, self.task_dict)

        # then
        assert definition.resources == {
            "/path/to/file1.png",
            "/path/to/file2.txt",
            "/path/to/file3.jpg",
            "/path/to/file4.txt",
            # because it's added at RenderingTaskDefinition.add_to_resources
            # and it modifies it on windows
            path.normpath("/path/to/file5.txt"),
        }
Beispiel #7
0
 def test_get_output_path(self):
     td = TaskDefinition()
     td.name = "MY task"
     tdict = {'options': {'output_path': '/dir3/dir4', 'format': 'txt'}}
     assert RenderingTaskBuilder.get_output_path(tdict, td) == \
         path.join("/dir3/dir4", "MY task.txt")