def test_get_filter_options_with_invalid_field_throws_exception( self) -> None: model_class = app_feedback_report_models.AppFeedbackReportModel invalid_filter = python_utils.create_enum( 'invalid_field') # type: ignore[no-untyped-call] with self.assertRaisesRegexp( # type: ignore[no-untyped-call] utils.InvalidInputException, 'The field %s is not a valid field to filter reports on' % (invalid_filter.invalid_field.name)): with self.swap(model_class, 'query', self._mock_query_filters_returns_empy_list): model_class.get_filter_options_for_field( invalid_filter.invalid_field)
from core import feconf from core import python_utils from core.jobs import job_utils from core.jobs.decorators import validation_decorators from core.jobs.types import base_validation_errors from core.platform import models import apache_beam as beam (base_models, exp_models) = models.Registry.import_models( [models.NAMES.base_model, models.NAMES.exploration]) BASE_MODEL_ID_PATTERN = r'^[A-Za-z0-9-_]{1,%s}$' % base_models.ID_LENGTH MAX_CLOCK_SKEW_SECS = datetime.timedelta(seconds=1) VALIDATION_MODES = python_utils.create_enum('neutral', 'strict', 'non_strict') # pylint: disable=invalid-name class ValidateDeletedModel(beam.DoFn): """DoFn to check whether models marked for deletion are stale. Doesn't use the AuditsExisting decorator because it audits deleted models, not existing ones. """ def process(self, entity): """Yields audit errors that are discovered in the input model. Args: entity: datastore_services.Model. Entity to validate. Yields:
from mypy_imports import datastore_services (base_models, ) = models.Registry.import_models([models.NAMES.base_model]) datastore_services = models.Registry.import_datastore_services() PLATFORM_CHOICE_ANDROID = 'android' PLATFORM_CHOICE_WEB = 'web' PLATFORM_CHOICES = [PLATFORM_CHOICE_ANDROID, PLATFORM_CHOICE_WEB] GITHUB_REPO_CHOICES = PLATFORM_CHOICES # The model field names that can be filtered / sorted for when maintainers # triage feedback reports. FILTER_FIELD_NAMES = python_utils.create_enum( # type: ignore[no-untyped-call] 'platform', 'report_type', 'entry_point', 'submitted_on', 'android_device_model', 'android_sdk_version', 'text_language_code', 'audio_language_code', 'platform_version', 'android_device_country_locale_code') # An ID used for stats model entities tracking all unticketed reports. UNTICKETED_ANDROID_REPORTS_STATS_TICKET_ID = ( 'unticketed_android_reports_stats_ticket_id') class AppFeedbackReportModel(base_models.BaseModel): """Model for storing feedback reports sent from learners. Instances of this model contain information about learner's device and Oppia app settings, as well as information provided by the user in the feedback report.
from core import feconf from core import python_utils from core.constants import constants from typing import List, Tuple, Type MYPY = False if MYPY: # pragma: no cover from mypy_imports import base_models # pylint: disable=unused-import # Valid model names. NAMES = python_utils.create_enum( # type: ignore[no-untyped-call] 'activity', 'app_feedback_report', 'audit', 'base_model', 'beam_job', 'blog', 'classifier', 'collection', 'config', 'email', 'exploration', 'feedback', 'improvements', 'job', 'opportunity', 'question', 'recommendations', 'skill', 'statistics', 'activity', 'audit', 'auth', 'base_model', 'classifier', 'collection', 'config', 'email', 'exploration', 'feedback', 'improvements', 'job', 'opportunity', 'question', 'recommendations', 'skill', 'statistics', 'story', 'subtopic', 'suggestion', 'topic', 'translation', 'user') # Types of deletion policies. The pragma comment is needed because Enums are # evaluated as classes in Python and they should use PascalCase, but using # UPPER_CASE seems more appropriate here. MODULES_WITH_PSEUDONYMIZABLE_CLASSES = ( # pylint: disable=invalid-name NAMES.app_feedback_report, NAMES.blog, NAMES.collection, NAMES.config, NAMES.exploration, NAMES.feedback, NAMES.question, NAMES.skill, NAMES.story, NAMES.subtopic, NAMES.suggestion, NAMES.topic) GAE_PLATFORM = 'gae'
def test_enum_for_invalid_attribute(self): enums = python_utils.create_enum('first', 'second', 'third') with self.assertRaisesRegexp(AttributeError, 'fourth'): getattr(enums, 'fourth')
def test_create_enum_method_and_check_its_names(self): """Test create_enum method.""" enums = python_utils.create_enum('first', 'second', 'third') self.assertEqual(enums.first.name, 'first') self.assertEqual(enums.second.name, 'second') self.assertEqual(enums.third.name, 'third')
UNTICKETED_ANDROID_REPORTS_STATS_TICKET_ID = ( app_feedback_report_models.UNTICKETED_ANDROID_REPORTS_STATS_TICKET_ID) MAXIMUM_TICKET_NAME_LENGTH = 100 MINIMUM_ANDROID_SDK_VERSION = 2 # Timezone offsets in hours, corresponding to the range of timezone difference # from GMT. TIMEZONE_MINIMUM_OFFSET = -12 TIMEZONE_MAXIMUM_OFFSET = 14 REPORT_ID_DELIMITER = '.' TICKET_ID_DELIMITER = '.' STATS_ID_DELIMITER = ':' ANDROID_VERSION_NAME_DELIMITER = '-' # Ignoring the untyped call error because python_utils is untyped. REPORT_TYPE = python_utils.create_enum( 'suggestion', 'issue', 'crash') # type: ignore[no-untyped-call] CATEGORY = python_utils.create_enum( # type: ignore[no-untyped-call] 'feature_suggestion', 'language_suggestion', 'other_suggestion', 'lesson_question_issue', 'language_general_issue', 'language_audio_issue', 'language_text_issue', 'topics_issue', 'profile_issue', 'other_issue', 'lesson_player_crash', 'practice_questions_crash', 'options_page_crash', 'profile_page_crash', 'other_crash') ENTRY_POINT = python_utils.create_enum( # type: ignore[no-untyped-call] 'navigation_drawer', 'lesson_player', 'revision_card', 'crash') STATS_PARAMETER_NAMES = python_utils.create_enum( # type: ignore[no-untyped-call] 'platform', 'report_type', 'country_locale_code', 'entry_point_name', 'text_language_code', 'audio_language_code', 'android_sdk_version', 'version_name') ANDROID_TEXT_SIZE = python_utils.create_enum( # type: ignore[no-untyped-call] 'text_size_unspecified', 'small_text_size', 'medium_text_size', 'large_text_size', 'extra_large_text_size')
# See the License for the specific language governing permissions and # limitations under the License. """Domain objects for platform parameters.""" from __future__ import annotations import json import re from core import feconf from core import python_utils from core import utils from core.constants import constants from core.domain import change_domain SERVER_MODES = python_utils.create_enum('dev', 'test', 'prod') # pylint: disable=invalid-name FEATURE_STAGES = SERVER_MODES # pylint: disable=invalid-name DATA_TYPES = python_utils.create_enum('bool', 'string', 'number') # pylint: disable=invalid-name ALLOWED_SERVER_MODES = [ SERVER_MODES.dev.value, SERVER_MODES.test.value, SERVER_MODES.prod.value ] ALLOWED_FEATURE_STAGES = [ FEATURE_STAGES.dev.value, FEATURE_STAGES.test.value, FEATURE_STAGES.prod.value ] ALLOWED_PLATFORM_TYPES = constants.PLATFORM_PARAMETER_ALLOWED_PLATFORM_TYPES ALLOWED_BROWSER_TYPES = constants.PLATFORM_PARAMETER_ALLOWED_BROWSER_TYPES ALLOWED_APP_VERSION_FLAVORS = ( constants.PLATFORM_PARAMETER_ALLOWED_APP_VERSION_FLAVORS)
def test_create_platform_parameter_with_invalid_type_failure(self): _data_type = python_utils.create_enum('invalid') with self.assertRaisesRegexp( Exception, 'Unsupported data type \'invalid\''): registry.Registry.create_platform_parameter( PARAM_NAMES.parameter_a, 'test', _data_type.invalid)
from core import feconf from core import python_utils from core import utils from core.domain import caching_services from core.domain import platform_parameter_domain as parameter_domain from core.domain import platform_parameter_registry as registry from core.platform import models from core.tests import test_utils (config_models,) = models.Registry.import_models( [models.NAMES.config]) DATA_TYPES = parameter_domain.DATA_TYPES # pylint: disable=invalid-name FEATURE_STAGES = parameter_domain.FEATURE_STAGES # pylint: disable=invalid-name PARAM_NAMES = python_utils.create_enum('parameter_a') # pylint: disable=invalid-name class PlatformParameterRegistryTests(test_utils.GenericTestBase): """Tests for the platform parameter Registry.""" def setUp(self): super(PlatformParameterRegistryTests, self).setUp() self.original_param_registry = registry.Registry.parameter_registry registry.Registry.parameter_registry.clear() # Parameter names that might be used in following tests. parameter_names = ('parameter_a', 'parameter_b') caching_services.delete_multi( caching_services.CACHE_NAMESPACE_PLATFORM_PARAMETER, None,
# limitations under the License. """Unit tests for platform_feature_services.py.""" from __future__ import absolute_import from __future__ import unicode_literals from core import python_utils from core import utils from core.constants import constants from core.domain import caching_services from core.domain import platform_feature_services as feature_services from core.domain import platform_parameter_domain from core.domain import platform_parameter_registry as registry from core.tests import test_utils PARAM_NAMES = python_utils.create_enum('feature_a', 'feature_b') # pylint: disable=invalid-name SERVER_MODES = platform_parameter_domain.SERVER_MODES FEATURE_STAGES = platform_parameter_domain.FEATURE_STAGES class PlatformFeatureServiceTest(test_utils.GenericTestBase): """Test for the platform feature services.""" def setUp(self): super(PlatformFeatureServiceTest, self).setUp() self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME) self.user_id = self.get_user_id_from_email(self.OWNER_EMAIL) registry.Registry.parameter_registry.clear() # Parameter names that might be used in following tests. param_names = ['feature_a', 'feature_b']
# distributed under the License is distributed on an "AS-IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Definition of platform parameters.""" from __future__ import annotations from core import python_utils from core.domain import platform_parameter_domain from core.domain import platform_parameter_registry as registry Registry = registry.Registry FEATURE_STAGES = platform_parameter_domain.FEATURE_STAGES # pylint: disable=invalid-name DATA_TYPES = platform_parameter_domain.DATA_TYPES # pylint: disable=invalid-name PARAM_NAMES = python_utils.create_enum( # pylint: disable=invalid-name 'dummy_feature', 'dummy_parameter') # Platform parameters should all be defined below. Registry.create_feature_flag( PARAM_NAMES.dummy_feature, 'This is a dummy feature flag.', FEATURE_STAGES.dev, ) Registry.create_platform_parameter(PARAM_NAMES.dummy_parameter, 'This is a dummy platform parameter.', DATA_TYPES.string)