def test_with_args_positional_override(self): class Positional(Keyable): def __init__(self, *args, **kwargs): self.args = args self.kwargs = kwargs self.doc = kwargs.get("doc") # Leave the positional argument (list type) blank, but specify a category. GenericCategorizedList = ListOf.with_args(category="my category") # Get lists with different types (but the same category). categorized_string_list = GenericCategorizedList(String()) categorized_cert_list = GenericCategorizedList(Positional()) self.assertEqual("my category", categorized_string_list.category) self.assertEqual("my category", categorized_cert_list.category) # ListOf(...) takes only one positional arg, so StringList(Positional()) should raise. StringList = ListOf.with_args(String()) self.assertRaises(Exception, lambda: StringList(Positional())) # ListOf(...) needs exactly one positional arg, so GenericCategorizedList() should also raise. self.assertRaises(Exception, lambda: CategorizedCertificateList()) # Confirm that positional args are pulled from the proper location MyPositional = Positional.with_args("a", doc="default docs") p0 = MyPositional() p0doc = MyPositional(doc="some docs") # Passing positional args to the factory constructor and the contructor is not allowed self.assertRaises(Exception, lambda: MyPositional("b")) self.assertRaises(Exception, lambda: MyPositional("x, y")) self.assertEqual(("a", ), p0.args) self.assertEqual("default docs", p0.doc) self.assertEqual(("a", ), p0doc.args) self.assertEqual("some docs", p0doc.doc)
def test_ListOf_exclude(self): a = ListOf(String()) self.assertFalse(a.exclude_bigquery) self.assertFalse(a.exclude_elasticsearch) b = ListOf(String(exclude=["bigquery"])) self.assertTrue(b.exclude_bigquery) self.assertFalse(b.exclude_elasticsearch) c = ListOf(String(), exclude=["elasticsearch"]) self.assertFalse(c.exclude_bigquery) self.assertTrue(c.exclude_elasticsearch) d = ListOf(String(exclude=["bigquery"]), exclude=["elasticsearch"]) self.assertTrue(d.exclude_bigquery) self.assertTrue(d.exclude_elasticsearch)
def setUp(self): self.maxDiff = 10000 heartbleed = SubRecord( { # with explicit proto field indices "heartbeat_support": Boolean(pr_index=11), "heartbleed_vulnerable": Boolean(category="Vulnerabilities", pr_ignore=True), "timestamp": DateTime(pr_index=10) }, pr_index=77) self.host = Record({ "ipstr": IPv4Address(required=True, examples=["8.8.8.8"], pr_index=1), "ip": Unsigned32BitInteger(doc="The IP Address of the host", pr_index=2), Port(443): SubRecord({ "tls": String(pr_index=1), "heartbleed": heartbleed }, category="heartbleed", pr_index=3), "tags": ListOf(String(), pr_index=47) })
def test_with_args(self): Certificate = SubRecord.with_args({}, doc="A parsed certificate.") CertificateChain = ListOf.with_args(Certificate()) AlgorithmType = String.with_args(doc="An algorithm identifier", examples=["a", "b", "c"]) OtherType = SubRecord({ "ca": Certificate(doc="The CA certificate."), "host": Certificate(doc="The host certificate."), "chain": CertificateChain(doc="The certificate chain."), "host_alg": AlgorithmType(doc="The host algorithm", examples=["x", "y"]), "client_alg": AlgorithmType(doc="The client algorithm"), "sig_alg": AlgorithmType(examples=["p", "q"]), }) # Check default self.assertEqual("A parsed certificate.", Certificate().doc) # Check overridden self.assertEqual("The CA certificate.", OtherType.definition["ca"].doc) self.assertEqual("The host certificate.", OtherType.definition["host"].doc) # Check ListOf self.assertEqual("The certificate chain.", OtherType.definition["chain"].doc) # Check that instance default is used in child self.assertEqual("A parsed certificate.", OtherType.definition["chain"].object_.doc) # Check Leaf type doc overrides self.assertEqual("The host algorithm", OtherType.definition["host_alg"].doc) self.assertEqual("The client algorithm", OtherType.definition["client_alg"].doc) self.assertEqual("An algorithm identifier", OtherType.definition["sig_alg"].doc) # Check that examples are inherited self.assertEqual(["a", "b", "c"], OtherType.definition["client_alg"].examples) # Check that examples are overridden self.assertEqual(["x", "y"], OtherType.definition["host_alg"].examples) self.assertEqual(["p", "q"], OtherType.definition["sig_alg"].examples)
class PathLogUnitTests(unittest.TestCase): sub_type = SubRecord( { "sub1": String(), "sub2": SubRecord({ "sub2sub1": Unsigned8BitInteger(), "sub2sub2": NestedListOf(String(), "sub2sub2.subrecord_name"), }), "sub3": Enum(values=["a", "b", "c"]) }, validation_policy="error") SCHEMA = Record( { "a": SubRecord({ "a1": String(), "a2": ListOf(sub_type), "a3": Unsigned8BitInteger(), }), "b": String(), }, validation_policy="error") def test_good(self): good = { "a": { "a1": "{a.a1}:good", "a2": [ { "sub1": "{a.a2[0].sub1}:good", "sub2": { "sub2sub1": 1, "sub2sub2": [ "{a.a2[0].sub2.sub2sub2[0]}:good", "{a.a2[0].sub2.sub2sub2[1]}:good", ], }, }, { "sub1": "{a.a2[1].sub1}:good", "sub2": { "sub2sub1": 1, "sub2sub2": [], }, }, ], "a3": 1, }, "b": "{b}:good", } self.SCHEMA.validate(good, policy="error") def test_bad_root(self): bad1 = { "does_not_exist": "{does_not_exist}:bad1", "a": { "a1": "{a.a1}:bad1", "a2": [ { "sub1": "{a.a2[0].sub1}:bad1", "sub2": { "sub2sub1": 1, "sub2sub2": [ "{a.a2[0].sub2.sub2sub2[0]}:bad1", "{a.a2[0].sub2.sub2sub2[1]}:bad1", ], }, }, { "sub1": "{a.a2[1].sub1}:bad1", "sub2": { "sub2sub1": 1, "sub2sub2": [], }, }, ], "a3": 1, }, "b": "{b}:bad1", } try: self.SCHEMA.validate(bad1, policy="error") self.assertTrue(False, "bad1 failed to fail") except DataValidationException as e: self.assertTrue(not e.path) del (bad1["does_not_exist"]) bad1["b"] = 23 try: self.SCHEMA.validate(bad1, policy="error") self.assertTrue(False, "bad1 failed to fail") except DataValidationException as e: self.assertEquals(e.path, ["b"]) def test_bad_a_key(self): bad = { "a": { "does_not_exist": 23, "a1": "{a.a1}:bad1", "a2": [ { "sub1": "{a.a2[0].sub1}:bad1", "sub2": { "sub2sub1": 1, "sub2sub2": [ "{a.a2[0].sub2.sub2sub2[0]}:bad1", "{a.a2[0].sub2.sub2sub2[1]}:bad1", ], }, }, { "sub1": "{a.a2[1].sub1}:bad1", "sub2": { "sub2sub1": 1, "sub2sub2": [], }, }, ], "a3": 1, }, "b": "{b}:bad1", } try: self.SCHEMA.validate(bad, policy="error") self.assertTrue(False, "bad failed to fail") except DataValidationException as e: self.assertEqual(e.path, ["a"]) del (bad["a"]["does_not_exist"]) bad["a"]["a3"] = "not an int" try: ret = self.SCHEMA.validate(bad, policy="error") self.assertTrue(False, "bad failed to fail") except DataValidationException as e: self.assertEqual(e.path, ["a", "a3"]) def test_bad_deep_key(self): bad = { "a": { "a1": "{a.a1}:bad", "a2": [ { "sub1": "{a.a2[0].sub1}:bad", "sub2": { "sub2sub1": 1, "sub2sub2": [ "{a.a2[0].sub2.sub2sub2[0]}:bad", "{a.a2[0].sub2.sub2sub2[1]}:bad", ], "does_not_exist": "fake", }, }, { "sub1": "{a.a2[1].sub1}:bad1", "sub2": { "sub2sub1": 1, "sub2sub2": [], }, }, ], "a3": 1, }, "b": "{b}:bad1", } try: self.SCHEMA.validate(bad, policy="error") self.assertTrue(False, "failed to fail") except DataValidationException as e: self.assertEqual(e.path, [ "a", "a2", 0, "sub2", ]) del (bad["a"]["a2"][0]["sub2"]["does_not_exist"]) bad["a"]["a2"][0]["sub2"]["sub2sub2"][1] = {"wrong type": "bad type"} try: self.SCHEMA.validate(bad, policy="error") self.assertTrue(False, "bad failed to fail") except DataValidationException as e: self.assertEqual(e.path, ["a", "a2", 0, "sub2", "sub2sub2", 1])
from zschema.keys import Port from zschema.compounds import ListOf, Record, SubRecord from zschema.leaves import Boolean, DateTime, IPv4Address, String, Unsigned32BitInteger heartbleed = SubRecord({ "heartbeat_support": Boolean(), "heartbleed_vulnerable": Boolean(), "timestamp": DateTime() }) host = Record({ "ipstr": IPv4Address(required=True), "ip": Unsigned32BitInteger(), Port(443): SubRecord({ "tls": String(), "heartbleed": heartbleed }), "tags": ListOf(String()) })