oioioi.base.tests.tests

Module Contents

Classes

TestPermsTemplateTags	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestIndex	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestIndexNoContest	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestMainPage	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestOrderedRegistry	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestMenu	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestErrorHandlers	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestUtils	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestAllWithPrefix	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestDottedFieldClass	A base class for classes which should have a list of subclasses
TestDottedFieldSubclass	A base class for classes which should have a list of subclasses
TestFields	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestEnumField	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestExecute	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestMisc	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestRegistration	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestArchive	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestAdmin	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestBaseViews	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestBackendMiddleware	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestNotifications	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestCondition	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestLoginChange	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestPreferences	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestTranslate	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestFileUtils	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestUserDeactivationLogout	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestObtainingAPIToken	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestDocsEndpoints	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestPingEndpointsAndAuthentication	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestPasswordReset	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestAccountDeletion	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestJsCatalog	Similar to TransactionTestCase, but use transaction.atomic() to achieve

Attributes

basedir

oioioi.base.tests.tests.basedir

class oioioi.base.tests.tests.TestPermsTemplateTags(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

test_check_perms()

class oioioi.base.tests.tests.TestIndex(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users', 'test_contest']

test_login()

test_admin_login_redirect()

test_logout()

test_index()

test_accounts_menu()

class oioioi.base.tests.tests.TestIndexNoContest(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

test_no_contest()

test_navbar_login()

class oioioi.base.tests.tests.TestMainPage(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

custom_templates

test_custom_main_page()

class oioioi.base.tests.tests.TestOrderedRegistry(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

test_ordered_registry()

class oioioi.base.tests.tests.TestMenu(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users', 'test_contest', 'test_icon']

setUp()

Hook method for setting up the test fixture before exercising it.

tearDown()

Hook method for deconstructing the test fixture after testing it.

_render_menu(user=None)

test_menu()

test_is_contest_admin()

test_menu_item_attrs_escape()

test_side_menus_registry()

class oioioi.base.tests.tests.TestErrorHandlers(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

setUp()

Modify the client so that it follows to handler500 view on error, retaining cookies.

ajax_get(url)

assertHtml(response, code)

assertPlain(response, code)

test_ajax_errors()

test_errors()

test_user_in_500()

class oioioi.base.tests.tests.TestUtils(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

test_classinit()

test_registered_subclasses_meta()

test_object_with_mixins()

test_mixins_mro()

test_registered_with_mixing()

test_memoized()

test_reset_memoized()

test_utils_dont_need_settings()

class oioioi.base.tests.tests.TestAllWithPrefix(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

test_all_with_prefix()

class oioioi.base.tests.tests.TestDottedFieldClass

Bases: oioioi.base.utils.RegisteredSubclassesBase

A base class for classes which should have a list of subclasses available.

The list of subclasses is available in their subclasses class attributes. Classes which have explicitly set abstract class attribute to True are not added to subclasses.

If a class has modules_with_subclasses attribute (list or string), then specified modules for all installed applications can be loaded by calling load_subclasses().

modules_with_subclasses = ['tests.test_dotted_field_classes']

abstract = True

class oioioi.base.tests.tests.TestDottedFieldSubclass

Bases: TestDottedFieldClass

A base class for classes which should have a list of subclasses available.

The list of subclasses is available in their subclasses class attributes. Classes which have explicitly set abstract class attribute to True are not added to subclasses.

If a class has modules_with_subclasses attribute (list or string), then specified modules for all installed applications can be loaded by calling load_subclasses().

description = Description

class oioioi.base.tests.tests.TestFields(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

test_dotted_name_field()

test_dotted_name_field_module_loading()

class oioioi.base.tests.tests.TestEnumField(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

setUp()

Hook method for setting up the test fixture before exercising it.

test_basic_usage()

test_serialization()

Test if choices aren’t serialized by migration.

class oioioi.base.tests.tests.TestExecute(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

test_echo()

test_echo_with_list_command()

test_cat_with_string_input()

test_error()

test_ignored_error()

test_ignored_error_list()

test_line_splitting()

test_env()

test_cwd()

class oioioi.base.tests.tests.TestMisc(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

test_reload_settings_for_coverage()

test_uploaded_file_name()

test_make_html_links()

class oioioi.base.tests.tests.TestRegistration(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

test_registration_form_fields()

_register_user(terms_accepted=True, pass_captcha=True)

_assert_user_active()

test_registration_with_activation_email()

test_registration_without_activation_email()

test_registration_terms_not_accepted()

test_registration_captcha_not_passed()

class oioioi.base.tests.tests.TestArchive(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

good_files = ['archive.tgz', 'archive.zip']

bad_files = ['archive-with-symlink.tgz', 'archive-with-hardlink.tgz']

base_dir

test_archive()

test_size_calc()

class oioioi.base.tests.tests.TestAdmin(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

test_admin_delete()

test_import_users()

class oioioi.base.tests.tests.TestBaseViews(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

setUp()

Hook method for setting up the test fixture before exercising it.

test_edit_profile_view()

test_edit_email()

test_terms_not_accepted()

test_username_change_attempt()

test_unicode_wrong_first_name()

test_unicode_wrong_last_name()

test_names_with_valid_spaces()

test_names_with_invalid_spaces()

test_profile_dynamic_fields()

class oioioi.base.tests.tests.TestBackendMiddleware(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

test_backend_middleware()

class oioioi.base.tests.tests.TestNotifications(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

test_notification_registration()

class oioioi.base.tests.tests.TestCondition(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

_fake_request_factory()

setUp()

Hook method for setting up the test fixture before exercising it.

test_and_operator()

test_or_operator()

test_inverse_operator()

test_make_condition()

test_request_condition()

test_enforce_condition_success()

test_enforce_condition_failure_with_template()

test_enforce_condition_failure_without_template()

test_enforce_failing_condition_without_require_login()

test_enforce_passing_condition_without_require_login()

class oioioi.base.tests.tests.TestLoginChange(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users', 'test_contest']

setUp()

Hook method for setting up the test fixture before exercising it.

test_message()

test_can_change_login_from_invalid()

test_login_cannot_change_from_valid()

test_failed_login_change()

class oioioi.base.tests.tests.TestPreferences(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

test_language_preferences()

test_registration_preferences()

class oioioi.base.tests.tests.TestTranslate(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

test_translate()

class oioioi.base.tests.tests.TestFileUtils(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

test_split_ext()

test_strip_num_or_hash()

class oioioi.base.tests.tests.TestUserDeactivationLogout(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users', 'test_contest']

setUp()

Hook method for setting up the test fixture before exercising it.

assert_logged(logged=True)

test_invalidated_user_logout()

class oioioi.base.tests.tests.TestObtainingAPIToken(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

setUp()

Hook method for setting up the test fixture before exercising it.

test_api_token_view()

test_api_token_regeneration()

class oioioi.base.tests.tests.TestDocsEndpoints(methodName='runTest')

Bases: rest_framework.test.APITestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

test_docs()

class oioioi.base.tests.tests.TestPingEndpointsAndAuthentication(methodName='runTest')

Bases: rest_framework.test.APITestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

test_ping()

test_auth_ping()

test_auth_ping_with_token()

test_auth_ping_with_session()

class oioioi.base.tests.tests.TestPasswordReset(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

setUp()

Hook method for setting up the test fixture before exercising it.

test_reset_password_email_send_existing()

class oioioi.base.tests.tests.TestAccountDeletion(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

fixtures = ['test_users']

setUp()

Hook method for setting up the test fixture before exercising it.

test_account_deletion_correct_password()

test_account_deletion_incorrect_password()

test_account_deletion_no_password()

class oioioi.base.tests.tests.TestJsCatalog(methodName='runTest')

Bases: oioioi.base.tests.TestCase

Similar to TransactionTestCase, but use transaction.atomic() to achieve test isolation.

In most situations, TestCase should be preferred to TransactionTestCase as it allows faster execution. However, there are some situations where using TransactionTestCase might be necessary (e.g. testing some transactional behavior).

On database backends with no transaction support, TestCase behaves as TransactionTestCase.

test_javascript_catalog()