oioioi.programs.tests

Module Contents

Classes

SubmitFileMixin
TestProgrammingProblemController	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestProgrammingContestController	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestProgramsViews	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSourceWithoutContest	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestHeaderLinks	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestProgramsXssViews	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestOtherSubmissions	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestNoOtherSubmissions	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestDiffView	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmission	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmissionAdmin	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmittingAsAdmin	Similar to TransactionTestCase, but use transaction.atomic() to achieve
PrivateProgrammingContestController	Contains the contest logic and rules.
TestSubmittingAsContestAdmin	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestSubmittingAsObserver	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestNotifications	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestScorers	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestUserOutsGenerating	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestAdminInOutDownload	Similar to TransactionTestCase, but use transaction.atomic() to achieve
ContestWithJudgeInfoController	Contains the contest logic and rules.
TestRejudge	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestLimitsLimits	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestCompiler	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestMaxScoreMigration	TestCase for Django Migrations
TestReportDisplayTypes	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestAllowedLanguages	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestLanguageOverrideForTest	Similar to TransactionTestCase, but use transaction.atomic() to achieve

Functions

extract_code(show_response)
extract_code_from_diff(show_response)

oioioi.programs.tests.extract_code(show_response)

oioioi.programs.tests.extract_code_from_diff(show_response)

class oioioi.programs.tests.SubmitFileMixin

Bases: oioioi.contests.tests.SubmitMixin

submit_file(contest, problem_instance, file_size=1024, file_name='submission.cpp', kind='NORMAL', user=None)

submit_code(contest, problem_instance, code='', prog_lang='C', send_file=False, kind='NORMAL', user=None)

class oioioi.programs.tests.TestProgrammingProblemController(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_safe_exec_mode()

class oioioi.programs.tests.TestProgrammingContestController(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_safe_exec_mode()

class oioioi.programs.tests.TestProgramsViews(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_permissions',...

test_submission_views()

test_test_views()

test_submissions_permissions()

test_model_solutions_view()

class oioioi.programs.tests.TestSourceWithoutContest(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_problem_instance_without_contest', 'test_submission_source', 'test_full_package']

test_source_permissions()

class oioioi.programs.tests.TestHeaderLinks(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_changelist_visibility()

class oioioi.programs.tests.TestProgramsXssViews(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_submission_xss']

test_submission_xss_views()

class oioioi.programs.tests.TestOtherSubmissions(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_get(username)

test_admin()

test_user()

class oioioi.programs.tests.TestNoOtherSubmissions(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_get(username)

test_admin()

test_user()

class oioioi.programs.tests.TestDiffView(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_saving_button()

test_diff_view()

class oioioi.programs.tests.TestSubmission(methodName='runTest')

Bases: oioioi.base.tests.TestCase, 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_submission',...

setUp()

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

test_submission_completed_notification()

test_repeated_submission_fail()

test_repeated_submission_different_problems()

test_repeated_submission_success()

test_simple_submission()

test_huge_submission()

test_huge_code_length()

test_size_limit_accuracy()

test_submissions_limitation()

_assertUnsupportedExtension(contest, problem_instance, name, ext)

test_extension_checking()

test_code_pasting()

test_pasting_unicode_code()

test_limiting_extensions()

class oioioi.programs.tests.TestSubmissionAdmin(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_submissions_changelist()

class oioioi.programs.tests.TestSubmittingAsAdmin(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_problem_instance', 'test_full_package']

test_ignored_submission()

test_submitting_as_self()

class oioioi.programs.tests.PrivateProgrammingContestController(contest)

Bases: oioioi.programs.controllers.ProgrammingContestController

Contains the contest logic and rules.

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

registration_controller()

class oioioi.programs.tests.TestSubmittingAsContestAdmin(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_missing_permission()

class oioioi.programs.tests.TestSubmittingAsObserver(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_ignored_submission()

class oioioi.programs.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_contest', 'test_full_package', 'test_problem_instance', 'test_permissions',...

test_initial_results_notification()

class oioioi.programs.tests.TestScorers(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.

t_results_ok = [None, None, None, None, None, None, None]

t_results_ok_perc = [None, None, None, None]

t_results_unequal_max_scores = [None, None]

t_expected_unequal_max_scores = [None, None]

t_results_wrong = [None, None]

t_expected_wrong = [None, None]

test_discrete_test_scorer()

test_threshold_linear_test_scorer()

g_results_ok()

g_results_wrong()

g_results_unequal_max_scores()

test_min_group_scorer()

test_sum_group_scorer()

test_sum_score_aggregator()

class oioioi.programs.tests.TestUserOutsGenerating(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_report_after_generate()

test_generate_and_download_user_permission()

class oioioi.programs.tests.TestAdminInOutDownload(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_report_href_visibility()

class oioioi.programs.tests.ContestWithJudgeInfoController(contest)

Bases: oioioi.programs.controllers.ProgrammingContestController

Contains the contest logic and rules.

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

judged = False

submission_judged(submission, rejudged=False)

class oioioi.programs.tests.TestRejudge(methodName='runTest')

Bases: oioioi.base.tests.TestCase, 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_submission',...

_set_active_tests(active_tests, all_tests)

_test_rejudge(submit_active_tests, rejudge_active_tests, rejudge_type, tests_subset, expected_ok, expected_re)

test_rejudge_full()

test_rejudge_judged()

test_rejudge_new()

class oioioi.programs.tests.TestLimitsLimits(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']

form_data

edit_settings()

test_time_limit()

test_memory_limit()

class oioioi.programs.tests.TestCompiler(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_submit_view()

test_compiler_hints_view()

test_contest_admin_inline()

test_contest_contest_admin_inline()

test_problem_admin_inline()

test_check_compiler_config_valid()

test_check_compiler_config_invalid_compiler()

test_check_compiler_config_no_compiler()

class oioioi.programs.tests.TestMaxScoreMigration(methodName='runTest')

Bases: oioioi.base.utils.test_migrations.TestCaseMigrations

TestCase for Django Migrations

migrate_from, migrate_to should be Django migration names of tested app setUpBeforeMigration(self, apps) method will be called before migrations are applied

source: https://www.caktusgroup.com/blog/2016/02/02/writing-unit-tests-django-migrations/

migrate_from = 0012_testreport_max_score

migrate_to = 0014_remove_testreport_test_max_score

make_report(problem_id, contest, apps, max_score)

setUpBeforeMigration(apps)

test()

class oioioi.programs.tests.TestReportDisplayTypes(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 = ['admin_admin', 'test_users', 'test_report_display_test']

test_oi_display()

test_acm_display()

test_pa_display()

class oioioi.programs.tests.TestAllowedLanguages(methodName='runTest')

Bases: oioioi.base.tests.TestCase, 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_permissions',...

setUp()

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

test_empty_whitelist()

test_allowed_languages_dict()

test_disallowed_language_submit_attempt()

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

setUp()

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

test_proper_env_override()