def test_sort(self): """Test the normal sort function.""" idx = index.I18NFieldIndex() data = storage.I18NDict({ u'en': u'Title in english', u'es': u'El título', }) idx.doIndex(111, data) data2 = storage.I18NDict({ u'en': u'English words', u'es': u'Título en español', u'de': u'Deutsch', }) idx.doIndex(222, data2) # request language English utils.get_language = lambda: u'en' self.assertEqual(list(idx.sort([111, 222])), [222, 111]) # request language Spanish utils.get_language = lambda: u'es' self.assertEqual(list(idx.sort([111, 222])), [111, 222]) # request language German utils.get_language = lambda: u'de' self.assertEqual(list(idx.sort([111, 222])), [222])
def test_do_index_required(self): """Test that the I18NDict values are indexed properly.""" idx = index.I18NFieldIndex() data = storage.I18NDict({u'en': u'English', u'de': u'Deutsch'}) data.required = True idx.doIndex(111, data) self.assertEqual(len(idx._indices), 5) # number of available langauges # English sub_idx = idx._indices[u'en'] self.assertEqual(sub_idx.documentCount(), 1) self.assertEqual(sub_idx.wordCount(), 1) self.assertIn(u'English', list(sub_idx._rev_index.values())) # Portuguese sub_idx = idx._indices[u'pt'] self.assertEqual(sub_idx.documentCount(), 1) self.assertEqual(sub_idx.wordCount(), 1) self.assertIn(u'English', list(sub_idx._rev_index.values())) data2 = storage.I18NDict({ u'en': u'English with more words', u'es': u'Español con más palabras', u'de': u'Deutsch', }) data2.required = True idx.doIndex(222, data2) self.assertEqual(len(idx._indices), 5) # number of available langauges # English sub_idx = idx._indices[u'en'] self.assertEqual(sub_idx.documentCount(), 2) self.assertEqual(sub_idx.wordCount(), 2) self.assertIn(u'English', list(sub_idx._rev_index.values())) self.assertIn( u'English with more words', list(sub_idx._rev_index.values()), ) # Spanish sub_idx = idx._indices[u'es'] self.assertEqual(sub_idx.documentCount(), 2) self.assertEqual(sub_idx.wordCount(), 2) self.assertIn(u'English', list(sub_idx._rev_index.values())) self.assertIn( u'Español con más palabras', list(sub_idx._rev_index.values()), ) # German sub_idx = idx._indices[u'de'] self.assertEqual(sub_idx.documentCount(), 2) self.assertEqual(sub_idx.wordCount(), 1) self.assertIn(u'Deutsch', list(sub_idx._rev_index.values())) # Portuguese sub_idx = idx._indices[u'pt'] self.assertEqual(sub_idx.documentCount(), 2) self.assertEqual(sub_idx.wordCount(), 2) self.assertIn(u'English', list(sub_idx._rev_index.values())) self.assertIn( u'English with more words', list(sub_idx._rev_index.values()), )
def test_string_representation(self): """Test the __str__ method of the dictionary.""" data = storage.I18NDict() data.default_language = u'es' data.required = True # no request, no values self.assertEqual(str(data), '') # no request - fallback to first value data[u'fr'] = u'French' self.assertEqual(str(data), 'French') # no value for request language - fallback to internal I18nDict default data[u'en'] = u'English' data[u'es'] = u'Español' utils.get_language = lambda: u'pt' self.assertEqual(str(data), u'Español'.encode('utf-8')) # request language Spanish utils.get_language = lambda: u'es' self.assertEqual(str(data), u'Español'.encode('utf-8')) # request language French utils.get_language = lambda: u'fr' self.assertEqual(str(data), 'French') # request language English utils.get_language = lambda: u'en' self.assertEqual(str(data), 'English')
def __set__(self, instance, value): # prepare the values value = self.prepare_dict(value) old_value = getattr(instance, self.__name, None) if old_value is None and isinstance(value, basestring): value = storage.I18NDict.from_text(value) if isinstance(value, storage.I18NDict): validate_dict = value.to_dict() storage_dict = value storage_dict.clear() else: validate_dict = value storage_dict = storage.I18NDict() assert isinstance(validate_dict, dict), 'validate_dict must be dict' assert isinstance(storage_dict, storage.I18NDict), \ 'storage_dict must be I18NDict' # field validation field = self.__field.bind(instance) field.validate(validate_dict) if field.readonly and self.__name in instance.__dict__: raise ValueError(self.__name, u'Field is readonly') # set the new I18nDict storage_dict.default_language = field._default_language storage_dict.required = field.required storage_dict.update(validate_dict) instance.__dict__[self.__name] = storage_dict
def test_default(self): """Test the default value method with a default language set.""" data = storage.I18NDict() data.default_language = u'es' # no values - fallback is None self.assertIsNone(data.get_default_value()) # one value - fallback is the first value found data[u'fr'] = u'French' self.assertEqual(data.get_default_value(), u'French') # two values - fallback comes from global default (ILanguageSettings) data[u'en'] = u'English' self.assertEqual(data.get_default_value(), u'English') # three values - fallback comes from I18nDict default language data[u'es'] = u'Español' self.assertEqual(data.get_default_value(), u'Español') # set to non-existent default language - default from ILanguageSettings data.default_language = u'de' self.assertEqual(data.get_default_value(), u'English') # default comes from global registry # self.assertEqual(data.get_default_value(), u'French') # default comes from I18nDict internally saved default language data.default_language = u'en' self.assertEqual(data.get_default_value(), u'English')
def test_unicode_representation(self): """Test the __unicode__ method of the dictionary.""" data = storage.I18NDict() data.required = True # no request, no values self.assertEqual(unicode(data), u'') # no request - fallback to first value data[u'fr'] = u'French' self.assertEqual(unicode(data), u'French') # no request - fallback to global default (English) data[u'en'] = u'English' data[u'es'] = u'Español' self.assertEqual(unicode(data), u'English') # request language Spanish utils.get_language = lambda: u'es' self.assertEqual(unicode(data), u'Español') # request language French utils.get_language = lambda: u'fr' self.assertEqual(unicode(data), u'French') # request language English utils.get_language = lambda: u'en' self.assertEqual(unicode(data), u'English')
def test_to_text(self): """Test the to_text method.""" data = storage.I18NDict({u'en': u'English', u'de': u'Deutsch'}) self.assertIn(u'English', data.to_text()) self.assertIn(u'Deutsch', data.to_text()) data[u'es'] = u'El texto en español' self.assertIn(u'El texto en español', data.to_text())
def test_add(self): """Test the add method.""" data = storage.I18NDict() data.add(u'de', u'Deutsch') self.assertEqual(len(data), 1) self.assertIn(u'de', data) data.add(u'fake', u'Fake language') self.assertEqual(len(data), 1)
def test_remove(self): """Test the remove method.""" data = storage.I18NDict({u'en': u'English', u'de': u'Deutsch'}) self.assertEqual(len(data), 2) data.remove(u'de') self.assertEqual(len(data), 1) self.assertNotIn(u'de', data) data.remove(u'not') self.assertEqual(len(data), 1)
def test_standard(self): """Test that the dictionary access with no default language.""" data = storage.I18NDict() self.assertIsNone(data.get(u'en')) data[u'en'] = u'English' self.assertEqual(data.get(u'en'), u'English') data[u'es'] = u'Español' self.assertEqual(data.get(u'es'), u'Español') self.assertEqual(len(data.keys()), 2)
def test_to_dict(self): original = storage.I18NDict() original[u'en'] = u'English' original[u'es'] = u'Español' self.assertEqual(len(original), 2) copy = original.to_dict() self.assertEqual(len(copy), 2) self.assertIn(u'en', copy.keys()) self.assertIn(u'Español', copy.values())
def test_do_index(self): """Test that the I18NDict values are indexed properly.""" idx = index.I18NFieldIndex() data = storage.I18NDict({u'en': u'English', u'de': u'Deutsch'}) idx.doIndex(111, data) self.assertEqual(len(idx._indices), 2) # English sub_idx = idx._indices[u'en'] self.assertEqual(sub_idx.documentCount(), 1) self.assertEqual(sub_idx.wordCount(), 1) data2 = storage.I18NDict({ u'en': u'English with more words', u'es': u'Español con más palabras', u'de': u'Deutsch', }) idx.doIndex(222, data2) self.assertEqual(len(idx._indices), 3) # English sub_idx = idx._indices[u'en'] self.assertEqual(sub_idx.documentCount(), 2) self.assertEqual(sub_idx.wordCount(), 2) self.assertIn(u'English', list(sub_idx._rev_index.values())) self.assertIn( u'English with more words', list(sub_idx._rev_index.values()), ) # Spanish sub_idx = idx._indices[u'es'] self.assertEqual(sub_idx.documentCount(), 1) self.assertEqual(sub_idx.wordCount(), 1) self.assertIn( u'Español con más palabras', list(sub_idx._rev_index.values()), ) # German sub_idx = idx._indices[u'de'] self.assertEqual(sub_idx.documentCount(), 2) self.assertEqual(sub_idx.wordCount(), 1) self.assertIn(u'Deutsch', list(sub_idx._rev_index.values()))
def test_set_item(self): """Test the checks from __setitem__ method.""" data = storage.I18NDict() data[u'fr'] = u'French' self.assertIn(u'fr', data) data[u'__default_value'] = u'Default value' self.assertIn(u'Default value', data.values()) data[u'non-existent'] = u'Invalid' self.assertEqual(len(data), 2) data[u'en'] = u'' self.assertEqual(len(data), 2) self.assertNotIn(u'en', data)
def test_copy(self): original = storage.I18NDict() original.default_language = u'es' original.required = True original[u'en'] = u'English' original[u'es'] = u'Español' self.assertEqual(len(original), 2) copy = original.copy() self.assertEqual(len(copy), 2) self.assertIn(u'es', copy.keys()) self.assertIn(u'English', copy.values()) self.assertEqual(copy.default_language, original.default_language) self.assertEqual(copy.required, original.required)
def test_not_required(self): """Test the __unicode__ method without a required field.""" data = storage.I18NDict() data.default_language = u'es' data.required = False data[u'fr'] = u'French' data[u'de'] = u'German' data[u'es'] = u'Español' # no request, no value for default language 'en' self.assertEqual(unicode(data), u'') # with required data.required = True self.assertEqual(unicode(data), u'Español')
def test_no_default(self): """Test the default value method with no default langauge set.""" data = storage.I18NDict() # no values - default is None self.assertIsNone(data.get_default_value()) # one value - fallback is first value found data[u'fr'] = u'French' self.assertEqual(data.get_default_value(), u'French') # two values - global registry default is used data[u'en'] = u'English' self.assertEqual(data.get_default_value(), u'English') # three values - global registry default is still used data[u'es'] = u'Español' self.assertEqual(data.get_default_value(), u'English')
def test_nonzero_required(self): """Test the __nonzero__ method.""" data = storage.I18NDict() data.required = True # no request, no values self.assertFalse(bool(data)) # no request - fallback to first value found data[u'fr'] = u'Français' self.assertTrue(bool(data)) # no request - fallback to first value found data[u'es'] = u'Español' self.assertTrue(bool(data)) # no request - with a value for default language data[u'en'] = u'English' self.assertTrue(bool(data))
def test_update(self): """Test the update method.""" data = storage.I18NDict({u'en': u'English', u'invalid': u'blah'}) self.assertEqual(len(data), 1) self.assertIn(u'en', data) data.update({ u'es': u'Español', u'fr': u'François', u'fake': u'Non-value', }) self.assertEqual(len(data), 3) self.assertIn(u'Español', data.values()) self.assertIn(u'François', data.values()) data.update([ (u'de', u'Deutsch'), (u'pt', u'Português'), (u'slang', u'Jibber jabber'), ]) self.assertEqual(len(data), 5) self.assertIn(u'de', data.keys()) self.assertIn(u'pt', data.keys())