def test_game_state_localized(self):
settings.change('language', 'Spanish')
game_state_test = game_state.GameState(self.log)
game_state_test.force_zero_map_time = True
game_state_test.set_bulk(
(False, 'ctf_mexico_b4', 'Engineer', '', 'Not queued', True))
self.assertTrue(game_state_test.update_rpc)
self.assertEqual(
str(game_state_test),
'Engineer on ctf_mexico_b4, gamemode=ctf, hosting=True, queued="Not queued", server='
)
self.assertEqual(
fix_activity_dict(game_state_test.activity()), {
'details': 'Mapa: ctf_mexico_b4 (alojamiento)',
'state': 'El tiempo en el mapa: 0:00',
'timestamps': {
'start': 0
},
'assets': {
'large_image': 'ctf',
'large_text':
'Capturar la Bandera - TF2 Presencia Rica {tf2rpvnum}',
'small_image': 'engineer',
'small_text': 'Engineer'
}
})
self.assertTrue(game_state_test.update_rpc)
def test_get_match_info(self):
test_game_state = game_state.GameState(self.log)
test_addresses = (
'162.254.192.155:27053', # valve
'dal-1.us.uncletopia.com:27025',
'chi.servers.creators.tf:27015',
'192.223.26.238:27017', # lazypurple
'45.35.1.186:27065') # blackwonder
for test_address in test_addresses:
try:
server_data = test_game_state.get_match_data(
test_address, ['Server name', 'Player count', 'Kills'],
allow_network_errors=False)
self.assertTrue(
server_data['player_count'].startswith("Players: "))
self.assertIn(server_data['player_count'].split('/')[1],
('24', '26', '30', '32'))
self.assertEqual(server_data['kills'], "Kills: 0")
if "Valve" in server_data['server_name']:
self.assertEqual(server_data['server_name'],
"Valve Matchmaking Server (Virginia)")
except Exception as error:
raise AssertionError(f'{test_address}, {repr(error)}')
settings.change('request_timeout', 0.001)
self.assertEqual(
test_game_state.get_match_data(
test_addresses[-1], ['Server name', 'Player count', 'Kills']),
server_data)
self.assertEqual(test_game_state.get_match_data('', ['Player count']),
{'player_count': 'Players: ?/?'})
def test_custom(self):
settings.change('wait_time_slow', 1)
big_number_file = f'test_{random.randint(10000, 99999)}.temp'
with open('custom.py', 'r+') as custom_file:
custom_old = custom_file.read()
custom_file.seek(0)
custom_file.truncate()
custom_file.write(
"class TF2RPCustom:"
"\n\tdef __init__(self, app): pass"
"\n\tdef before_loop(self, app): pass"
"\n\tdef modify_game_state(self, app): pass"
"\n\tdef modify_gui(self, app): pass"
"\n\tdef modify_rpc_activity(self, app): pass"
f"\n\tdef after_loop(self, app): open('{big_number_file}', 'w').close()"
)
custom_file.flush()
app = main.TF2RichPresense(self.log, set_process_priority=False)
app.loop_body()
app.gui.master.destroy()
self.assertTrue(os.path.isfile(big_number_file))
time.sleep(0.2)
for file in os.listdir():
if file.startswith('test_') and file.endswith('.temp'):
os.remove(file)
with open('custom.py', 'r+') as custom_file:
custom_file.truncate()
custom_file.write(custom_old)
def test_black_listing(self):
self.assertEquals(False, access.is_page_blacklisted('Welcome'))
settings.change({'page-blacklist': '^Wel.*'})
self.assertEquals(True, access.is_page_blacklisted('Welcome'))
settings.change({'page-whitelist': '.*come$'})
self.assertEquals(False, access.is_page_blacklisted('Welcome'),
'White listing does not beat blacklisting.')
def test_admin_edits(self):
settings.change({
'open-editing': 'no',
'page-blacklist': '.*',
'parents-must-exist': 'yes'
})
self.assertEquals(access.can_edit_page('foo/bar'), False)
self.assertEquals(access.can_edit_page('foo/bar', is_admin=True), True)
def setUp(self):
settings.access_registry(
save=settings.defaults()) # sorry if this changes your settings
settings.change('request_timeout', 30)
self.dir = os.getcwd()
self.log = logger.Log('logs\\tests.log')
self.log.force_disabled = True
self.log.to_stderr = False
self.log.sentry_enabled = False
self.log.info(f"Starting test: {self.id()}")
gc.enable() # because main may have disabled it
def test_access_to_special_pages(self):
user = users.User('*****@*****.**')
settings.change({
'open-reading': None,
'readers': None,
'editors': None
})
self.assertEquals(access.can_see_most_pages(user, False), True)
settings.change({
'open-reading': 'no',
'readers': None,
'editors': None
})
self.assertEquals(access.can_see_most_pages(user, False), False)
settings.change({
'open-reading': 'no',
'readers': user.email(),
'editors': None
})
self.assertEquals(access.can_see_most_pages(user, False), True)
settings.change({
'open-reading': 'no',
'readers': None,
'editors': user.email()
})
self.assertEquals(access.can_see_most_pages(user, False), True)
def test_set_gui_from_game_state_localized(self):
settings.change('language', 'German')
app = main.TF2RichPresense(self.log, set_process_priority=False)
app.game_state.force_zero_map_time = True
app.game_state.set_bulk((False, 'mvm_rottenburg', 'Medic', '',
'Queued for MvM (Boot Camp)', True))
app.game_state.update_server_data(['Player count'], set())
app.set_gui_from_game_state()
self.assertEqual((app.gui.text_state, app.gui.bg_state,
app.gui.fg_state, app.gui.class_state),
(('Karte: Rottenburg (Hosting)', 'Spieler: ?/?',
'Zeit auf der Karte: 0:00', '0:00 verstrichen'),
('bg_modes/mvm', 77,
172), 'fg_maps/mvm_rottenburg', 'classes/medic'))
self.assertEqual(app.gui.bottom_text_queue_state,
"Warteschlange für MvM (Boot Camp)")
app.gui.master.destroy()
def test_main_simple(self):
settings.change('wait_time_slow', 1)
app = main.TF2RichPresense(self.log)
self.assertEqual(repr(app), 'main.TF2RichPresense (state=init)')
self.assertEqual(
fix_activity_dict(app.game_state.activity()), {
'details': 'In menus',
'state': 'Not queued',
'timestamps': {
'start': 0
},
'assets': {
'large_image': 'main_menu',
'large_text': 'In menus - TF2 Rich Presence {tf2rpvnum}',
'small_image': 'tf2_logo',
'small_text': 'Team Fortress 2'
}
})
app.loop_body()
app.gui.safe_update()
self.assertEqual(repr(app), 'main.TF2RichPresense (state=no tf2)')
self.assertEqual(
fix_activity_dict(app.game_state.activity()), {
'details': 'In menus',
'state': 'Not queued',
'timestamps': {
'start': 0
},
'assets': {
'large_image': 'main_menu',
'large_text': 'In menus - TF2 Rich Presence {tf2rpvnum}',
'small_image': 'tf2_logo',
'small_text': 'Team Fortress 2'
}
})
self_process = psutil.Process()
self.assertEqual(self_process.nice(),
psutil.BELOW_NORMAL_PRIORITY_CLASS)
self.assertEqual(self_process.ionice(), psutil.IOPRIO_LOW)
self_process.nice(psutil.NORMAL_PRIORITY_CLASS)
self_process.ionice(psutil.IOPRIO_NORMAL)
app.send_rpc_activity()
def test_logger(self):
self.log.log_file.close()
try:
os.remove(self.log.filename)
except (FileNotFoundError, PermissionError):
pass
self.log.force_disabled = False
self.log.filename = 'test_resources\\test_self.log'
try:
os.remove(self.log.filename)
except (FileNotFoundError, PermissionError):
pass
self.log.log_file = open(self.log.filename, 'a', encoding='UTF8')
self.log.info("Test1 饏ӞR៣1ࠞͳⴺۋ")
self.log.error(str(SystemError("Test2")), reportable=False)
self.assertEqual(
repr(self.log),
r'logger.Log at test_resources\test_self.log (enabled=True, level=Debug, stderr=False)'
)
settings.change('log_level', 'Error')
self.log.debug("Gone. Reduced to atoms.")
settings.change('log_level', 'Off')
self.assertFalse(self.log.enabled())
self.log.log_file.close()
with open(self.log.filename, 'r', encoding='UTF8') as current_log_file:
current_log_file_read = current_log_file.readlines()
self.assertEqual(len(current_log_file_read), 2)
self.assertTrue(current_log_file_read[0].endswith(
"] INFO: Test1 饏ӞR៣1ࠞͳⴺۋ\n"))
self.assertTrue(
current_log_file_read[1].endswith("] ERROR: Test2\n"))
with self.assertRaises(IndexError):
should_be_empty = current_log_file_read[2]
os.remove(self.log.filename)
def test_access_to_special_pages(self):
user = users.User('*****@*****.**')
settings.change({'open-reading': None, 'readers': None, 'editors': None})
self.assertEquals(access.can_see_most_pages(user, False), True)
settings.change({'open-reading': 'no', 'readers': None, 'editors': None})
self.assertEquals(access.can_see_most_pages(user, False), False)
settings.change({'open-reading': 'no', 'readers': user.email(), 'editors': None})
self.assertEquals(access.can_see_most_pages(user, False), True)
settings.change({'open-reading': 'no', 'readers': None, 'editors': user.email()})
self.assertEquals(access.can_see_most_pages(user, False), True)
def detect_system_language(log: logger.Log):
db: Dict[str, Union[bool, list, str]] = utils.access_db()
if not db['has_asked_language']:
language_codes: dict = {
read_localization_files()[lang]['code']: lang
for lang in langs[1:]
}
system_locale: str = locale.windows_locale[
ctypes.windll.kernel32.GetUserDefaultUILanguage()]
system_language_code: str = system_locale.split('_')[0]
is_brazilian_port: bool = system_locale == 'pt_BR'
if system_language_code in language_codes or is_brazilian_port:
system_language: str = language_codes[system_language_code]
can_localize: bool = True
else:
if system_language_code != 'en':
log.error(f"System locale {system_locale} is not localizable")
can_localize = False
if can_localize and settings.get('language') != system_language:
log.info(
f"System language ({system_locale}, {system_language}) != settings language ({settings.get('language')}), asking to change"
)
db['has_asked_language'] = True
utils.access_db(db)
system_language_display: str = 'Português Brasileiro' if is_brazilian_port else system_language
# this is intentionally not localized
changed_language: str = messagebox.askquestion(
f"TF2 Rich Presence {launcher.VERSION}",
f"Change language to your system's default ({system_language_display})?"
)
log.debug(f"Changed language: {changed_language}")
if changed_language == 'yes':
settings.change('language', system_language)
def test_logged_in_page_editing(self):
alice = users.User('*****@*****.**')
settings.change({'open-editing': 'no'})
self.assertFalse(access.can_edit_page("some page", user=None))
self.assertFalse(access.can_edit_page("some page", user=alice))
settings.change({'open-editing': 'yes'})
self.assertTrue(access.can_edit_page("some page", user=None))
self.assertTrue(access.can_edit_page("some page", user=alice))
settings.change({'open-editing': 'login'})
self.assertFalse(access.can_edit_page("some page", user=None))
self.assertTrue(access.can_edit_page("some page", user=alice))
def test_logged_in_page_editing(self):
alice = users.User('*****@*****.**')
settings.change({'open-editing': 'no'})
self.assertFalse(access.can_edit_page("some page", user=None))
self.assertFalse(access.can_edit_page("some page", user=alice))
settings.change({'open-editing': 'yes'})
self.assertTrue(access.can_edit_page("some page", user=None))
self.assertTrue(access.can_edit_page("some page", user=alice))
settings.change({'open-editing': 'login'})
self.assertFalse(access.can_edit_page("some page", user=None))
self.assertTrue(access.can_edit_page("some page", user=alice))
def test_open_editing(self):
self.assertEquals(access.can_edit_page('foo'), False)
settings.change({'open-editing': 'yes'})
self.assertEquals(access.can_edit_page('foo'), True)
settings.change({'page-blacklist': '^foo'})
self.assertEquals(access.can_edit_page('foo'), False)
def test_black_listing(self):
self.assertEquals(False, access.is_page_blacklisted('Welcome'))
settings.change({'page-blacklist': '^Wel.*'})
self.assertEquals(True, access.is_page_blacklisted('Welcome'))
settings.change({'page-whitelist': '.*come$'})
self.assertEquals(False, access.is_page_blacklisted('Welcome'), 'White listing does not beat blacklisting.')
def test_white_listing(self):
self.assertEquals(False, access.is_page_whitelisted('Welcome'))
settings.change({'page-whitelist': '^Wel.*'})
self.assertEquals(True, access.is_page_whitelisted('Welcome'))
def test_list_changes_in_closed_wiki(self):
settings.change({"open-reading": "yes", "open-writing": "yes"})
self.assertTrue(isinstance(model.WikiContent.get_changes(), list))
settings.change({"open-reading": "no", "open-writing": "no"})
self.assertTrue(isinstance(model.WikiContent.get_changes(), list))
def test_list_changes_in_closed_wiki(self):
settings.change({"open-reading": "yes", "open-writing": "yes"})
self.assertTrue(isinstance(model.WikiContent.get_changes(), list))
settings.change({"open-reading": "no", "open-writing": "no"})
self.assertTrue(isinstance(model.WikiContent.get_changes(), list))
def test_admin_edits(self):
settings.change({'open-editing': 'no', 'page-blacklist': '.*', 'parents-must-exist': 'yes'})
self.assertEquals(access.can_edit_page('foo/bar'), False)
self.assertEquals(access.can_edit_page('foo/bar', is_admin=True), True)
def test_edit_orphan_page(self):
settings.change({'open-editing': 'yes'})
self.assertEquals(access.can_edit_page('foo/bar'), True)
settings.change({'parents-must-exist': 'yes'})
self.assertEquals(access.can_edit_page('foo/bar'), False)
def test_editor_access(self):
user = users.User('*****@*****.**')
self.assertEquals(access.can_edit_page('foo'), False)
self.assertEquals(access.can_edit_page('foo', user), False)
settings.change({'editors': user.email()})
self.assertEquals(access.can_edit_page('foo', user), True)
def test_edit_locked_page(self):
"""Make sure that locked pages aren't editable."""
model.WikiContent(title='foo', body='locked: yes\n---\n# foo').put()
settings.change({'open-editing': 'yes', 'open-reading': 'yes'})
self.assertEquals(access.can_edit_page('foo', is_admin=False), False)
def test_edit_orphan_page(self):
settings.change({'open-editing': 'yes'})
self.assertEquals(access.can_edit_page('foo/bar'), True)
settings.change({'parents-must-exist': 'yes'})
self.assertEquals(access.can_edit_page('foo/bar'), False)
def test_editor_access(self):
user = users.User('*****@*****.**')
self.assertEquals(access.can_edit_page('foo'), False)
self.assertEquals(access.can_edit_page('foo', user), False)
settings.change({'editors': user.email()})
self.assertEquals(access.can_edit_page('foo', user), True)
def test_white_listing(self):
self.assertEquals(False, access.is_page_whitelisted('Welcome'))
settings.change({'page-whitelist': '^Wel.*'})
self.assertEquals(True, access.is_page_whitelisted('Welcome'))
def test_edit_locked_page(self):
"""Make sure that locked pages aren't editable."""
model.WikiContent(title='foo', body='locked: yes\n---\n# foo').put()
settings.change({'open-editing': 'yes', 'open-reading': 'yes'})
self.assertEquals(access.can_edit_page('foo', is_admin=False), False)
def test_open_editing(self):
self.assertEquals(access.can_edit_page('foo'), False)
settings.change({'open-editing': 'yes'})
self.assertEquals(access.can_edit_page('foo'), True)
settings.change({'page-blacklist': '^foo'})
self.assertEquals(access.can_edit_page('foo'), False)
def test_page_reading(self):
user = users.User('*****@*****.**')
# Unknown user, default access.
settings.change({'open-reading': None, 'readers': None, 'editors': None})
self.assertEquals(access.can_read_page('foo', user, False), True)
# Unknown user, private wiki.
settings.change({'open-reading': 'no'})
self.assertEquals(access.can_read_page('foo', user, False), False)
# A privilaged reader, private wiki.
settings.change({'open-reading': 'no', 'readers': user.email(), 'editors': None})
self.assertEquals(access.can_read_page('foo', user, False), True)
# A privilaged editor, private wiki.
settings.change({'open-reading': 'no', 'readers': None, 'editors': user.email()})
self.assertEquals(access.can_read_page('foo', user, False), True)
page = model.WikiContent(title='foo')
# An unknown user, a private wiki and a public page.
settings.change({'open-reading': 'no', 'readers': None, 'editors': None})
page.body = 'public: yes\n---\n# foo'
page.put()
self.assertEquals(access.can_read_page('foo', user, False), True)
# An unknown user, an open wiki and a private page.
settings.change({'open-reading': 'yes', 'readers': None, 'editors': None})
page.body = 'private: yes\n---\n# foo'
page.put()
self.assertEquals(access.can_read_page('foo', user, False), False)
# An open wiki, a private page with explicit access to some regular user.
settings.change({'open-reading': 'yes', 'readers': None, 'editors': None})
page.body = 'private: yes\nreaders: %s\n---\n# foo' % user.email()
page.put()
self.assertEquals(access.can_read_page('foo', user, False), True)
def test_game_state(self):
game_state_test = game_state.GameState(self.log)
game_state_test.force_zero_map_time = True
self.assertTrue(game_state_test.update_rpc)
self.assertEqual(str(game_state_test), 'in menus, queued="Not queued"')
game_state_test.set_bulk((True, '', '', '', 'Not queued', False))
self.assertTrue(game_state_test.update_rpc)
self.assertEqual(str(game_state_test), 'in menus, queued="Not queued"')
self.assertEqual(
fix_activity_dict(game_state_test.activity()), {
'details': 'In menus',
'state': 'Not queued',
'timestamps': {
'start': 0
},
'assets': {
'large_image': 'main_menu',
'large_text': 'In menus - TF2 Rich Presence {tf2rpvnum}',
'small_image': 'tf2_logo',
'small_text': 'Team Fortress 2'
}
})
self.assertFalse(game_state_test.update_rpc)
game_state_test.set_bulk(
(False, 'koth_highpass', 'Demoman', '', 'Not queued', True))
self.assertTrue(game_state_test.update_rpc)
self.assertEqual(
str(game_state_test),
'Demoman on Highpass, gamemode=koth, hosting=True, queued="Not queued", server='
)
self.assertEqual(
fix_activity_dict(game_state_test.activity()), {
'details': 'Map: Highpass (hosting)',
'state': 'Time on map: 0:00',
'timestamps': {
'start': 0
},
'assets': {
'large_image': 'z_koth_highpass',
'large_text': 'Highpass - TF2 Rich Presence {tf2rpvnum}',
'small_image': 'demoman',
'small_text': 'Demoman'
}
})
self.assertTrue(game_state_test.update_rpc)
settings.change('bottom_line', 'Class')
game_state_test.set_bulk(
(False, 'koth_highpass', 'Demoman', '', 'Not queued', True))
self.assertTrue(game_state_test.update_rpc)
self.assertEqual(
str(game_state_test),
'Demoman on Highpass, gamemode=koth, hosting=True, queued="Not queued", server='
)
self.assertEqual(
fix_activity_dict(game_state_test.activity()), {
'details': 'Map: Highpass (hosting)',
'state': 'Class: Demoman',
'timestamps': {
'start': 0
},
'assets': {
'large_image': 'z_koth_highpass',
'large_text': 'Highpass - TF2 Rich Presence {tf2rpvnum}',
'small_image': 'demoman',
'small_text': 'Demoman'
}
})
self.assertFalse(game_state_test.update_rpc)
settings.access_registry(save=settings.defaults())
game_state_test.set_bulk(
(False, 'pl_snowycoast', 'Pyro', '162.254.192.155:27053',
'Not queued', False))
self.assertTrue(game_state_test.update_rpc)
game_state_test.update_server_data(['Player count'], {'Kataiser'})
self.assertEqual(
str(game_state_test),
'Pyro on Snowycoast, gamemode=payload, hosting=False, queued="Not queued", server=162.254.192.155:27053'
)
self.assertEqual(
fix_activity_dict(game_state_test.activity()), {
'details': 'Players: 0/0',
'state': 'Time on map: 0:00',
'timestamps': {
'start': 0
},
'assets': {
'large_image': 'z_pl_snowycoast',
'large_text': 'Snowycoast - TF2 Rich Presence {tf2rpvnum}',
'small_image': 'pyro',
'small_text': 'Pyro'
}
})
self.assertTrue(game_state_test.update_rpc)
settings.change('bottom_line', 'Kills')
settings.change('server_rate_limit', 0)
game_state_test.update_server_data(['Player count', 'Kills'],
{'Kataiser'})
self.assertEqual(
fix_activity_dict(game_state_test.activity()), {
'details': 'Players: 0/0',
'state': 'Kills: 0',
'timestamps': {
'start': 0
},
'assets': {
'large_image': 'z_pl_snowycoast',
'large_text': 'Snowycoast - TF2 Rich Presence {tf2rpvnum}',
'small_image': 'pyro',
'small_text': 'Pyro'
}
})
self.assertFalse(game_state_test.update_rpc)
settings.access_registry(save=settings.defaults())
game_state_test.set_bulk((False, 'cp_catwalk_a5c', 'Soldier', '',
'Queued for Casual', True))
self.assertTrue(game_state_test.update_rpc)
self.assertEqual(
str(game_state_test),
'Soldier on cp_catwalk_a5c, gamemode=control-point, hosting=True, queued="Queued for Casual", server='
)
self.assertEqual(
fix_activity_dict(game_state_test.activity()), {
'details': 'Map: cp_catwalk_a5c (hosting)',
'state': 'Queued for Casual',
'timestamps': {
'start': 0
},
'assets': {
'large_image': 'control-point',
'large_text':
'Control Point - TF2 Rich Presence {tf2rpvnum}',
'small_image': 'soldier',
'small_text': 'Soldier'
}
})
self.assertFalse(game_state_test.update_rpc)
game_state_test.set_bulk(
(False, 'arena_badlands', 'Engineer', '', 'Not queued', True))
self.assertTrue(game_state_test.update_rpc)
self.assertEqual(
str(game_state_test),
'Engineer on Badlands (Arena), gamemode=arena, hosting=True, queued="Not queued", server='
)
self.assertEqual(
fix_activity_dict(game_state_test.activity()), {
'details': 'Map: Badlands (Arena) (hosting)',
'state': 'Time on map: 0:00',
'timestamps': {
'start': 0
},
'assets': {
'large_image': 'z_cp_badlands',
'large_text':
'Badlands (Arena) - TF2 Rich Presence {tf2rpvnum}',
'small_image': 'engineer',
'small_text': 'Engineer'
}
})
self.assertTrue(game_state_test.update_rpc)
def test_settings_changing(self):
self.assertEquals(settings.get('no-such-value'), None)
settings.change({'no-such-value': 'yes'})
self.assertEquals(settings.get('no-such-value'), 'yes')
settings.change({'editors': 'one, two'})
self.assertEquals(settings.get('editors'), ['one', 'two'])
def test_page_reading(self):
user = users.User('*****@*****.**')
# Unknown user, default access.
settings.change({
'open-reading': None,
'readers': None,
'editors': None
})
self.assertEquals(access.can_read_page('foo', user, False), True)
# Unknown user, private wiki.
settings.change({'open-reading': 'no'})
self.assertEquals(access.can_read_page('foo', user, False), False)
# A privilaged reader, private wiki.
settings.change({
'open-reading': 'no',
'readers': user.email(),
'editors': None
})
self.assertEquals(access.can_read_page('foo', user, False), True)
# A privilaged editor, private wiki.
settings.change({
'open-reading': 'no',
'readers': None,
'editors': user.email()
})
self.assertEquals(access.can_read_page('foo', user, False), True)
page = model.WikiContent(title='foo')
# An unknown user, a private wiki and a public page.
settings.change({
'open-reading': 'no',
'readers': None,
'editors': None
})
page.body = 'public: yes\n---\n# foo'
page.put()
self.assertEquals(access.can_read_page('foo', user, False), True)
# An unknown user, an open wiki and a private page.
settings.change({
'open-reading': 'yes',
'readers': None,
'editors': None
})
page.body = 'private: yes\n---\n# foo'
page.put()
self.assertEquals(access.can_read_page('foo', user, False), False)
# An open wiki, a private page with explicit access to some regular user.
settings.change({
'open-reading': 'yes',
'readers': None,
'editors': None
})
page.body = 'private: yes\nreaders: %s\n---\n# foo' % user.email()
page.put()
self.assertEquals(access.can_read_page('foo', user, False), True)
def saveSettings():
cup_type = bottle.request.forms.get('selectedCup')
settings.change('Current Cup', cup_type)
log.info(cup_type)
def test_settings_changing(self):
self.assertEquals(settings.get('no-such-value'), None)
settings.change({'no-such-value': 'yes'})
self.assertEquals(settings.get('no-such-value'), 'yes')
settings.change({'editors': 'one, two'})
self.assertEquals(settings.get('editors'), ['one', 'two'])
