oioioi.participants.tests

Module Contents

Classes

ParticipantsContestController	Contains the contest logic and rules.
OnsiteContestController	Contains the contest logic and rules.
TestParticipantsContestViews	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestParticipantsSubmit	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestParticipantsRegistration	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestOpenParticipantsRegistration	Similar to TransactionTestCase, but use transaction.atomic() to achieve
NoAdminParticipantsRegistrationController	A base class for classes which should have a list of subclasses
NoAdminParticipantsContestController	Contains the contest logic and rules.
TestOnsiteAdmin	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestParticipantsModelAdmin	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestParticipantsExclusiveContestsMiddlewareMixin	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestRegistrationModel	Similar to TransactionTestCase, but use transaction.atomic() to achieve
AnonymousRegistrationController	A base class for classes which should have a list of subclasses
AnonymousContestController	Contains the contest logic and rules.
TestAnonymousParticipants	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestParticipantsDataViews	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestOnsiteViews	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestOnsiteRegistration	Similar to TransactionTestCase, but use transaction.atomic() to achieve
TestUserInfo	Similar to TransactionTestCase, but use transaction.atomic() to achieve

Attributes

basedir

oioioi.participants.tests.basedir

class oioioi.participants.tests.ParticipantsContestController(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.participants.tests.OnsiteContestController(contest)

Bases: oioioi.programs.controllers.ProgrammingContestController

Contains the contest logic and rules.

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

class oioioi.participants.tests.TestParticipantsContestViews(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_participants_contest_visibility()

test_participants_contest_access()

class oioioi.participants.tests.TestParticipantsSubmit(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_submit_permissions()

class oioioi.participants.tests.TestParticipantsRegistration(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_participants_accounts_menu()

test_participants_registration()

test_participants_unregister()

class oioioi.participants.tests.TestOpenParticipantsRegistration(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_participants_registration()

test_contest_info()

class oioioi.participants.tests.NoAdminParticipantsRegistrationController(contest)

Bases: oioioi.participants.controllers.ParticipantsController

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().

property participant_admin

class oioioi.participants.tests.NoAdminParticipantsContestController(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.participants.tests.TestOnsiteAdmin(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_admin_menu()

test_regions_admin()

test_participants_import()

class oioioi.participants.tests.TestParticipantsModelAdmin(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_permissions']

test_participants_admin_visibility()

test_noadmin_admin_visibility()

test_participants_import()

class oioioi.participants.tests.TestParticipantsExclusiveContestsMiddlewareMixin(methodName='runTest')

Bases: oioioi.base.tests.TestCase, oioioi.contestexcl.tests.ContestIdViewCheckMixin

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']

setUp()

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

test_participants_selector()

test_contest_admin_with_participant()

class oioioi.participants.tests.TestRegistrationModel(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_both_hands_cascading_on_registration_delete()

class oioioi.participants.tests.AnonymousRegistrationController(contest)

Bases: oioioi.oi.controllers.OIRegistrationController

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().

allow_login_as_public_name()

Determines if participants may choose to stay anonymous, i.e. use their logins as public names.

class oioioi.participants.tests.AnonymousContestController(contest)

Bases: oioioi.oi.controllers.OIContestController

Contains the contest logic and rules.

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

registration_controller()

class oioioi.participants.tests.TestAnonymousParticipants(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_schools', 'test_full_package', 'test_problem_instance',...

_register(user, anonymous=False, possible=False)

test_no_anonymous_participants()

test_anonymous_participants()

test_user_info_page()

class oioioi.participants.tests.TestParticipantsDataViews(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_schools']

register(contest)

test_no_email_data_view()

test_data_view()

test_none_school()

class oioioi.participants.tests.TestOnsiteViews(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_contest_visibility()

test_contest_access()

class oioioi.participants.tests.TestOnsiteRegistration(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_missing_registration_model()

test_participants_accounts_menu()

test_participants_unregister_forbidden()

class oioioi.participants.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_permissions']

test_onsite_user_info_page()