oioioi.contests.tests.tests

Module Contents

Classes

TestModels	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestScores	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmissionListOrder	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmissionListFilters	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestUrls	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestCurrentContest	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestContestController	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestContestViews	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestMySubmissions	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestManyRounds	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestMultilingualStatements	Similar to TransactionTestCase, but use transaction.atomic() to achieve
ContestWithoutStatementsController	Contains the contest logic and rules.
TestMySubmissionsContext	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmitButtonInProblemsList	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestStatementsVisibility	Similar to TransactionTestCase, but use transaction.atomic() to achieve
BrokenContestController	Contains the contest logic and rules.
TestRejudgeAndFailure	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestRejudgeTypesView	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestContestAdmin	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestAttachments	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestRoundExtension	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestPermissions	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestPermissionsBasicAdmin	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestProblemsMenuWithQuizzes	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmissionChangeKind	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestDeleteSelectedSubmissions	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmitSelectOneProblem	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmitSelectManyProblems	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestDateRegistry	Similar to TransactionTestCase, but use transaction.atomic() to achieve
ContestWithPublicResultsController	Contains the contest logic and rules.
TestPublicResults	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestContestLinks	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestPersonalDataUser	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestUserInfo	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestProblemInstanceView	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestReattachingProblems	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestModifyContest	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestRegistrationController	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestAdministeredContests	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmissionViewWithoutContest	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmissionAdminWithoutContest	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmissionsLimitOnListView	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmissionsLinksOnListView	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestNoSubmissionsLimitOnListView	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestAPIGetProblemId	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestAPISubmitBase	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestAPIContestSubmit	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestAPIProblemsetSubmit	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestManyRoundsNoEnd	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestRankingVisibility	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestContestChangeForm	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestOpenRegistration	Similar to TransactionTestCase, but use transaction.atomic() to achieve

Functions

print_contest_id_view(request)
render_contest_id_view(request)
failing_handler(env)
see_limits_on_problems_list(self, username, ...[, ...])
see_link_for_submission_on_problem_list(self, ...)
check_ranking_visibility(self, url, rvc)
set_registration_availability(rvc, enabled[, ...])
check_registration(self, expected_status_code, ...[, ...])

