Skip to content

[SYNPY-1295] Trim down integration tests #1199

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 8 commits into from
Apr 29, 2025
254 changes: 115 additions & 139 deletions tests/integration/synapseclient/models/async/test_activity_async.py
Original file line number Diff line number Diff line change
Expand Up @@ -21,17 +21,60 @@ def init(self, syn: Synapse, schedule_for_cleanup: Callable[..., None]) -> None:
self.syn = syn
self.schedule_for_cleanup = schedule_for_cleanup

async def test_store_with_parent_and_id(self, project: Synapse_Project) -> None:
# GIVEN a file in a project
async def create_file_with_activity(
self,
project: Synapse_Project,
activity: Activity = None,
store_file: bool = True,
) -> File:
"""Helper to create a file with optional activity"""
path = utils.make_bogus_uuid_file()
file = File(
parent_id=project["id"], path=path, name=f"bogus_file_{str(uuid.uuid4())}"
parent_id=project["id"],
path=path,
name=f"bogus_file_{str(uuid.uuid4())}",
activity=activity,
)
self.schedule_for_cleanup(file.path)
await file.store_async()
self.schedule_for_cleanup(file.id)

# AND an activity I want to store
if store_file:
await file.store_async()
self.schedule_for_cleanup(file.id)

return file

async def verify_activity_properties(
self, activity, expected_name, expected_description, has_references=False
):
"""Helper to verify common activity properties"""
assert activity.name == expected_name
assert activity.description == expected_description
assert activity.id is not None
assert activity.etag is not None
assert activity.created_on is not None
assert activity.modified_on is not None
assert activity.created_by is not None
assert activity.modified_by is not None

if has_references:
assert activity.used[0].url == BOGUS_URL
assert activity.used[0].name == "example"
assert activity.used[1].target_id == "syn456"
assert activity.used[1].target_version_number == 1
assert activity.executed[0].url == BOGUS_URL
assert activity.executed[0].name == "example"
assert activity.executed[1].target_id == "syn789"
assert activity.executed[1].target_version_number == 1
else:
assert activity.used == []
assert activity.executed == []

async def test_activity_lifecycle(self, project: Synapse_Project) -> None:
"""Test complete activity lifecycle - create, update, retrieve, and delete"""
# GIVEN a file in a project
file = await self.create_file_with_activity(project)

