Python mock.call函数代码示例

 def test_display(self, call):
     for action in self.actions:
         self.display.progress(self.pkg, action, 0, 100, 1, 1000)
         msg = self.display._fmt_event(self.pkg, action, 1, 1000)
         # updating plymouth display means two plymouth calls
         call.assert_has_calls([
             mock.call((PLYMOUTH, "system-update", "--progress", "0")),
             mock.call((PLYMOUTH, "display-message", "--text", msg))
         ], any_order=True)

 def test_setup_from_dnf_conf(self, setup_m):
     conf = mock.Mock(debuglevel=2, errorlevel=2, logdir=self.logdir)
     self.logging._setup_from_dnf_conf(conf)
     self.assertEqual(setup_m.call_args, mock.call(dnf.logging.INFO,
                                                   dnf.logging.WARNING,
                                                   self.logdir))
     conf = mock.Mock(debuglevel=6, errorlevel=6, logdir=self.logdir)
     self.logging._setup_from_dnf_conf(conf)
     self.assertEqual(setup_m.call_args, mock.call(dnf.logging.DEBUG,
                                                   dnf.logging.WARNING,
                                                   self.logdir))

    def test_filter_calls(self, call):
        action = PKG_INSTALL
        # first display update -> set percentage and text
        self.display.progress(self.pkg, action, 0, 100, 1, 1000)
        msg1 = self.display._fmt_event(self.pkg, action, 1, 1000)
        call.assert_has_calls([
            mock.call((PLYMOUTH, "system-update", "--progress", "0")),
            mock.call((PLYMOUTH, "display-message", "--text", msg1)),
        ])

        # event progress on the same transaction item.
        # no new calls to plymouth because the percentage and text don't change
        for te_cur in range(1, 100):
            self.display.progress(self.pkg, action, te_cur, 100, 1, 1000)
        call.assert_has_calls([
            mock.call((PLYMOUTH, "system-update", "--progress", "0")),
            mock.call((PLYMOUTH, "display-message", "--text", msg1)),
        ])

        # new item: new message ("[2/1000] ..."), but percentage still 0..
        self.display.progress(self.pkg, action, 0, 100, 2, 1000)
        # old message hidden, new message displayed. no new percentage.
        msg2 = self.display._fmt_event(self.pkg, action, 2, 1000)
        call.assert_has_calls([
            mock.call((PLYMOUTH, "system-update", "--progress", "0")),
            mock.call((PLYMOUTH, "display-message", "--text", msg1)),
            mock.call((PLYMOUTH, "hide-message", "--text", msg1)),
            mock.call((PLYMOUTH, "display-message", "--text", msg2)),
        ])

    def test_userconfirm(self, input_fnc):
        # with defaultyes==False
        input_fnc.return_value = 'y'
        self.assertTrue(self.output.userconfirm())
        self.assertEqual(input_fnc.call_args, mock.call(u'Is this ok [y/N]: '))

        input_fnc.return_value = 'n'
        self.assertFalse(self.output.userconfirm())

        input_fnc.return_value = ''
        self.assertFalse(self.output.userconfirm())

        input_fnc.side_effect = self._keyboard_interrupt
        input_fnc.return_value = 'y'
        self.assertFalse(self.output.userconfirm())

        input_fnc.side_effect = self._eof_error
        self.assertFalse(self.output.userconfirm())

        # with defaultyes==True
        self.output.conf.defaultyes = True
        input_fnc.side_effect = None
        input_fnc.return_value = ''
        self.assertTrue(self.output.userconfirm())

        input_fnc.side_effect = self._keyboard_interrupt
        input_fnc.return_value = ''
        self.assertFalse(self.output.userconfirm())

        input_fnc.side_effect = self._eof_error
        self.assertTrue(self.output.userconfirm())

    def test_downgradePkgs_notinstalled(self, logger):
        tests.support.ObjectMatcher(dnf.package.Package, {'name': 'lotus'})

        with self.assertRaises(dnf.exceptions.Error) as ctx:
            self.base.downgradePkgs(('lotus',))
        self.assertEqual(str(ctx.exception), 'No packages marked for downgrade.')

        self.assertEqual(self.base.downgrade_to.mock_calls, [mock.call('lotus', strict=False)])

    def test_close(self):
        """Test close."""
        yum_history = mock.create_autospec(dnf.yum.history.YumHistory)
        history = self._create_wrapper(yum_history)

        history.close()

        self.assertEqual(yum_history.close.mock_calls, [mock.call()])

    def test_downgradePkgs_notinstalled(self):
        pkg = support.ObjectMatcher(dnf.package.Package, {"name": "lotus"})

        with self.assertRaises(dnf.exceptions.Error) as ctx:
            self._base.downgradePkgs(("lotus",))
        self.assertEqual(str(ctx.exception), "Nothing to do.")

        self.assertEqual(self._base.downgrade.mock_calls, [mock.call("lotus")])
        self.assertEqual(self._base.logger.mock_calls, [mock.call.info("No match for available package: %s", pkg)] * 2)

    def test_downgradePkgs_notfound(self):
        with self.assertRaises(dnf.exceptions.Error) as ctx:
            self._base.downgradePkgs(("non-existent",))
        self.assertEqual(str(ctx.exception), "Nothing to do.")

        self.assertEqual(self._base.downgrade.mock_calls, [mock.call("non-existent")])
        self.assertEqual(
            self._base.logger.mock_calls, [mock.call.info("No package %s%s%s available.", "", "non-existent", "")]
        )

    def test_downgradePkgs_notfound(self, logger):
        with self.assertRaises(dnf.exceptions.Error) as ctx:
            self._base.downgradePkgs(('non-existent',))
        self.assertEqual(str(ctx.exception), 'Nothing to do.')

        self.assertEqual(self._base.downgrade.mock_calls,
                         [mock.call('non-existent')])
        self.assertEqual(logger.mock_calls,
                         [mock.call.info('No package %s%s%s available.', '',
                                         'non-existent', '')])

    def test_downgradePkgs_notinstalled(self, logger):
        pkg = support.ObjectMatcher(dnf.package.Package, {'name': 'lotus'})

        with self.assertRaises(dnf.exceptions.Error) as ctx:
            self._base.downgradePkgs(('lotus',))
        self.assertEqual(str(ctx.exception), 'Nothing to do.')

        self.assertEqual(self._base.downgrade_to.mock_calls, [mock.call('lotus')])
        self.assertEqual(logger.mock_calls, [
            mock.call.info('No match for available package: %s', pkg)] * 2)

 def test_update_not_installed(self, logger):
     """ Updating an uninstalled package is a not valid operation. """
     self.base._goal = goal = mock.create_autospec(dnf.goal.Goal)
     # no "mrkite" installed:
     with self.assertRaises(dnf.exceptions.MarkingError) as context:
         self.base.upgrade("mrkite")
     self.assertEqual(logger.mock_calls, [
         mock.call(u'Package %s available, but not installed.', u'mrkite')])
     self.assertEqual(context.exception.pkg_spec, 'mrkite')
     self.assertEqual(goal.mock_calls, [])

    def test_context_manager(self):
        """Test whether _HistoryWrapper can be used as a context manager."""
        yum_history = mock.create_autospec(dnf.yum.history.YumHistory)
        history = self._create_wrapper(yum_history)

        with history as instance:
            pass

        self.assertIs(instance, history)
        self.assertEqual(yum_history.close.mock_calls, [mock.call()])

    def test_downgradePkgs_notfound(self, logger):
        with self.assertRaises(dnf.exceptions.Error) as ctx:
            self.base.downgradePkgs(('non-existent',))
        self.assertEqual(str(ctx.exception), 'No packages marked for downgrade.')

        self.assertEqual(self.base.downgrade_to.mock_calls,
                         [mock.call('non-existent', strict=False)])
        self.assertEqual(logger.mock_calls,
                         [mock.call.info('No package %s available.',
                                         'non-existent')])

 def hidem(m):
     return mock.call((PLYMOUTH, "hide-message", "--text", m))

 def dispm(m):
     return mock.call((PLYMOUTH, "display-message", "--text", m))