def test_uploader_identity_ensure_member_role_can_be_changed_no_member(
uploader_identity: UploaderIdentity, new_role: str) -> None:
assert uploader_identity.can_member_role_be_changed(None,
new_role) is False
with pytest.raises(ValidationError) as e:
uploader_identity.ensure_member_role_can_be_changed(None, new_role)
assert "Invalid member" in str(e.value)
def test_uploader_identity_ensure_member_role_can_be_changed_invalid_role(
uploader_identity: UploaderIdentity, role: Optional[str]) -> None:
member = UploaderIdentityMemberFactory(
identity=uploader_identity, role=UploaderIdentityMemberRole.member)
assert uploader_identity.can_member_role_be_changed(member, role) is False
with pytest.raises(ValidationError) as e:
uploader_identity.ensure_member_role_can_be_changed(member, role)
assert "New role is invalid" in str(e.value)
def test_uploader_identity_ensure_member_can_be_removed_wrong_identity(
uploader_identity: UploaderIdentity, ) -> None:
member = UploaderIdentityMemberFactory(
role=UploaderIdentityMemberRole.member)
assert uploader_identity.can_member_be_removed(member) is False
with pytest.raises(ValidationError) as e:
uploader_identity.ensure_member_can_be_removed(member)
assert "Member is not a part of this uploader identity" in str(e.value)
def test_uploader_identity_creation(user, author_name, should_fail):
user.username = author_name
if should_fail:
with pytest.raises(ValidationError):
UploaderIdentity.get_or_create_for_user(user)
else:
identity = UploaderIdentity.get_or_create_for_user(user)
assert identity.name == author_name
def test_uploader_identity_ensure_user_can_disband_has_packages(
uploader_identity: UploaderIdentity, package: Package) -> None:
member = UploaderIdentityMemberFactory(
identity=uploader_identity, role=UploaderIdentityMemberRole.owner)
assert uploader_identity.can_user_disband(member.user) is False
with pytest.raises(ValidationError) as e:
uploader_identity.ensure_user_can_disband(member.user)
assert "Unable to disband teams with packages" in str(e.value)
def test_uploader_identity_ensure_member_role_can_be_changed_last_owner(
uploader_identity: UploaderIdentity, ) -> None:
new_role = UploaderIdentityMemberRole.member
member = UploaderIdentityMemberFactory(
identity=uploader_identity, role=UploaderIdentityMemberRole.owner)
assert uploader_identity.can_member_role_be_changed(member,
new_role) is False
with pytest.raises(ValidationError) as e:
uploader_identity.ensure_member_role_can_be_changed(member, new_role)
assert "Cannot remove last owner from team" in str(e.value)
def test_uploader_identity_ensure_member_can_be_removed_last_owner(
uploader_identity: UploaderIdentity, ) -> None:
owner = UploaderIdentityMemberFactory(
identity=uploader_identity,
role=UploaderIdentityMemberRole.owner,
)
assert uploader_identity.members.count() == 1
assert uploader_identity.can_member_be_removed(owner) is False
with pytest.raises(ValidationError) as e:
uploader_identity.ensure_member_can_be_removed(owner)
assert "Cannot remove last owner from team" in str(e.value)
def test_uploader_identity_ensure_member_can_be_removed(
uploader_identity: UploaderIdentity, role: str) -> None:
member = UploaderIdentityMemberFactory(
role=role,
identity=uploader_identity,
)
if role == UploaderIdentityMemberRole.owner:
UploaderIdentityMemberFactory(
identity=uploader_identity,
role=UploaderIdentityMemberRole.owner,
)
assert uploader_identity.can_member_be_removed(member) is True
uploader_identity.ensure_member_can_be_removed(member)
def test_uploader_identity_ensure_member_role_can_be_changed(
uploader_identity: UploaderIdentity, old_role: str,
new_role: str) -> None:
member = UploaderIdentityMemberFactory(identity=uploader_identity,
role=old_role)
is_last_owner = (old_role == UploaderIdentityMemberRole.owner
and new_role == UploaderIdentityMemberRole.member)
if is_last_owner:
UploaderIdentityMemberFactory(identity=uploader_identity,
role=UploaderIdentityMemberRole.owner)
assert uploader_identity.can_member_role_be_changed(member,
new_role) is True
uploader_identity.ensure_member_role_can_be_changed(member, new_role)
def test_uploader_identity_add_member(uploader_identity: UploaderIdentity,
role: str) -> None:
assert uploader_identity.members.count() == 0
membership = uploader_identity.add_member(UserFactory(), role)
assert membership.role == role
assert uploader_identity.members.count() == 1
assert membership in uploader_identity.members.all()
def test_uploader_identity_get_default_for_user_conflict(user_type: str):
user = TestUserTypes.get_user_by_type(user_type)
if user and user.is_authenticated:
UploaderIdentity.objects.create(
name=strip_unsupported_characters(user.username))
default_identity = UploaderIdentity.get_default_for_user(user)
assert default_identity is None
def get_form_kwargs(self, *args, **kwargs):
kwargs = super(PackageCreateView,
self).get_form_kwargs(*args, **kwargs)
kwargs["user"] = self.request.user
kwargs["identity"] = UploaderIdentity.get_or_create_for_user(
self.request.user)
return kwargs
def test_package_upload(user, manifest_v1_data, community):
icon_raw = io.BytesIO()
icon = Image.new("RGB", (256, 256), "#FF0000")
icon.save(icon_raw, format="PNG")
readme = "# Test readme".encode("utf-8")
manifest = json.dumps(manifest_v1_data).encode("utf-8")
files = [
("README.md", readme),
("icon.png", icon_raw.getvalue()),
("manifest.json", manifest),
]
zip_raw = io.BytesIO()
with ZipFile(zip_raw, "a", ZIP_DEFLATED, False) as zip_file:
for name, data in files:
zip_file.writestr(name, data)
file_data = {"file": SimpleUploadedFile("mod.zip", zip_raw.getvalue())}
identity = UploaderIdentity.get_or_create_for_user(user)
form = PackageUploadForm(
user=user,
identity=identity,
files=file_data,
community=community,
)
assert form.is_valid()
version = form.save()
assert version.name == manifest_v1_data["name"]
assert version.package.owner == identity
def get_form_kwargs(self, *args, **kwargs):
kwargs = super().get_form_kwargs(*args, **kwargs)
kwargs["user"] = self.request.user
kwargs["identity"] = UploaderIdentity.get_or_create_for_user(
self.request.user
)
kwargs["community"] = self.request.community
return kwargs
def get_form_kwargs(self, *args, **kwargs):
kwargs = super().get_form_kwargs(*args, **kwargs)
kwargs["user"] = self.request.user
kwargs["community"] = self.request.community
kwargs["initial"] = {
"team": UploaderIdentity.get_default_for_user(self.request.user),
"communities": [self.request.community],
}
return kwargs
def test_manifest_v1_null_fields(user, manifest_v1_data, field):
identity = UploaderIdentity.get_or_create_for_user(user)
manifest_v1_data[field] = None
serializer = ManifestV1Serializer(
user=user,
uploader=identity,
data=manifest_v1_data,
)
assert serializer.is_valid() is False
assert "This field may not be null." in str(serializer.errors[field][0])
def test_manifest_v1_missing_fields(user, manifest_v1_data, field):
identity = UploaderIdentity.get_or_create_for_user(user)
del manifest_v1_data[field]
serializer = ManifestV1Serializer(
user=user,
uploader=identity,
data=manifest_v1_data,
)
assert serializer.is_valid() is False
assert "This field is required." in str(serializer.errors[field][0])
def test_uploader_identity_create_for_user(
user: UserType, username: str, expected_name: Optional[str]) -> None:
user.username = username
identity = UploaderIdentity.get_or_create_for_user(user)
if expected_name:
assert identity.name == expected_name
assert identity.members.count() == 1
assert identity.members.first().user == user
else:
assert identity is None
def test_manifest_v1_update(user, manifest_v1_data):
identity = UploaderIdentity.get_or_create_for_user(user)
serializer = ManifestV1Serializer(
user=user,
uploader=identity,
data=manifest_v1_data,
)
assert serializer.is_valid()
with pytest.raises(NotImplementedError) as exc:
serializer.update({}, serializer.validated_data)
assert ".update() is not supported" in str(exc.value)
def test_manifest_v1_blank_fields(user, manifest_v1_data, field, empty_val, should_fail):
identity = UploaderIdentity.get_or_create_for_user(user)
manifest_v1_data[field] = empty_val
serializer = ManifestV1Serializer(
user=user,
uploader=identity,
data=manifest_v1_data,
)
if should_fail:
assert serializer.is_valid() is False
assert "This field may not be blank." in str(serializer.errors[field][0])
else:
assert serializer.is_valid() is True
def test_manifest_v1_serializer_dependencies_invalid(user, manifest_v1_data, dependencies, error: str):
identity = UploaderIdentity.get_or_create_for_user(user)
manifest_v1_data["dependencies"] = dependencies
serializer = ManifestV1Serializer(
user=user,
uploader=identity,
data=manifest_v1_data,
)
if error:
assert serializer.is_valid() is False
assert error in str(serializer.errors["dependencies"][0])
else:
assert serializer.is_valid() is True
def test_manifest_v1_serializer_website_url_validation(user, manifest_v1_data, url: str, error: str):
identity = UploaderIdentity.get_or_create_for_user(user)
manifest_v1_data["website_url"] = url
serializer = ManifestV1Serializer(
user=user,
uploader=identity,
data=manifest_v1_data,
)
if error:
assert serializer.is_valid() is False
assert error in str(serializer.errors["website_url"][0])
else:
assert serializer.is_valid() is True
def test_manifest_v1_serializer_version_number_validation(user, manifest_v1_data, version: str, error: str):
identity = UploaderIdentity.get_or_create_for_user(user)
manifest_v1_data["version_number"] = version
serializer = ManifestV1Serializer(
user=user,
uploader=identity,
data=manifest_v1_data,
)
if error:
assert serializer.is_valid() is False
assert error in str(serializer.errors["version_number"][0])
else:
assert serializer.is_valid() is True
def test_manifest_v1_invalid_key_formatting(user):
data = {
"name": "name",
"versionNumber": "1.0.0",
"websiteUrl": "",
"description": "",
"dependencies": [],
}
identity = UploaderIdentity.get_or_create_for_user(user)
deserializer = ManifestV1Serializer(
user=user,
uploader=identity,
data=data,
)
assert deserializer.is_valid() is False
def test_uploader_identity_create_for_user_name_taken(user: UserType,
role: str) -> None:
would_be_name = strip_unsupported_characters(user.username)
identity = UploaderIdentity.objects.create(name=would_be_name)
if role:
UploaderIdentityMember.objects.create(
identity=identity,
user=user,
role=UploaderIdentityMemberRole.owner,
)
result = UploaderIdentity.get_or_create_for_user(user)
if role:
assert result == identity
else:
assert result is None
def test_manifest_v1_serializer_unresolved_dependency(user, manifest_v1_data, package_version):
identity = UploaderIdentity.get_or_create_for_user(user)
manifest_v1_data["dependencies"] = [
"invalid-package-1.0.0",
str(package_version.reference),
"invalid-package-2.0.0",
]
serializer = ManifestV1Serializer(
user=user,
uploader=identity,
data=manifest_v1_data,
)
assert serializer.is_valid() is False
assert len(serializer.errors["dependencies"]) == 2
assert "No matching package found for reference" in str(serializer.errors["dependencies"][0])
assert "No matching package found for reference" in str(serializer.errors["dependencies"][2])
def test_package_upload_with_extra_data(user, community, manifest_v1_data):
icon_raw = io.BytesIO()
icon = Image.new("RGB", (256, 256), "#FF0000")
icon.save(icon_raw, format="PNG")
readme = "# Test readme".encode("utf-8")
manifest = json.dumps(manifest_v1_data).encode("utf-8")
files = [
("README.md", readme),
("icon.png", icon_raw.getvalue()),
("manifest.json", manifest),
]
zip_raw = io.BytesIO()
with ZipFile(zip_raw, "a", ZIP_DEFLATED, False) as zip_file:
for name, data in files:
zip_file.writestr(name, data)
category = PackageCategory.objects.create(
name="Test Category",
slug="test-category",
community=community,
)
file_data = {"file": SimpleUploadedFile("mod.zip", zip_raw.getvalue())}
identity = UploaderIdentity.get_or_create_for_user(user)
form = PackageUploadForm(
user=user,
files=file_data,
community=community,
data={
"categories": [category.pk],
"has_nsfw_content": True,
"team": identity.name,
"communities": [community.identifier],
},
)
assert form.is_valid()
version = form.save()
assert version.name == manifest_v1_data["name"]
assert version.package.owner == identity
listing = PackageListing.objects.filter(package=version.package).first()
assert listing.categories.count() == 1
assert listing.categories.first() == category
assert listing.has_nsfw_content is True
def test_uploader_identity_get_default_for_user(
user: UserType, existing_team_role: Optional[str]) -> None:
existing_identity = None
if existing_team_role:
existing_identity = UploaderIdentity.objects.create(name="TestTeam")
UploaderIdentityMember.objects.create(
identity=existing_identity,
user=user,
role=existing_team_role,
)
default_identity = UploaderIdentity.get_default_for_user(user)
if existing_team_role:
assert default_identity == existing_identity
else:
assert bool(default_identity)
def test_manifest_v1_serializer_dependencies_valid(user, manifest_v1_data):
reference = PackageReference.parse("actual_package-reference-1.0.0")
PackageVersionFactory.create(
package=PackageFactory.create(
owner=UploaderIdentityFactory.create(name=reference.namespace, ),
name=reference.name,
),
name=reference.name,
version_number=reference.version_str,
)
identity = UploaderIdentity.get_or_create_for_user(user)
manifest_v1_data["dependencies"] = [str(reference)]
serializer = ManifestV1Serializer(
user=user,
uploader=identity,
data=manifest_v1_data,
)
assert serializer.is_valid() is True
def test_manifest_v1_serializer_too_many_dependencies(user, manifest_v1_data):
identity = UploaderIdentity.get_or_create_for_user(user)
reference_strings = [
f"user-package-{i}.{i}.{i}" for i in range(101)
]
manifest_v1_data["dependencies"] = reference_strings
serializer = ManifestV1Serializer(
user=user,
uploader=identity,
data=manifest_v1_data,
)
# Patch the validator because we don't want to generate 101 actual packages here
serializer.fields["dependencies"].child.validators = [PackageReferenceValidator(
require_version=True,
resolve=False # Otherwise the same, but don't try to resolve the references
)]
assert serializer.is_valid() is False
assert len(serializer.errors["dependencies"]) == 1
assert "Ensure this field has no more than 100 elements." in str(serializer.errors["dependencies"][0])