# AND an activity with references
activity = Activity(
name="some_name",
description="some_description",
Expand All @@ -49,94 +92,77 @@ async def test_store_with_parent_and_id(self, project: Synapse_Project) -> None:
result = await activity.store_async(parent=file)
self.schedule_for_cleanup(result.id)

# THEN I expect the activity to be stored
# THEN I expect the activity to be stored correctly
assert result == activity
assert result.id is not None
assert result.etag is not None
assert result.created_on is not None
assert result.modified_on is not None
assert result.created_by is not None
assert result.modified_by is not None
assert result.used[0].url == BOGUS_URL
assert result.used[0].name == "example"
assert result.used[1].target_id == "syn456"
assert result.used[1].target_version_number == 1
assert result.executed[0].url == BOGUS_URL
assert result.executed[0].name == "example"
assert result.executed[1].target_id == "syn789"
assert result.executed[1].target_version_number == 1

# GIVEN our already stored activity
modified_activity = activity

# WHEN I modify the activity
modified_activity.name = "modified_name"
modified_activity.description = "modified_description"

# AND I store the modified activity without a parent
modified_result = await modified_activity.store_async()
await self.verify_activity_properties(
result, "some_name", "some_description", has_references=True
)

# WHEN I modify and store the activity
result.name = "modified_name"
result.description = "modified_description"
modified_result = await result.store_async()

# THEN I expect the modified activity to be stored
assert modified_result == modified_activity
assert modified_result.id is not None
assert modified_result.etag is not None
assert modified_result.created_on is not None
assert modified_result.modified_on is not None
assert modified_result.created_by is not None
assert modified_result.modified_by is not None
assert modified_result.name == "modified_name"
assert modified_result.description == "modified_description"
assert modified_result.used[0].url == BOGUS_URL
assert modified_result.used[0].name == "example"
assert modified_result.used[1].target_id == "syn456"
assert modified_result.used[1].target_version_number == 1
assert modified_result.executed[0].url == BOGUS_URL
assert modified_result.executed[0].name == "example"
assert modified_result.executed[1].target_id == "syn789"
assert modified_result.executed[1].target_version_number == 1
await self.verify_activity_properties(
modified_result,
"modified_name",
"modified_description",
has_references=True,
)

# Clean up
# WHEN I get the activity from the file
retrieved_activity = await Activity.from_parent_async(parent=file)

# THEN I expect the retrieved activity to match the modified one
assert retrieved_activity.name == "modified_name"
assert retrieved_activity.description == "modified_description"
await self.verify_activity_properties(
retrieved_activity,
"modified_name",
"modified_description",
has_references=True,
)

# WHEN I delete the activity
await result.delete_async(parent=file)

async def test_store_with_no_references(self, project: Synapse_Project) -> None:
# GIVEN a file in a project that has an activity with no references
# THEN I expect no activity to be associated with the file
activity_after_delete = await Activity.from_parent_async(parent=file)
assert activity_after_delete is None

async def test_store_activity_with_no_references(
self, project: Synapse_Project
) -> None:
"""Test storing an activity without references"""
# GIVEN an activity with no references
activity = Activity(
name="some_name",
description="some_description",
name="simple_activity",
description="activity with no references",
)
path = utils.make_bogus_uuid_file()
file = File(
parent_id=project["id"],
path=path,
name=f"bogus_file_{str(uuid.uuid4())}",
activity=activity,
)
self.schedule_for_cleanup(file.path)

# WHEN I store the file with the activity
await file.store_async()
self.schedule_for_cleanup(file.id)

# THEN I expect the activity to have been stored
assert file.activity.name == activity.name
assert file.activity.description == activity.description
assert file.activity.used == []
assert file.activity.executed == []
assert file.activity.id is not None
assert file.activity.etag is not None
assert file.activity.created_on is not None
assert file.activity.modified_on is not None
assert file.activity.created_by is not None
assert file.activity.modified_by is not None
# AND a file with that activity
file = await self.create_file_with_activity(project, activity=activity)

# THEN I expect the activity to have been stored properly
await self.verify_activity_properties(
file.activity,
"simple_activity",
"activity with no references",
has_references=False,
)

# Clean up
await file.activity.delete_async(parent=file)

async def test_from_parent(self, project: Synapse_Project) -> None:
# GIVEN a file in a project that has an activity
async def test_store_activity_via_file_creation(
self, project: Synapse_Project
) -> None:
"""Test storing an activity as part of file creation"""
# GIVEN an activity with references
activity = Activity(
name="some_name",
description="some_description",
name="file_activity",
description="activity stored with file",
used=[
UsedURL(name="example", url=BOGUS_URL),
UsedEntity(target_id="syn456", target_version_number=1),
Expand All @@ -146,67 +172,17 @@ async def test_from_parent(self, project: Synapse_Project) -> None:
UsedEntity(target_id="syn789", target_version_number=1),
],
)
path = utils.make_bogus_uuid_file()
file = File(
parent_id=project["id"],
path=path,
name=f"bogus_file_{str(uuid.uuid4())}",
activity=activity,
)
self.schedule_for_cleanup(file.path)
await file.store_async()
self.schedule_for_cleanup(file.id)

# WHEN I get the activity from the file
result = await Activity.from_parent_async(parent=file)

# THEN I expect the activity to be returned
assert result == activity
assert result.name == "some_name"
assert result.description == "some_description"
assert result.id is not None
assert result.etag is not None
assert result.created_on is not None
assert result.modified_on is not None
assert result.created_by is not None
assert result.modified_by is not None
assert result.used[0].url == BOGUS_URL
assert result.used[0].name == "example"
assert result.used[1].target_id == "syn456"
assert result.used[1].target_version_number == 1
assert result.executed[0].url == BOGUS_URL
assert result.executed[0].name == "example"
assert result.executed[1].target_id == "syn789"
assert result.executed[1].target_version_number == 1
# WHEN I create a file with the activity
file = await self.create_file_with_activity(project, activity=activity)

# Clean up
await result.delete_async(parent=file)

async def test_delete(self, project: Synapse_Project) -> None:
# GIVEN a file in a project that has an activity
activity = Activity(
name="some_name",
description="some_description",
# THEN I expect the activity to have been stored with the file
await self.verify_activity_properties(
file.activity,
"file_activity",
"activity stored with file",
has_references=True,
)
path = utils.make_bogus_uuid_file()
file = File(
parent_id=project["id"],
path=path,
name=f"bogus_file_{str(uuid.uuid4())}",
activity=activity,
)
self.schedule_for_cleanup(file.path)

# AND I store the file with the activity
await file.store_async()
self.schedule_for_cleanup(file.id)

# AND the activity exists
assert file.activity.id is not None

# WHEN I delete the activity
# Clean up
await file.activity.delete_async(parent=file)

# THEN I expect to receieve None
activity = await Activity.from_parent_async(parent=file)
assert activity is None
Loading
Loading