def get_scenario(self, scenario_id: int) -> Optional[ScenarioModel]: with db.create_session() as session: scenario: Optional[db.Scenario] = session.query( db.Scenario).get(scenario_id) if scenario is not None: return cast(ScenarioModel, ScenarioModel.from_orm(scenario)) return None
def set_error_emulation_run(self, emulation_run_id: int, traceback: str) -> None: with db.create_session() as session: emulation_run = self._get_emulation_run(session, emulation_run_id) emulation_run.status = db.EmulationStatus.ERROR emulation_run.traceback = traceback emulation_run.changed_at = get_current_time()
def test_scenario(test_feature: FeatureModel, faker: Faker) -> ScenarioModel: with db.create_session() as session: db_scenario = db.Scenario(feature_id=test_feature.id, text=faker.word()) session.add(db_scenario) session.flush() return cast(ScenarioModel, ScenarioModel.from_orm(db_scenario))
def set_emulation_run_status(self, emulation_run_id: int, status: db.EmulationStatus) -> None: with db.create_session() as session: emulation_run = self._get_emulation_run(session, emulation_run_id) if emulation_run.status != status: emulation_run.status = status emulation_run.changed_at = get_current_time()
def test_db_user(database: None) -> SystemUserModel: with db.create_session() as session: db_user = db.UserRole(login="******", password="******", role=db.Role.user) session.add(db_user) session.flush() return SystemUserModel.from_orm(db_user)
def authorize_user(self, username_field: StringField, password_field: PasswordField) -> Optional[db.BaseUser]: with db.create_session(expire_on_commit=False) as s: db_user = s.query(db.UserRole).filter(db.UserRole.login == username_field.data).one_or_none() if db_user is None: db_user = self._create_user(session=s, username=username_field.data, password=password_field.data) if db_user.password == password_field.data: return cast(db.BaseUser, db_user) return None
def get_requested_emulation_run( self, emulation_run_id: int) -> EmulationRunModel: with db.create_session() as session: emulation_run = self._get_emulation_run(session, emulation_run_id) emulation_run.status = db.EmulationStatus.REQUESTED emulation_run.port = self._get_next_port(session) emulation_run.changed_at = get_current_time() return cast(EmulationRunModel, EmulationRunModel.from_orm(emulation_run))
def test_user(test_system_user: SystemUserModel, faker: Faker, test_feature_type) -> TestUserModel: with db.create_session() as session: test_user = db.TestUser(feature_type_id=test_feature_type.id, name=cast(str, faker.word()), created_by=test_system_user.login) session.add(test_user) session.flush() return cast(TestUserModel, TestUserModel.from_orm(test_user))
def test_system_user(database: None, faker: Faker, test_user_role: db.Role) -> SystemUserModel: with db.create_session() as session: app_user = db.UserRole(login=faker.word(), password=faker.word(), role=test_user_role) session.add(app_user) session.flush() return cast(SystemUserModel, SystemUserModel.from_orm(app_user))
def create_emulation_run(self, emulation_id: int, initiated_by: str) -> EmulationRunModel: with db.create_session() as session: emulation_run = db.EmulationRun(emulation_id=emulation_id, initiated_by=initiated_by) session.add(emulation_run) session.flush() return cast(EmulationRunModel, EmulationRunModel.from_orm(emulation_run))
def save_response(self, draft_id: int, pr_url: str, published_at: datetime, opened: bool) -> None: with db.create_session() as session: draft: db.Draft = session.query(db.Draft).get(draft_id) draft.pr_url = pr_url draft.published_at = published_at feature: db.Feature = session.query(db.Feature).get( draft.feature_id) feature.released = opened
def set_run_status(self, run_id: int, status: db.TestRunStatus, traceback: Optional[str] = None) -> None: with db.create_session() as session: run: db.TestRun = session.query(db.TestRun).filter(db.TestRun.id == run_id).one() run.status = status if status is db.TestRunStatus.RUNNING: run.start = get_current_time() if status.finished: run.end = get_current_time() if isinstance(traceback, str): run.traceback = traceback
def save_draft(self, test_run_id: int, published_by: str) -> int: with db.create_session() as session: try: draft = session.query(db.Draft).as_unique( test_run_id=test_run_id, published_by=published_by) except RuntimeError as e: raise UniqueDraftCreationError( "Could not get unique draft!") from e session.add(draft) session.flush() return cast(int, draft.id)
def get_previous_feature_draft(self, feature_id: int) -> DraftModel: with db.create_session() as session: selection_num = 2 drafts: List[db.Draft] = session.query( db.Draft).filter( # noqa: ECE001 db.Draft.feature_id == feature_id).order_by( db.Draft.id.asc()).limit(selection_num).all() if not drafts or len(drafts) != selection_num: raise NullableDraftsError( f"Haven't got Drafts amount={selection_num} for feature_id={feature_id}!" ) return cast(DraftModel, DraftModel.from_orm(drafts[0]))
def test_emulation(test_system_user: SystemUserModel, test_user: TestUserModel, faker: Faker) -> EmulationModel: with db.create_session() as session: emulation = db.Emulation( name=cast(str, faker.word()), command=cast(str, faker.word()), test_user_id=test_user.id, created_by=test_system_user.login, ) session.add(emulation) session.flush() return cast(EmulationModel, EmulationModel.from_orm(emulation))
def _make_secret(cls) -> None: with db.create_session(expire_on_commit=False) as session: db_user = session.query(db.UserRole).filter( db.UserRole.login == _ADMIN_USERNAME).one_or_none() if db_user is not None: logger.info("Admin user already exists") return secret = cls._get_secret() logger.info("Generated admin secret: %s", secret) cls._create_user(session=session, username=_ADMIN_USERNAME, password=str(secret), role=db.Role.admin)
def create_test_run(self, scenario_id: int, executed_by: str) -> int: with db.create_session() as session: scenario: db.Scenario = session.query(db.Scenario).filter(db.Scenario.id == scenario_id).one() feature: db.Feature = session.query(db.Feature).filter(db.Feature.id == scenario.feature_id).one() run = db.TestRun( # type: ignore scenario_id=scenario_id, name=feature.name, status=db.TestRunStatus.STARTED, report_status=db.TestReportStatus.EMPTY, executed_by=executed_by, ) session.add(run) session.flush() return cast(int, run.id)
def test_feature(faker: Faker, test_system_user: SystemUserModel, test_feature_type: FeatureTypeModel) -> FeatureModel: with db.create_session() as session: feature = db.Feature( name=faker.word(), author=test_system_user.login, type_id=test_feature_type.id, task=[faker.word()[:11]], last_edited_by=test_system_user.login, file_path="my_folder/my_feature", ) session.add(feature) session.flush() return cast(FeatureModel, FeatureModel.from_orm(feature))
def test_draft(faker: Faker, test_feature: FeatureModel, test_created_test_run_id: int, test_system_user: SystemUserModel) -> DraftModel: with db.create_session() as session: draft: db.Draft = db.Draft( feature_id=test_feature.id, test_run_id=test_created_test_run_id, text=faker.word(), pr_url=faker.word(), published_by=test_system_user.login, published_at=datetime.datetime.now(), ) session.add(draft) session.flush() return cast(DraftModel, DraftModel.from_orm(draft))
def test_correct_run_created( self, test_executed_testruntask_id: int, subprocess_run_mock: mock.MagicMock, report_status: db.TestReportStatus ) -> None: subprocess_run_mock.assert_called_once() with db.create_session() as session: db_test_run = session.query(db.TestRun).get(test_executed_testruntask_id) assert db_test_run is not None test_run: TestRunModel = TestRunModel.from_orm(db_test_run) assert test_run.id == test_executed_testruntask_id assert isinstance(test_run.created_at, datetime) assert test_run.status is db.TestRunStatus.SUCCESS assert isinstance(test_run.start, datetime) assert isinstance(test_run.end, datetime) assert test_run.report_status is report_status assert test_run.traceback is None
def test_authorize_user_incorrect_password( self, test_simple_auth_manager: SimpleAdminAuthorizationManager, test_username: StringField, test_password: PasswordField, ) -> None: with db.create_session() as session: session.add( db.UserRole(login=test_username.data, password=test_password.data, role=db.Role.user)) incorrect_password_field = MagicMock() incorrect_password_field.data = "incorrect_password" assert (test_simple_auth_manager.authorize_user( username_field=test_username, password_field=incorrect_password_field) is None)
def test_authorize_user_has_user( self, test_simple_auth_manager: SimpleAdminAuthorizationManager, test_username: StringField, test_password: PasswordField, user_role: db.Role, ) -> None: with db.create_session() as session: session.add( db.UserRole(login=test_username.data, password=test_password.data, role=user_role)) user = test_simple_auth_manager.authorize_user( username_field=test_username, password_field=test_password) assert user is not None assert user.login == test_username.data assert user.password == test_password.data assert user.role is user_role
def authorize_user(self, username_field: StringField, password_field: PasswordField) -> Optional[db.BaseUser]: logger.debug("Try to authorize user '%s'...", username_field.data) user_groups = self._ldap_authenticator.get_user_groups(username_field.data, password_field.data) if not user_groups: logger.debug("LDAP user does not exist!") return None logger.debug("LDAP user groups: \n %s", pformat(user_groups)) with db.create_session(expire_on_commit=False) as s: db_user = s.query(db.UserRole).filter(db.UserRole.login == username_field.data).one_or_none() if db_user is not None: self._reassign_role_if_neccessary(session=s, user=db_user, user_groups=user_groups) return cast(db.BaseUser, db_user) logger.debug("Have not found user with username '%s'!", username_field.data) db_groups = s.query(db.GroupRole).filter(db.GroupRole.group.in_(user_groups)).all() if db_groups or self._settings.admin_group in user_groups: db_user = self._create_user(session=s, username=username_field.data) self._reassign_role_if_neccessary(session=s, user=db_user, user_groups=user_groups) return cast(db.BaseUser, db_user) logger.debug("Received groups are not supplied with db_groups: \n %s", db_groups) return None
def test_db_scenario(test_feature_container: FeatureTestContainer, test_db_user: SystemUserModel) -> ScenarioModel: with db.create_session() as session: db_feature_type = session.query(db.FeatureType).filter( db.FeatureType.name == test_feature_container.type).one() db_feature = db.Feature( name=test_feature_container.name, author=test_db_user.login, type_id=db_feature_type.id, task=["PRJ-123"], last_edited_by=test_db_user.login, file_path=test_feature_container.file_path, ) session.add(db_feature) session.flush() db_scenario = db.Scenario(feature_id=db_feature.id, text=test_feature_container.scenario) session.add(db_scenario) session.flush() return ScenarioModel.from_orm(db_scenario)
def test_correct_run_created( self, test_featureview_runtest_result: werkzeug.Response, test_db_user: SystemUserModel, test_feature_container: FeatureTestContainer, test_db_scenario: ScenarioModel, ) -> None: with db.create_session() as session: db_test_run = session.query(db.TestRun).get(test_db_scenario.id) assert db_test_run is not None test_run: TestRunModel = TestRunModel.from_orm(db_test_run) assert test_run.id == test_db_scenario.id assert isinstance(test_run.created_at, datetime) assert test_run.name == test_feature_container.name assert test_run.executed_by == test_db_user.login assert test_run.status is db.TestRunStatus.STARTED assert test_run.start is None assert test_run.end is None assert test_run.report_status is db.TestReportStatus.EMPTY assert test_run.traceback is None
def test_authorize_user_has_user( self, mocked_ldap_authenticator: MagicMock, test_ldap_auth_manager: LDAPAdminAuthorizationManager, test_db_groups: List[str], test_username: StringField, test_password: PasswordField, user_role: db.Role, ) -> None: mocked_ldap_authenticator.get_user_groups.return_value = test_db_groups with db.create_session() as session: session.add( db.UserRole(login=test_username.data, password=None, role=user_role)) user = test_ldap_auth_manager.authorize_user( username_field=test_username, password_field=test_password) assert user is not None assert user.login == test_username.data assert user.password is None # LDAP auth does not require password assert user.role is user_role
def get_emulation_run_by_id(self, emulation_run_id: int) -> EmulationRunModel: with db.create_session() as session: emulation_run: EmulationRunModel = EmulationRunModel.from_orm( self._get_emulation_run(session, emulation_run_id)) return emulation_run
def _create_user_groups(db_groups: Sequence[str]) -> None: with db.create_session() as session: for group in db_groups: session.add(db.GroupRole(group=group))
def get_feature(self, feature_id: int) -> FeatureModel: with db.create_session() as session: scenario: db.Feature = session.query( db.Feature).filter(db.Feature.id == feature_id).one() return cast(FeatureModel, FeatureModel.from_orm(scenario))
def get_draft(self, draft_id: int) -> Optional[DraftModel]: with db.create_session() as session: draft: Optional[db.Draft] = session.query(db.Draft).get(draft_id) if draft is not None: return cast(DraftModel, DraftModel.from_orm(draft)) return None