def test_Any(self):
# Test conditions for valid arguments.
any_schema = SCHEMA.Any()
self.assertTrue(any_schema.matches('test'))
self.assertTrue(any_schema.matches(123))
self.assertTrue(any_schema.matches(['test']))
self.assertTrue(any_schema.matches({'word': 'definition'}))
self.assertTrue(any_schema.matches(True))
def test_AllOf(self):
# Test conditions for valid arguments.
allof_schema = SCHEMA.AllOf([SCHEMA.Any(),
SCHEMA.AnyString(),
SCHEMA.String('a')])
self.assertTrue(allof_schema.matches('a'))
# Test conditions for invalid arguments.
self.assertFalse(allof_schema.matches('b'))
# Test conditions for invalid arguments in a schema definition.
self.assertRaises(securesystemslib.exceptions.FormatError, SCHEMA.AllOf, 1)
self.assertRaises(securesystemslib.exceptions.FormatError, SCHEMA.AllOf, [1])
self.assertRaises(securesystemslib.exceptions.FormatError, SCHEMA.AllOf, {'a': 1})
self.assertRaises(securesystemslib.exceptions.FormatError, SCHEMA.AllOf, [SCHEMA.AnyString(), 1])
keyid=KEYID_SCHEMA,
keyval=SCHEMA.Object(public=GPG_ED25519_PUBKEYVAL_SCHEMA,
private=SCHEMA.String("")))
GPG_ED25519_PUBKEY_SCHEMA = _create_gpg_pubkey_with_subkey_schema(
_GPG_ED25519_PUBKEY_SCHEMA)
GPG_PUBKEY_SCHEMA = SCHEMA.OneOf(
[GPG_RSA_PUBKEY_SCHEMA, GPG_DSA_PUBKEY_SCHEMA, GPG_ED25519_PUBKEY_SCHEMA])
GPG_SIGNATURE_SCHEMA = SCHEMA.Object(
object_name="SIGNATURE_SCHEMA",
keyid=KEYID_SCHEMA,
short_keyid=SCHEMA.Optional(KEYID_SCHEMA),
other_headers=HEX_SCHEMA,
signature=HEX_SCHEMA,
info=SCHEMA.Optional(SCHEMA.Any()),
)
# A single signature of an object. Indicates the signature, and the KEYID of
# the signing key. I debated making the signature schema not contain the key
# ID and instead have the signatures of a file be a dictionary with the key
# being the keyid and the value being the signature schema without the keyid.
# That would be under the argument that a key should only be able to sign a
# file once.
SIGNATURE_SCHEMA = SCHEMA.Object(object_name='SIGNATURE_SCHEMA',
keyid=KEYID_SCHEMA,
sig=HEX_SCHEMA)
# A dict where the dict keys hold a keyid and the dict values a key object.
KEYDICT_SCHEMA = SCHEMA.DictOf(key_schema=KEYID_SCHEMA,
value_schema=KEY_SCHEMA)
# A dict of roles where the dict keys are role names and the dict values holding
# the role data/information.
ROLEDICT_SCHEMA = SCHEMA.DictOf(key_schema=ROLENAME_SCHEMA,
value_schema=ROLE_SCHEMA)
# A dictionary of ROLEDICT, where dictionary keys can be repository names, and
# dictionary values containing information for each role available on the
# repository (corresponding to the repository belonging to named repository in
# the dictionary key)
ROLEDICTDB_SCHEMA = SCHEMA.DictOf(key_schema=sslib_formats.NAME_SCHEMA,
value_schema=ROLEDICT_SCHEMA)
# Command argument list, as used by the CLI tool.
# Example: {'keytype': ed25519, 'expires': 365,}
COMMAND_SCHEMA = SCHEMA.DictOf(key_schema=sslib_formats.NAME_SCHEMA,
value_schema=SCHEMA.Any())
# A dictionary holding version information.
VERSION_SCHEMA = SCHEMA.Object(object_name='VERSION_SCHEMA',
major=SCHEMA.Integer(lo=0),
minor=SCHEMA.Integer(lo=0),
fix=SCHEMA.Integer(lo=0))
# A value that is either True or False, on or off, etc.
BOOLEAN_SCHEMA = SCHEMA.Boolean()
# A hexadecimal value in '23432df87ab..' format.
HASH_SCHEMA = SCHEMA.RegularExpression(r'[a-fA-F0-9]+')
# A key identifier (e.g., a hexadecimal value identifying an RSA key).
KEYID_SCHEMA = HASH_SCHEMA
DSA_PUBKEYVAL_SCHEMA = ssl_schema.Object(object_name="DSA_PUBKEYVAL_SCHEMA",
y=ssl_formats.HEX_SCHEMA,
p=ssl_formats.HEX_SCHEMA,
q=ssl_formats.HEX_SCHEMA,
g=ssl_formats.HEX_SCHEMA)
# We have to define DSA_PUBKEY_SCHEMA in two steps, because it is
# self-referential. Here we define a shallow _DSA_PUBKEY_SCHEMA, which we use
# below to create the self-referential DSA_PUBKEY_SCHEMA.
_DSA_PUBKEY_SCHEMA = ssl_schema.Object(
object_name="DSA_PUBKEY_SCHEMA",
type=ssl_schema.String("dsa"),
method=ssl_schema.String(PGP_DSA_PUBKEY_METHOD_STRING),
hashes=ssl_schema.ListOf(ssl_schema.String(GPG_HASH_ALGORITHM_STRING)),
keyid=ssl_formats.KEYID_SCHEMA,
keyval=ssl_schema.Object(public=DSA_PUBKEYVAL_SCHEMA,
private=ssl_schema.String("")))
DSA_PUBKEY_SCHEMA = _create_pubkey_with_subkey_schema(_DSA_PUBKEY_SCHEMA)
PUBKEY_SCHEMA = ssl_schema.OneOf([RSA_PUBKEY_SCHEMA, DSA_PUBKEY_SCHEMA])
SIGNATURE_SCHEMA = ssl_schema.Object(
object_name="SIGNATURE_SCHEMA",
keyid=ssl_formats.KEYID_SCHEMA,
short_keyid=ssl_schema.Optional(ssl_formats.KEYID_SCHEMA),
other_headers=ssl_formats.HEX_SCHEMA,
signature=ssl_formats.HEX_SCHEMA,
info=ssl_schema.Optional(ssl_schema.Any()),
)
