Beispiel #1
0
    def test_luid(self, mocked_init):

        s = Stage()
        s._p_pipeline = {'uid': 'pipe.0000', 'name': None}
        s._uid = 'stage.0000'
        s._name = None

        self.assertEqual(s.luid, 'pipe.0000.stage.0000')

        s = Stage()
        s._p_pipeline = {'uid': 'pipe.0000', 'name': 'test_pipe'}
        s._uid = 'stage.0000'
        s._name = None

        self.assertEqual(s.luid, 'test_pipe.stage.0000')

        s = Stage()
        s._p_pipeline = {'uid': 'pipe.0000', 'name': None}
        s._uid = 'stage.0000'
        s._name = 'test_stage'

        self.assertEqual(s.luid, 'pipe.0000.test_stage')

        s = Stage()
        s._p_pipeline = {'uid': 'pipe.0000', 'name': 'test_pipe'}
        s._uid = 'stage.0000'
        s._name = 'test_stage'

        self.assertEqual(s.luid, 'test_pipe.test_stage')
Beispiel #2
0
    def test_stage_task_addition(self, mocked_init):

        s = Stage()
        s._p_pipeline = {'uid': None, 'name': None}
        s._uid = 'stage.0000'
        s._name = None
        s._tasks = set()
        t1 = mock.MagicMock(spec=Task)
        t2 = mock.MagicMock(spec=Task)
        s.add_tasks(set([t1, t2]))

        self.assertIsInstance(s.tasks, set)
        self.assertEqual(s._task_count, 2)
        self.assertIn(t1, s.tasks)
        self.assertIn(t2, s.tasks)

        s = Stage()
        s._uid = 'stage.0000'
        s._name = None
        s._p_pipeline = {'uid': None, 'name': None}
        s._tasks = set()
        t1 = mock.MagicMock(spec=Task)
        t2 = mock.MagicMock(spec=Task)
        s.add_tasks([t1, t2])

        self.assertIsInstance(s.tasks, set)
        self.assertEqual(s._task_count, 2)
        self.assertIn(t1, s.tasks)
        self.assertIn(t2, s.tasks)
Beispiel #3
0
    def test_stage_from_dict(self, mocked_init):

        d = {
            'uid': 're.Stage.0000',
            'name': 's1',
            'state': states.DONE,
            'state_history': [states.INITIAL, states.DONE],
            'parent_pipeline': {
                'uid': 'p1',
                'name': 'pipe1'
            }
        }

        s = Stage()
        s._uid = None
        s._name = None
        s._state = None
        s._state_history = None
        s._p_pipeline = None
        s.from_dict(d)

        self.assertEqual(s._uid, d['uid'])
        self.assertEqual(s._name, d['name'])
        self.assertEqual(s._state, d['state'])
        self.assertEqual(s._state_history, d['state_history'])
        self.assertEqual(s._p_pipeline, d['parent_pipeline'])
Beispiel #4
0
    def test_stage_to_dict(self, mocked_init):

        s = Stage()
        s._uid = 'stage.0000'
        s._name = 'test_stage'
        s._state = states.INITIAL
        s._state_history = [states.INITIAL]
        s._p_pipeline = {'uid': 'pipeline.0000', 'name': 'parent'}

        self.assertEqual(
            s.to_dict(), {
                'uid': 'stage.0000',
                'name': 'test_stage',
                'state': states.INITIAL,
                'state_history': [states.INITIAL],
                'parent_pipeline': {
                    'uid': 'pipeline.0000',
                    'name': 'parent'
                }
            })