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
