Пример #1
0
 def test_languages(self, lang, is_ok):
     if is_ok:
         seconds_to_str(0, language=lang)
     else:
         with pytest.raises(InvalidLanguageError,
                            match=r"'\w+' is not a valid"):
             seconds_to_str(0, language=lang)
Пример #2
0
    def test_invalid_language_error(self):
        expected_match = "'<invalid-language>' is not a valid language"
        with pytest.raises(InvalidLanguageError, match=expected_match):
            seconds_to_str(2, language="<invalid-language>")

        self.jp_m.assert_not_called()
        self.gp_m.assert_not_called()
        self.ss_m.assert_not_called()
Пример #3
0
    def test_type_error(self):
        with pytest.raises(TypeError,
                           match="seconds must be float or int, not complex"):
            seconds_to_str(2 + 5j)

        self.jp_m.assert_not_called()
        self.gp_m.assert_not_called()
        self.ss_m.assert_not_called()
Пример #4
0
    def test_ok(self, langs_m, is_empty):
        self.ss_m.return_value = (10, 20, 30, 40)
        lang = mock.MagicMock()
        langs_m.__getitem__.return_value.__getitem__.return_value = lang
        lang.t = "h"

        if is_empty:
            self.jp_m.return_value = None

        parts = [
            mock.MagicMock(),
            mock.MagicMock(),
            mock.MagicMock(),
            mock.MagicMock(),
            mock.MagicMock(),
        ]
        self.gp_m.side_effect = parts

        seconds_to_str(2)
        langs_m.__getitem__.assert_called_once()
        langs_m.__getitem__.return_value.__getitem__.assert_called_once()

        self.ss_m.assert_called_once()
        self.gp_m.assert_any_call(10, lang.day, lang.s, False)
        self.gp_m.assert_any_call(20, lang.hour, lang.s, False)
        self.gp_m.assert_any_call(30, lang.minute, lang.s, False)
        self.gp_m.assert_any_call(40, lang.second, lang.s, False)
        self.jp_m.assert_called_once_with(lang.join, *parts[:-1])

        if is_empty:
            self.gp_m.assert_any_call(0,
                                      lang.second,
                                      lang.s,
                                      False,
                                      force_output=True)
            assert self.gp_m.call_count == 5
        else:
            assert self.gp_m.call_count == 4
Пример #5
0
 def test_infinite_seconds(self, inf, lang):
     result = seconds_to_str(inf, language=lang)
     assert result == "infinite " + ALPHABET["default"][lang][0] + "s"
Пример #6
0
 def test_integration(self, ss_m, use_abbr, language, time_tuple):
     ss_m.return_value = time_tuple
     expected = SECONDS_TO_STR_TEST_DATA[time_tuple][(use_abbr, language)]
     real = seconds_to_str(0, abbreviated=use_abbr, language=language)
     assert real == expected