mstranslator/tests.py at master · wronglink/mstranslator · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import os
try:
    import unittest2 as unittest
except ImportError:
    import unittest
try:
    from StringIO import StringIO
except ImportError:
    # Python 3
    from io import BytesIO as StringIO

from mstranslator import AccessToken, AccessError, Translator, ArgumentOutOfRangeException
import requests

SUBSCRIPTION_KEY = os.environ['TEST_MSTRANSLATOR_SUBSCRIPTION_KEY']


class TranslatorMock(Translator):
    """
    A Translator mock that returns url on `.make_request()` method call without
    making a real HTTP request.
    """
    def make_request(self, action, params=None):
        prepped = requests.Request('GET',
                                   url=self.make_url(action),
                                   params=params).prepare()
        return prepped.url

class AccessTokenTestCase(unittest.TestCase):
    def test_access(self):
        at = AccessToken(SUBSCRIPTION_KEY)
        assert at.token

    def test_access_denied(self):
        at = AccessToken("AN_INVALID_SUBSCRIPTION_KEY")
        self.assertRaises(AccessError, at.request_token)


class TranslatorTestCase(unittest.TestCase):
    def setUp(self):
        self.translator = Translator(SUBSCRIPTION_KEY)
        self.translator_mock = TranslatorMock(SUBSCRIPTION_KEY)

    def test_translate(self):
        t = self.translator.translate('world', 'en', 'ru')
        self.assertEqual('мир', t)

    def test_translate_exception(self):
        self.assertRaises(ArgumentOutOfRangeException, self.translator.translate, 'world', 'en', 'asdf')

    def test_translate_array(self):
        ts = self.translator.translate_array(['hello', 'world'], 'en', 'ru')
        translations = [t['TranslatedText'] for t in ts]
        self.assertEqual(['Привет', 'мир'], translations)

    def test_translate_array2(self):
        ts = self.translator.translate_array2(['hello', 'world', 'Hello. How are you?'], 'en', 'ru')
        translations = [t['TranslatedText'] for t in ts]
        self.assertEqual(['Привет', 'мир', 'Привет. Как ваши дела?'], translations)
        alignments = [t['Alignment'] for t in ts]
        self.assertEqual(['0:4-0:5', '0:4-0:2', '0:5-0:6 7:18-8:21'], alignments)

    def test_get_translations(self):
        t = self.translator.get_translations('world', 'en', 'ru')
        self.assertIsInstance(t, dict)
        self.assertIn('Translations', t)

    def test_break_sentences(self):
        t = self.translator.break_sentences('Hello. How are you?', 'en')
        self.assertEqual(['Hello. ', 'How are you?'], t)

    def test_add_translation(self):
        url = self.translator_mock.add_translation('orig', 'trans', 'en', 'ru', user='test')
        self.assertIn('originalText=orig', url)
        self.assertIn('translatedText=trans', url)

    def test_get_langs(self):
        langs = self.translator.get_langs()
        self.assertIsInstance(langs, list)
        self.assertIn('en', langs)

    def test_get_lang_names(self):
        lang_names = self.translator.get_lang_names(['ru', 'en'], 'en')
        self.assertEqual(['Russian', 'English'], lang_names)

    def test_get_speackable_langs(self):
        langs = self.translator.get_langs(speakable=True)
        self.assertIsInstance(langs, list)
        self.assertIn('en-us', langs)

    def test_detect_lang(self):
        self.assertEqual('en', self.translator.detect_lang('Hello'))

    def test_detect_langs(self):
        self.assertEqual(['en', 'ru'], self.translator.detect_langs(['Hello', 'Привет']))

    def test_speak(self):
        self.assertIsNotNone(self.translator.speak('Hello', 'en'))

    def test_speak_to_file(self):
        s = StringIO()
        self.translator.speak_to_file(s, 'Hello', 'en')
        s.seek(0)
        self.assertTrue(len(s.read()) > 0)