class oioioi.contests.tests.tests.TestModels(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_fields_autogeneration()

class oioioi.contests.tests.tests.TestScores(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_full_package', 'test_problem_instance', 'test_submission']

test_integer_score()

test_score_field()

test_db_order()

oioioi.contests.tests.tests.print_contest_id_view(request)

oioioi.contests.tests.tests.render_contest_id_view(request)

class oioioi.contests.tests.tests.TestSubmissionListOrder(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_full_package', 'test_problem_instance', 'test_submission',...

setUp()

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

test_default_order()

check_id_order_in_response(response, ids)

test_score_order()

check_ce_order_in_response(response, is_descending, error_msg)

check_order_in_response(response, order, error_msg)

class oioioi.contests.tests.tests.TestSubmissionListFilters(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_full_package', 'test_problem_instance', 'test_submission',...

setUp()

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

test_all_filters()

class oioioi.contests.tests.tests.TestUrls(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_contest']

test_make_patterns()

test_reverse()

class oioioi.contests.tests.tests.TestCurrentContest(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_two_empty_contests']

_test_redirecting_contest_mode()

test_neutral_contest_mode()

test_contest_if_possible_contest_mode()

test_contest_only_contest_mode()

test_namespaced_redirect()

class oioioi.contests.tests.tests.TestContestController(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_full_package', 'test_problem_instance', 'test_submission',...

test_order_rounds_by_focus()

class oioioi.contests.tests.tests.TestContestViews(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_full_package', 'test_problem_instance', 'test_submission']

test_recent_contests_list()

test_contest_visibility()

test_submission_view()

test_submissions_permissions()

class oioioi.contests.tests.tests.TestMySubmissions(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_full_package', 'test_problem_instance', 'test_submission_list']

test_submission_messages()

class oioioi.contests.tests.tests.TestManyRounds(methodName='runTest')

Bases: oioioi.base.tests.TestsUtilsMixin, 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_full_package', 'test_problem_instance', 'test_submission',...

static remove_ws(response)

test_problems_visibility()

test_submissions_visibility()

test_mixin_past_rounds_hidden_during_prep_time()

class oioioi.contests.tests.tests.TestMultilingualStatements(methodName='runTest')

Bases: oioioi.base.tests.TestCase, oioioi.filetracker.tests.TestStreamingMixin

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_full_package', 'test_problem_instance', 'test_extra_statements']

test_multilingual_statements()

class oioioi.contests.tests.tests.ContestWithoutStatementsController(contest)

Bases: oioioi.programs.controllers.ProgrammingContestController

Contains the contest logic and rules.

This is the computerized implementation of the contest’s official rules.

default_can_see_statement(request_or_context, problem_instance)

class oioioi.contests.tests.tests.TestMySubmissionsContext(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_full_package', 'test_problem_instance']

test_config()

class oioioi.contests.tests.tests.TestSubmitButtonInProblemsList(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_full_package', 'test_problem_instance', 'test_submission']

test_with_authorized_user()

test_with_unauthorized_user()

test_with_no_submissions_left()

test_with_ended_round()

class oioioi.contests.tests.tests.TestStatementsVisibility(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_full_package', 'test_problem_instance']

test_controller()

test_statements_config()

oioioi.contests.tests.tests.failing_handler(env)

class oioioi.contests.tests.tests.BrokenContestController(contest)

Bases: oioioi.programs.controllers.ProgrammingContestController

Contains the contest logic and rules.

This is the computerized implementation of the contest’s official rules.

fill_evaluation_environ(environ, submission)

class oioioi.contests.tests.tests.TestRejudgeAndFailure(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_full_package', 'test_problem_instance', 'test_submission']

test_rejudge_request()

test_rejudge_and_failure()

test_suspicious_rejudge_request()

class oioioi.contests.tests.tests.TestRejudgeTypesView(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_full_package', 'test_problem_instance', 'test_submission',...

test_view()

class oioioi.contests.tests.tests.TestContestAdmin(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_simple_contest_create_and_change()

test_admin_permissions()

class oioioi.contests.tests.tests.TestAttachments(methodName='runTest')

Bases: oioioi.base.tests.TestCase, oioioi.filetracker.tests.TestStreamingMixin

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_full_package', 'test_problem_instance']

test_attachments()

test_pub_date()

class oioioi.contests.tests.tests.TestRoundExtension(methodName='runTest')

Bases: oioioi.base.tests.TestCase, oioioi.programs.tests.SubmitFileMixin

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_full_package', 'test_problem_instance', 'test_extra_rounds']

test_round_extension()

test_round_extension_admin()

class oioioi.contests.tests.tests.TestPermissions(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_full_package', 'test_problem_instance', 'test_submission',...

get_fake_request_factory(contest=None)

setUp()

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

test_utils()

test_privilege_manipulation()

test_menu()

class oioioi.contests.tests.tests.TestPermissionsBasicAdmin(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_permissions', 'test_contest', 'test_full_package', 'test_problem_packages',...

setUp()

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

test_dashboard()

test_menu()

test_menu_settings()

test_menu_problems()

test_problem_admin()

test_probleminstance_admin()

test_modelsolutions()

test_modelsubmission_source()

test_menu_submissions()

test_menu_problempackages_basicadmin()

test_menu_problempackages_admin()

test_usermenu()

test_usermenu_files()

test_usermenu_submit()

test_usermenu_ranking()

test_usermenu_questions_and_news()

test_show_info_about()

class oioioi.contests.tests.tests.TestProblemsMenuWithQuizzes(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_permissions', 'test_contest', 'test_quiz_problem', 'test_problem_instance',...

test_menu_problems()

class oioioi.contests.tests.tests.TestSubmissionChangeKind(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_full_package', 'test_problem_instance', 'test_multiple_submissions']

setUp()

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

change_kind(submission, kind)

test_kind_change()

class oioioi.contests.tests.tests.TestDeleteSelectedSubmissions(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_full_package', 'test_problem_instance', 'test_submission',...

test_delete_one_submission()

test_delete_many_submissions()

class oioioi.contests.tests.tests.TestSubmitSelectOneProblem(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_full_package', 'test_problem_instance']

test_problems_list()

class oioioi.contests.tests.tests.TestSubmitSelectManyProblems(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_extra_problem', 'test_contest', 'test_full_package', 'test_problem_instance']

test_problems_list()

class oioioi.contests.tests.tests.TestDateRegistry(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_contest']

test_registry_content()

class oioioi.contests.tests.tests.ContestWithPublicResultsController(contest)

Bases: oioioi.programs.controllers.ProgrammingContestController

Contains the contest logic and rules.

This is the computerized implementation of the contest’s official rules.

separate_public_results()

Determines if there should be two separate dates for personal results (when participants can see their scores for a given round) and public results (when round ranking is published).

Depending on the value returned, contest admins can see and modify both Results date and Public results date or only the first one.

Return type

bool

class oioioi.contests.tests.tests.TestPublicResults(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']

_change_controller(public_results=False)

test_round_inline()

_check_public_results(expected)

test_public_results_visible()

test_all_results_visible()

class oioioi.contests.tests.tests.TestContestLinks(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_menu()

class oioioi.contests.tests.tests.TestPersonalDataUser(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_contest', 'test_permissions']

testUser()

class oioioi.contests.tests.tests.TestUserInfo(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_full_package', 'test_problem_instance', 'test_submission']

test_user_info_page()

class oioioi.contests.tests.tests.TestProblemInstanceView(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_full_package', 'test_problem_instance', 'test_permissions',...

test_admin_change_view()

separate_main_problem_instance()

test_resetting_limits()

test_rejudge_not_needed()

class oioioi.contests.tests.tests.TestReattachingProblems(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_extra_contests', 'test_full_package',...

test_reattaching_problem()

test_permissions()

class oioioi.contests.tests.tests.TestModifyContest(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_modify_contest()

class oioioi.contests.tests.tests.TestRegistrationController(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_two_empty_contests', 'test_users']

test_filter_visible_contests()

class oioioi.contests.tests.tests.TestAdministeredContests(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_two_empty_contests', 'test_users']

test_administered_contests()

class oioioi.contests.tests.tests.TestSubmissionViewWithoutContest(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_contest', 'test_users', 'test_full_package', 'test_problem_site',...

setUp()

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

test_submission_view_without_contest()

class oioioi.contests.tests.tests.TestSubmissionAdminWithoutContest(methodName='runTest')

Bases: oioioi.base.tests.TestCase, oioioi.programs.tests.SubmitFileMixin

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_extra_contests', 'test_users', 'test_full_package', 'test_extra_problem_instance',...

setUp()

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

test_submission_admin_without_contest()

oioioi.contests.tests.tests.see_limits_on_problems_list(self, username, displays_submissions_limit, displays_tries_left, additional=[])

class oioioi.contests.tests.tests.TestSubmissionsLimitOnListView(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_full_package', 'test_problem_instance', 'test_submission']

test_anonymous_user()

test_user()

test_admin()

oioioi.contests.tests.tests.see_link_for_submission_on_problem_list(self, username, should_see)

class oioioi.contests.tests.tests.TestSubmissionsLinksOnListView(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_full_package', 'test_problem_instance', 'test_submission']

test_link_to_submission_no_user()

test_link_to_submission_user()

test_link_to_submission_admin()

class oioioi.contests.tests.tests.TestNoSubmissionsLimitOnListView(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_full_package', 'test_submission',...

test_not_displaying_limits()

class oioioi.contests.tests.tests.TestAPIGetProblemId(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_contest', 'test_full_package', 'test_problem_instance']

view_name = api_contest_get_problem_id

setUp()

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

test_successful_query()

test_invalid_contest_id()

test_invalid_problem_short_name()

class oioioi.contests.tests.tests.TestAPISubmitBase(*args, **kwargs)

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_contest', 'test_full_package', 'test_submission']

extra_fixtures = []

setUp()

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

submit_file(url_name, url_kwargs, file_size=1024, file_name='submission.cpp', kind=None)

_assertSubmitted(response, i=None)

class oioioi.contests.tests.tests.TestAPIContestSubmit(*args, **kwargs)

Bases: TestAPISubmitBase

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.

extra_fixtures = ['test_problem_instance']

contest_submit(contest, pi, *args, **kwargs)

test_simple_submission()

test_submissions_limitation()

test_huge_submission()

test_size_limit_accuracy()

_assertUnsupportedExtension(contest, problem_instance, name, ext)

test_limiting_extensions()

class oioioi.contests.tests.tests.TestAPIProblemsetSubmit(*args, **kwargs)

Bases: TestAPISubmitBase

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.

extra_fixtures = ['test_problem_site', 'test_problem_instance_with_no_contest']

problemset_submit(problem=None, site_key=None, *args, **kwargs)

test_problemset_submission()

class oioioi.contests.tests.tests.TestManyRoundsNoEnd(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_full_package', 'test_problem_instance', 'test_submission',...

test_not_sorting()

oioioi.contests.tests.tests.check_ranking_visibility(self, url, rvc)

class oioioi.contests.tests.tests.TestRankingVisibility(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_full_package', 'test_problem_instance', 'test_submission']

test_user()

test_admin()

class oioioi.contests.tests.tests.TestContestChangeForm(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_contest_change_form()

oioioi.contests.tests.tests.set_registration_availability(rvc, enabled, available_from=None, available_to=None)

oioioi.contests.tests.tests.check_registration(self, expected_status_code, availability, available_from=None, available_to=None)

class oioioi.contests.tests.tests.TestOpenRegistration(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_open_registration()

test_closed_registration()

test_configured_registration_opened()

test_configured_registration_closed_before()

test_configured_registration_closed_after()