def test_post_existing_issue(authorized_api_request, get_issue, put_project):
put_project(create_project())
authorized_api_request("POST", get_project_issues_url("PRJ"),
{"issue": MINIMAL_SERIALIZED_ISSUE})
response = authorized_api_request("POST", get_project_issues_url("PRJ"),
{"issue": FULL_SERIALIZED_ISSUE})
assert response.status_code == 201
loaded_issue = get_issue(EntityId(response.json["id"]))
assert loaded_issue.__dict__ == BoundIssue(EntityId("PRJ-2"),
FULL_ISSUE).__dict__
def test_get_object_types_by_project(objects_tracker_model, put_project):
object_id1 = EntityId(OBJECT_ID1)
object_id2 = EntityId(OBJECT_ID2)
put_project(create_project(object_id1.project_id))
put_project(create_project(object_id2.project_id))
objects_tracker_model.track_object(object_id1, EntityType.deliverable)
objects_tracker_model.track_object(object_id2, EntityType.issue)
assert objects_tracker_model.get_objects_types_by_project(object_id1) == {
object_id1: EntityType.deliverable,
}
def test_post_existing_deliverable(authorized_api_request, get_deliverable,
put_project):
put_project(create_project())
authorized_api_request("POST", get_project_deliverables_url("PRJ"),
{"deliverable": MINIMAL_SERIALIZED_DELIVERABLE})
response = authorized_api_request(
"POST", get_project_deliverables_url("PRJ"),
{"deliverable": FULL_SERIALIZED_DELIVERABLE})
assert response.status_code == 201
loaded_deliverable = get_deliverable(EntityId(response.json["id"]))
assert loaded_deliverable.__dict__ == BoundDeliverable(
EntityId("PRJ-2"), FULL_DELIVERABLE).__dict__
def get_timesheets(serializer: TimesheetsSerializer,
timesheets_api: TimesheetsApi, object_id, offset, limit):
with transaction.manager:
timesheets = timesheets_api.get_timesheets(EntityId(object_id), offset,
limit)
serialized_timesheets = serializer.serialize_timesheets(timesheets)
return {"timesheets": serialized_timesheets}, 200
def _get_entity_data(self, entity_ids: List[str]):
query = select(
[
ISSUES_TABLE.c.hour_rate_amount,
ISSUES_TABLE.c.hour_rate_currency,
ISSUES_TABLE.c.estimated_duration,
ISSUES_TABLE.c.object_id,
]
).where(
ISSUES_TABLE.c.object_id.in_(entity_ids)
)
result = self._session.execute(query)
entity_data = {}
for row in result:
amount = row["hour_rate_amount"]
currency = row["hour_rate_currency"]
hour_rate = None
if amount is not None and currency:
hour_rate = Money(
amount=amount,
currency=currency,
)
entity_data[EntityId(row["object_id"])] = EntityStatisticsData(
hour_rate=hour_rate,
estimated_duration=row["estimated_duration"]
)
return entity_data
def test_post_issue(
authorized_api_request,
get_issue,
serialized_issue,
issue,
put_project,
):
put_project(create_project())
response = authorized_api_request("POST", get_project_issues_url("PRJ"),
{"issue": serialized_issue})
assert response.status_code == 201
loaded_issue = get_issue(EntityId(response.json["id"]))
assert loaded_issue.__dict__ == BoundIssue(EntityId("PRJ-1"),
issue).__dict__
def create_bound_deliverable(
object_id="PRJ-1",
name="Dummy project",
status=DeliverableStatus.open,
description="Description",
date_opened=datetime(year=2019,
month=1,
day=1,
hour=10,
minute=30,
second=5),
date_closed=datetime(year=2019,
month=1,
day=2,
hour=10,
minute=30,
second=5),
deadline=datetime(year=2019, month=1, day=3, hour=10, minute=30, second=5),
):
return BoundDeliverable(object_id=EntityId(object_id),
deliverable=create_deliverable(
name=name,
status=status,
description=description,
date_opened=date_opened,
date_closed=date_closed,
deadline=deadline,
))
def _row_to_entity(row) -> BoundIssue:
hour_rate = None
if row["hour_rate_amount"] and row["hour_rate_currency"]:
hour_rate = Money(
amount=row["hour_rate_amount"],
currency=Currency(row["hour_rate_currency"]),
)
return BoundIssue(object_id=EntityId(row["object_id"]),
issue=Issue(
name=row["name"],
status=IssueStatus(row["status"]),
type_=IssueType(row["type"]),
priority=IssuePriority(row["priority"]),
date_opened=row["date_opened"],
date_closed=row["date_closed"],
deadline=row["deadline"],
description=row["description"],
external_type=row["external_type"],
estimated_duration=row["estimated_duration"],
hour_rate=hour_rate,
files=[],
links=[],
tags=[],
tasks=[],
))
def post_timesheet(deserializer: TimesheetsDeserializer,
timesheets_api: TimesheetsApi, body, object_id):
timesheet = deserializer.deserialize_timesheet(body["timesheet"])
entity_id = EntityId(object_id)
with transaction.manager:
bound_timesheet = timesheets_api.create_timesheet(entity_id, timesheet)
return {"id": bound_timesheet.simple_id.simple_id}, 201
def test_post_deliverable(
authorized_api_request,
get_deliverable,
serialized_deliverable,
deliverable,
put_project,
):
put_project(create_project())
response = authorized_api_request("POST",
get_project_deliverables_url("PRJ"),
{"deliverable": serialized_deliverable})
assert response.status_code == 201
loaded_deliverable = get_deliverable(EntityId(response.json["id"]))
assert loaded_deliverable.__dict__ == BoundDeliverable(
EntityId("PRJ-1"), deliverable).__dict__
def test_create_timesheet_non_existing_entity(authorized_api_request):
response = authorized_api_request(
"POST",
get_timesheet_url(EntityId("ABC-1")),
{"timesheet": SERIALIZED_TIMESHEET}
)
assert response.status_code == 404
assert response.json["code"] == "object_does_not_exist"
def test_untrack_object(objects_tracker_model, put_project):
object_id = EntityId(OBJECT_ID1)
put_project(create_project(object_id.project_id))
objects_tracker_model.track_object(object_id, EntityType.deliverable)
objects_tracker_model.untrack_object(object_id)
assert objects_tracker_model.get_objects_types([object_id]) == {}
def get_project_issues(
issues_api: IssuesApi,
serializer: IssuesSerializer,
project_id,
offset,
limit,
related_object_id=None,
):
# pylint: disable=too-many-arguments
with transaction.manager:
issues = issues_api.get_issues(
EntityId(project_id),
related_entity_id=EntityId(related_object_id) if related_object_id else None,
offset=offset,
limit=limit,
)
return {"issues": serializer.serialize_issues(issues)}, 200
def get_expenditures(expenditures_api: ExpendituresApi,
serializer: ExpendituresSerializer, object_id, offset,
limit):
with transaction.manager:
expenditures = expenditures_api.get_expenditures(
EntityId(object_id), offset, limit)
serialized_expenditures = serializer.serialize_expenditures(expenditures)
return {"expenditures": serialized_expenditures}, 200
def test_get_object_type(objects_tracker_model, put_project):
object_id1 = EntityId(OBJECT_ID1)
put_project(create_project(object_id1.project_id))
objects_tracker_model.track_object(object_id1, EntityType.deliverable)
assert objects_tracker_model.get_object_type(
object_id1) == EntityType.deliverable
def _row_to_entity(row) -> BoundDeliverable:
return BoundDeliverable(object_id=EntityId(row["object_id"]),
deliverable=Deliverable(
name=row["name"],
status=DeliverableStatus(row["status"]),
date_opened=row["date_opened"],
date_closed=row["date_closed"],
deadline=row["deadline"],
description=row["description"],
))
def post_issue(
issues_api: IssuesApi,
deserializer: IssuesDeserializer,
project_id,
body,
):
issue = deserializer.deserialize_issue(body["issue"])
with transaction.manager:
bound_issue = issues_api.create_issue(EntityId(project_id), issue)
return {"id": bound_issue.object_id.full_id}, 201
def post_deliverable(
deliverables_api: DeliverablesApi,
deserializer: DeliverableDeserializer,
project_id,
body,
):
deliverable = deserializer.deserialize_deliverable(body["deliverable"])
with transaction.manager:
bound_deliverable = deliverables_api.create_deliverable(EntityId(project_id), deliverable)
return {"id": bound_deliverable.object_id.full_id}, 201
def test_delete_issue(issues_model, put_project):
put_project(create_project())
issue = create_bound_issue()
issues_model.put_issue(issue)
issues_model.delete_issue(issue.object_id)
assert not issues_model.get_issues(EntityId(issue.object_id.project_id),
related_entity_id=None,
offset=0,
limit=1)
def get_related_entities_ids(self, entity_id: EntityId):
query = select(
[ENTITY_LINKS_TABLE.c.object_id]
).where(
ENTITY_LINKS_TABLE.c.other_object_id == entity_id.full_id
)
result = self._session.execute(query)
return [
EntityId(row["object_id"])
for row
in result
]
def test_put_issue(authorized_api_request, get_issue, put_project):
put_project(create_project())
response = authorized_api_request("POST", get_project_issues_url("PRJ"),
{"issue": MINIMAL_SERIALIZED_ISSUE})
issue_id = EntityId(response.json["id"])
response = authorized_api_request("PUT", get_issue_url(str(issue_id)),
{"issue": FULL_SERIALIZED_ISSUE})
assert response.status_code == 200
loaded_issue = get_issue(issue_id)
assert loaded_issue.__dict__ == BoundIssue(issue_id, FULL_ISSUE).__dict__
def test_delete_deliverable(deliverables_model, put_project):
put_project(create_project())
deliverable = create_bound_deliverable()
deliverables_model.put_deliverable(deliverable)
deliverables_model.delete_deliverable(deliverable.object_id)
assert not deliverables_model.get_deliverables(EntityId(
deliverable.object_id.project_id),
related_entity_id=None,
offset=0,
limit=1)
def post_expenditure(
deserializer: ExpendituresDeserializer,
expenditures_api: ExpendituresApi,
body,
object_id,
):
expenditure = deserializer.deserialize_expenditure(body["expenditure"])
entity_id = EntityId(object_id)
with transaction.manager:
bound_expenditure = expenditures_api.create_expenditure(
entity_id, expenditure)
return {"id": bound_expenditure.simple_id.simple_id}, 201
def get_project_ids(self, project_id: EntityId):
query = select(
[OBJECTS_TRACKER_TABLE.c.id]
).where(
OBJECTS_TRACKER_TABLE.c.project_id == project_id.full_id
).where(
OBJECTS_TRACKER_TABLE.c.type != EntityType.project.value
)
result = self._session.execute(query)
return [
EntityId(row["id"])
for row
in result
]
def create_bound_issue(object_id="PRJ-1",
name="Dummy issue",
status=IssueStatus.open,
type=IssueType.bug,
priority=IssuePriority.critical,
description="Description issue",
date_opened=datetime(year=2019,
month=1,
day=1,
hour=10,
minute=30,
second=5),
date_closed=datetime(year=2019,
month=1,
day=2,
hour=10,
minute=30,
second=5),
deadline=datetime(year=2019,
month=1,
day=3,
hour=10,
minute=30,
second=5),
estimated_duration=Decimal(10),
external_type="external_type",
files=None,
links=None,
tags=None,
tasks=None,
hour_rate=None):
return BoundIssue(object_id=EntityId(object_id),
issue=create_issue(
name=name,
status=status,
type=type,
priority=priority,
description=description,
date_opened=date_opened,
date_closed=date_closed,
deadline=deadline,
estimated_duration=estimated_duration,
external_type=external_type,
files=files,
links=links,
tags=tags,
tasks=tasks,
hour_rate=hour_rate,
))
def test_get_issues_filter_project(issues_model, put_project):
put_project(create_project())
put_project(create_project("AAA"))
issue1 = create_bound_issue()
issues_model.put_issue(issue1)
issue2 = create_bound_issue(object_id="AAA", name="Other issue")
issues_model.put_issue(issue2)
issues = issues_model.get_issues(EntityId(issue1.object_id.project_id),
related_entity_id=None,
offset=0,
limit=2)
assert issues == [issue1]
def test_put_deliverable(authorized_api_request, get_deliverable, put_project):
put_project(create_project())
response = authorized_api_request(
"POST", get_project_deliverables_url("PRJ"),
{"deliverable": MINIMAL_SERIALIZED_DELIVERABLE})
deliverable_id = EntityId(response.json["id"])
response = authorized_api_request(
"PUT", get_deliverable_url(str(deliverable_id)),
{"deliverable": FULL_SERIALIZED_DELIVERABLE})
assert response.status_code == 200
loaded_deliverable = get_deliverable(deliverable_id)
assert loaded_deliverable.__dict__ == BoundDeliverable(
deliverable_id, FULL_DELIVERABLE).__dict__
def get_deliverable(
deliverables_api: DeliverablesApi,
statistics_api: StatisticsApi,
serializer: DeliverableSerializer,
statistics_serializer: StatisticsSerializer,
deliverable_id,
):
deliverable_id = EntityId(deliverable_id)
with transaction.manager:
deliverable = deliverables_api.get_deliverable(deliverable_id)
statistics = statistics_api.get_deliverable_statistics(deliverable_id)
return {
"deliverable": serializer.serialize_deliverable(deliverable),
"stats": statistics_serializer.serialize_statistics(statistics),
}, 200
def test_get_deliverables(deliverables_model, put_project):
put_project(create_project())
deliverable1 = create_bound_deliverable()
deliverables_model.put_deliverable(deliverable1)
deliverable2 = create_bound_deliverable(
object_id=deliverable1.object_id.project_id + "-2",
name="Other deliverable")
deliverables_model.put_deliverable(deliverable2)
deliverables = deliverables_model.get_deliverables(EntityId(
deliverable1.object_id.project_id),
related_entity_id=None,
offset=0,
limit=2)
assert deliverables == [deliverable1, deliverable2]
def _get_burned_time(self, entity_ids: List[str]):
query = select(
[
TIMESHEETS_TABLE.c.parent_id,
func.sum(TIMESHEETS_TABLE.c.duration).label("burned_duration"),
]
).group_by(
TIMESHEETS_TABLE.c.parent_id
).where(
TIMESHEETS_TABLE.c.parent_id.in_(entity_ids)
)
result = self._session.execute(query)
return {
EntityId(row["parent_id"]): row["burned_duration"]
for row
in result
}