# Copyright New York University and the TUF contributors

# SPDX-License-Identifier: MIT OR Apache-2.0

"""Test __eq__ implementations of classes inside tuf/api/metadata.py."""

from __future__ import annotations

import copy

import os

import sys

import unittest

from typing import Any, ClassVar

from securesystemslib.signer import SSlibKey

from tests import utils

from tuf.api.metadata import (

TOP_LEVEL_ROLE_NAMES,

DelegatedRole,

Delegations,

Metadata,

MetaFile,

Role,

Signature,

SuccinctRoles,

TargetFile,

)

class TestMetadataComparisons(unittest.TestCase):

"""Test __eq__ for all classes inside tuf/api/metadata.py."""

metadata: ClassVar[dict[str, bytes]]

@classmethod

def setUpClass(cls) -> None:

cls.repo_dir = os.path.join(

utils.TESTS_DIR, "repository_data", "repository", "metadata"

)

# Store class instances in this dict instead of creating them inside the

# test function in order to escape the need for reinitialization of the

# instances on each run of the test function.

cls.objects = {}

for md in TOP_LEVEL_ROLE_NAMES:

with open(os.path.join(cls.repo_dir, f"{md}.json"), "rb") as f:

data = f.read()

cls.objects[md.capitalize()] = Metadata.from_bytes(data).signed

cls.objects["Metadata"] = Metadata(cls.objects["Timestamp"], {})

cls.objects["Signed"] = cls.objects["Timestamp"]

cls.objects["Key"] = SSlibKey(

"id", "rsa", "rsassa-pss-sha256", {"public": "foo"}

)

cls.objects["Role"] = Role(["keyid1", "keyid2"], 3)

cls.objects["MetaFile"] = MetaFile(1, 12, {"sha256": "abc"})

cls.objects["DelegatedRole"] = DelegatedRole("a", [], 1, False, ["d"])

cls.objects["SuccinctRoles"] = SuccinctRoles(["keyid"], 1, 8, "foo")

cls.objects["Delegations"] = Delegations(

{"keyid": cls.objects["Key"]}, {"a": cls.objects["DelegatedRole"]}

)

cls.objects["TargetFile"] = TargetFile(

1, {"sha256": "abc"}, "file1.txt"

)

# Keys are class names.

# Values are dictionaries containing attribute names and their new values.

classes_attributes_modifications = {

"Metadata": {"signed": None, "signatures": None},

"Signed": {"version": -1, "spec_version": "0.0.0"},

"Key": {"keyid": "a", "keytype": "foo", "scheme": "b", "keyval": "b"},

"Role": {"keyids": [], "threshold": 10},

"Root": {"consistent_snapshot": None, "keys": {}},

"MetaFile": {"version": None, "length": None, "hashes": {}},

"Timestamp": {"snapshot_meta": None},

"Snapshot": {"meta": None},

"DelegatedRole": {

"name": "",

"terminating": None,

"paths": [""],

"path_hash_prefixes": [""],

},

"SuccinctRoles": {"bit_length": 0, "name_prefix": ""},

"Delegations": {"keys": {}, "roles": {}},

"TargetFile": {"length": 0, "hashes": {}, "path": ""},

"Targets": {"targets": {}, "delegations": []},

}

@utils.run_sub_tests_with_dataset(classes_attributes_modifications)

def test_classes_eq_(self, test_case_data: dict[str, Any]) -> None:

obj = self.objects[self.case_name]

# Assert that obj is not equal to an object from another type

self.assertNotEqual(obj, "")

obj_2 = copy.deepcopy(obj)

# Assert that __eq__ works for equal objects.

self.assertEqual(obj, obj_2)

for attr, value in test_case_data.items():

original_value = getattr(obj_2, attr)

setattr(obj_2, attr, value)

# Assert that the original object != modified one.

self.assertNotEqual(obj, obj_2, f"Failed case: {attr}")

# Restore the old value of the attribute.

setattr(obj_2, attr, original_value)

def test_md_eq_signatures_reversed_order(self) -> None:

# Test comparing objects with same signatures but different order.

# Remove all signatures and create new ones.

md: Metadata = self.objects["Metadata"]

md.signatures = {"a": Signature("a", "a"), "b": Signature("b", "b")}

md_2 = copy.deepcopy(md)

# Reverse signatures order in md_2.

md_2.signatures = dict(reversed(md_2.signatures.items()))

# Assert that both objects are not the same because of signatures order.

self.assertNotEqual(md, md_2)

# but if we fix the signatures order they will be equal

md_2.signatures = {"a": Signature("a", "a"), "b": Signature("b", "b")}

self.assertEqual(md, md_2)

def test_md_eq_special_signatures_tests(self) -> None:

# Test that metadata objects with different signatures are not equal.

md: Metadata = self.objects["Metadata"]

md_2 = copy.deepcopy(md)

md_2.signatures = {}

self.assertNotEqual(md, md_2)

# Test that metadata objects with empty signatures are equal

md.signatures = {}

self.assertEqual(md, md_2)

# Metadata objects with different signatures types are not equal.

md_2.signatures = "" # type: ignore[assignment]

self.assertNotEqual(md, md_2)

def test_delegations_eq_roles_reversed_order(self) -> None:

# Test comparing objects with same delegated roles but different order.

role_one_dict = {

"keyids": ["keyid1"],

"name": "a",

"terminating": False,

"paths": ["fn1"],

"threshold": 1,

}

role_two_dict = {

"keyids": ["keyid2"],

"name": "b",

"terminating": True,

"paths": ["fn2"],

"threshold": 4,

}

delegations_dict = {

"keys": {

"keyid2": {

"keytype": "ed25519",

"scheme": "ed25519",

"keyval": {"public": "bar"},

}

},

"roles": [role_one_dict, role_two_dict],

}

delegations = Delegations.from_dict(copy.deepcopy(delegations_dict))

# Create a second delegations obj with reversed roles order

delegations_2 = copy.deepcopy(delegations)

assert isinstance(delegations.roles, dict)

delegations_2.roles = dict(reversed(delegations.roles.items()))

# Both objects are not the equal because of delegated roles order.

self.assertNotEqual(delegations, delegations_2)

# but if we fix the delegated roles order they will be equal

delegations_2.roles = delegations.roles

self.assertEqual(delegations, delegations_2)

# Run unit test.

if __name__ == "__main__":

utils.configure_test_logging(sys.argv)

unittest.main()