Ejemplo n.º 1
0
    def test_move(self):
        '''
        Test if it move scheduled job to another minion or minions.
        '''
        comm1 = 'no servers answered the published schedule.add command'
        comm2 = 'the following minions return False'
        comm3 = 'Moved Job job1 from schedule.'
        with patch.dict(schedule.__opts__, {
                'schedule': {
                    'job1': JOB1
                },
                'sock_dir': SOCK_DIR
        }):
            mock = MagicMock(return_value=True)
            with patch.dict(schedule.__salt__, {'event.fire': mock}):
                _ret_value = {'complete': True, 'schedule': {'job1': JOB1}}
                with patch.object(SaltEvent,
                                  'get_event',
                                  return_value=_ret_value):
                    mock = MagicMock(return_value={})
                    with patch.dict(schedule.__salt__,
                                    {'publish.publish': mock}):
                        self.assertDictEqual(schedule.move('job1', 'minion1'),
                                             {
                                                 'comment': comm1,
                                                 'result': True
                                             })

                    mock = MagicMock(return_value={'minion1': ''})
                    with patch.dict(schedule.__salt__,
                                    {'publish.publish': mock}):
                        self.assertDictEqual(
                            schedule.move('job1', 'minion1'), {
                                'comment': comm2,
                                'minions': ['minion1'],
                                'result': True
                            })

                    mock = MagicMock(return_value={'minion1': 'job1'})
                    with patch.dict(schedule.__salt__,
                                    {'publish.publish': mock}):
                        mock = MagicMock(return_value=True)
                        with patch.dict(schedule.__salt__,
                                        {'event.fire': mock}):
                            self.assertDictEqual(
                                schedule.move('job1', 'minion1'), {
                                    'comment': comm3,
                                    'minions': ['minion1'],
                                    'result': True
                                })

                    self.assertDictEqual(schedule.move('job3', 'minion1'), {
                        'comment': 'Job job3 does not exist.',
                        'result': False
                    })

        mock = MagicMock(side_effect=[{}, {'job1': {}}])
        with patch.dict(schedule.__opts__, {
                'schedule': mock,
                'sock_dir': SOCK_DIR
        }):
            mock = MagicMock(return_value=True)
            with patch.dict(schedule.__salt__, {'event.fire': mock}):
                _ret_value = {'complete': True, 'schedule': {'job1': JOB1}}
                with patch.object(SaltEvent,
                                  'get_event',
                                  return_value=_ret_value):
                    with patch.dict(schedule.__pillar__,
                                    {'schedule': {
                                        'job1': JOB1
                                    }}):
                        mock = MagicMock(return_value={})
                        with patch.dict(schedule.__salt__,
                                        {'publish.publish': mock}):
                            self.assertDictEqual(
                                schedule.move('job1', 'minion1'), {
                                    'comment': comm1,
                                    'result': True
                                })

                        mock = MagicMock(return_value={'minion1': ''})
                        with patch.dict(schedule.__salt__,
                                        {'publish.publish': mock}):
                            self.assertDictEqual(
                                schedule.move('job1', 'minion1'), {
                                    'comment': comm2,
                                    'minions': ['minion1'],
                                    'result': True
                                })

                        mock = MagicMock(return_value={'minion1': 'job1'})
                        with patch.dict(schedule.__salt__,
                                        {'publish.publish': mock}):
                            mock = MagicMock(return_value=True)
                            with patch.dict(schedule.__salt__,
                                            {'event.fire': mock}):
                                self.assertDictEqual(
                                    schedule.move('job1', 'minion1'), {
                                        'comment': comm3,
                                        'minions': ['minion1'],
                                        'result': True
                                    })
Ejemplo n.º 2
0
    def test_move(self):
        """
        Test if it move scheduled job to another minion or minions.
        """
        comm1 = "no servers answered the published schedule.add command"
        comm2 = "the following minions return False"
        comm3 = "Moved Job job1 from schedule."
        with patch.dict(
            schedule.__opts__, {"schedule": {"job1": JOB1}, "sock_dir": self.sock_dir}
        ):
            mock = MagicMock(return_value=True)
            with patch.dict(schedule.__salt__, {"event.fire": mock}):
                _ret_value = {"complete": True, "schedule": {"job1": JOB1}}
                with patch.object(SaltEvent, "get_event", return_value=_ret_value):
                    mock = MagicMock(return_value={})
                    with patch.dict(schedule.__salt__, {"publish.publish": mock}):
                        self.assertDictEqual(
                            schedule.move("job1", "minion1"),
                            {"comment": comm1, "result": True},
                        )

                    mock = MagicMock(return_value={"minion1": ""})
                    with patch.dict(schedule.__salt__, {"publish.publish": mock}):
                        self.assertDictEqual(
                            schedule.move("job1", "minion1"),
                            {"comment": comm2, "minions": ["minion1"], "result": True},
                        )

                    mock = MagicMock(return_value={"minion1": "job1"})
                    with patch.dict(schedule.__salt__, {"publish.publish": mock}):
                        mock = MagicMock(return_value=True)
                        with patch.dict(schedule.__salt__, {"event.fire": mock}):
                            self.assertDictEqual(
                                schedule.move("job1", "minion1"),
                                {
                                    "comment": comm3,
                                    "minions": ["minion1"],
                                    "result": True,
                                },
                            )

                    self.assertDictEqual(
                        schedule.move("job3", "minion1"),
                        {"comment": "Job job3 does not exist.", "result": False},
                    )

        mock = MagicMock(side_effect=[{}, {"job1": {}}])
        with patch.dict(
            schedule.__opts__, {"schedule": mock, "sock_dir": self.sock_dir}
        ):
            mock = MagicMock(return_value=True)
            with patch.dict(schedule.__salt__, {"event.fire": mock}):
                _ret_value = {"complete": True, "schedule": {"job1": JOB1}}
                with patch.object(SaltEvent, "get_event", return_value=_ret_value):
                    with patch.dict(schedule.__pillar__, {"schedule": {"job1": JOB1}}):
                        mock = MagicMock(return_value={})
                        with patch.dict(schedule.__salt__, {"publish.publish": mock}):
                            self.assertDictEqual(
                                schedule.move("job1", "minion1"),
                                {"comment": comm1, "result": True},
                            )

                        mock = MagicMock(return_value={"minion1": ""})
                        with patch.dict(schedule.__salt__, {"publish.publish": mock}):
                            self.assertDictEqual(
                                schedule.move("job1", "minion1"),
                                {
                                    "comment": comm2,
                                    "minions": ["minion1"],
                                    "result": True,
                                },
                            )

                        mock = MagicMock(return_value={"minion1": "job1"})
                        with patch.dict(schedule.__salt__, {"publish.publish": mock}):
                            mock = MagicMock(return_value=True)
                            with patch.dict(schedule.__salt__, {"event.fire": mock}):
                                self.assertDictEqual(
                                    schedule.move("job1", "minion1"),
                                    {
                                        "comment": comm3,
                                        "minions": ["minion1"],
                                        "result": True,
                                    },
                                )
Ejemplo n.º 3
0
    def test_move(self):
        '''
        Test if it move scheduled job to another minion or minions.
        '''
        comm1 = 'no servers answered the published schedule.add command'
        comm2 = 'the following minions return False'
        comm3 = 'Moved Job job1 from schedule.'
        with patch.dict(schedule.__opts__, {'schedule': {'job1': JOB1}, 'sock_dir': SOCK_DIR}):
            mock = MagicMock(return_value=True)
            with patch.dict(schedule.__salt__, {'event.fire': mock}):
                _ret_value = {'complete': True, 'schedule': {'job1': JOB1}}
                with patch.object(SaltEvent, 'get_event', return_value=_ret_value):
                    mock = MagicMock(return_value={})
                    with patch.dict(schedule.__salt__, {'publish.publish': mock}):
                        self.assertDictEqual(schedule.move('job1', 'minion1'),
                                             {'comment': comm1, 'result': True})

                    mock = MagicMock(return_value={'minion1': ''})
                    with patch.dict(schedule.__salt__, {'publish.publish': mock}):
                        self.assertDictEqual(schedule.move('job1', 'minion1'),
                                             {'comment': comm2, 'minions': ['minion1'],
                                              'result': True})

                    mock = MagicMock(return_value={'minion1': 'job1'})
                    with patch.dict(schedule.__salt__, {'publish.publish': mock}):
                        mock = MagicMock(return_value=True)
                        with patch.dict(schedule.__salt__, {'event.fire': mock}):
                            self.assertDictEqual(schedule.move('job1', 'minion1'),
                                                 {'comment': comm3,
                                                  'minions': ['minion1'],
                                                  'result': True})

                    self.assertDictEqual(schedule.move('job3', 'minion1'),
                                         {'comment': 'Job job3 does not exist.',
                                          'result': False})

        mock = MagicMock(side_effect=[{}, {'job1': {}}])
        with patch.dict(schedule.__opts__, {'schedule': mock, 'sock_dir': SOCK_DIR}):
            mock = MagicMock(return_value=True)
            with patch.dict(schedule.__salt__, {'event.fire': mock}):
                _ret_value = {'complete': True, 'schedule': {'job1': JOB1}}
                with patch.object(SaltEvent, 'get_event', return_value=_ret_value):
                    with patch.dict(schedule.__pillar__, {'schedule': {'job1': JOB1}}):
                        mock = MagicMock(return_value={})
                        with patch.dict(schedule.__salt__, {'publish.publish': mock}):
                            self.assertDictEqual(schedule.move('job1', 'minion1'),
                                                 {'comment': comm1,
                                                  'result': True})

                        mock = MagicMock(return_value={'minion1': ''})
                        with patch.dict(schedule.__salt__, {'publish.publish': mock}):
                            self.assertDictEqual(schedule.move('job1', 'minion1'),
                                                 {'comment': comm2,
                                                  'minions': ['minion1'],
                                                  'result': True})

                        mock = MagicMock(return_value={'minion1': 'job1'})
                        with patch.dict(schedule.__salt__, {'publish.publish': mock}):
                            mock = MagicMock(return_value=True)
                            with patch.dict(schedule.__salt__, {'event.fire': mock}):
                                self.assertDictEqual(schedule.move('job1', 'minion1'),
                                                     {'comment': comm3,
                                                      'minions': ['minion1'],
                                                      'result': True})