# HG changeset patch
# User Franz Glasner <fzglas.hg@dom66.de>
# Date 1689811457 -7200
# Node ID d2b43423fa4c5b9da1f76520bfed4f8e594e8e0f
# Parent  2376224a97179dae8a730800a9c8b2359f88e5e5
Some new test cases with ref-false, when-ref-false, ref-not-existss, when-ref-not-exists

diff -r 2376224a9717 -r d2b43423fa4c tests/test_schema.py
--- a/tests/test_schema.py	Wed Jul 19 15:19:23 2023 +0200
+++ b/tests/test_schema.py	Thu Jul 20 02:04:17 2023 +0200
@@ -807,6 +807,24 @@
         self.assertIsNone(r["new-key"])
         self.assertFalse("cond" in r)
 
+    def test_simple_replace_when_ref_false(self):
+        schema = data_schema._Schema(
+            None, True, {"$type": None,
+                         "require": ["huhu", "haha"],
+                         "cond": [
+                             {"when-ref-false": '#foo2',
+                              "then": {
+                                  "require": ["r1", "r2", "r3"],
+                                  "new-key": None,
+                              }}
+                         ]})
+        r = data_schema.process_schema_conditionals(schema, self._ctx)
+        self.assertIsNot(r, schema)
+        self.assertEqual(["r1", "r2", "r3"], r["require"])
+        self.assertTrue("new-key" in r)
+        self.assertIsNone(r["new-key"])
+        self.assertFalse("cond" in r)
+
     def test_simple_replace_when_ref_true_2(self):
         schema = data_schema._Schema(
             None, True, {"$type": None,
@@ -881,6 +899,28 @@
         self.assertFalse("new-key3" in r)
         self.assertFalse("cond" in r)
 
+    def test_simple_replace_when_ref_not_exists(self):
+        schema = data_schema._Schema(
+            None, True, {"$type": None,
+                         "require": ["huhu", "haha"],
+                         "cond": [
+                             {"when-ref-not-exists": '#foo3-non-existing',
+                              "then": {
+                                  "require": ["r1", "r2", "r3"],
+                                  "new-key": None,
+                              }},
+                             {"when": True,
+                              "then": {
+                                  "new-key3": "val"}}
+                         ]})
+        r = data_schema.process_schema_conditionals(schema, self._ctx)
+        self.assertIsNot(r, schema)
+        self.assertEqual(["r1", "r2", "r3"], r["require"])
+        self.assertTrue("new-key" in r)
+        self.assertIsNone(r["new-key"])
+        self.assertFalse("new-key3" in r)
+        self.assertFalse("cond" in r)
+
     def test_simple_replace_when_ref_exists_2(self):
         schema = data_schema._Schema(
             None, True, {"$type": None,
@@ -903,6 +943,28 @@
         self.assertFalse("new-key3" in r)
         self.assertFalse("cond" in r)
 
+    def test_simple_replace_when_ref_not_exists_2(self):
+        schema = data_schema._Schema(
+            None, True, {"$type": None,
+                         "require": ["huhu", "haha"],
+                         "cond": [
+                             {"when": {"ref-not-exists": '#foo3-non-existing'},
+                              "then": {
+                                  "require": ["r1", "r2", "r3"],
+                                  "new-key": None,
+                              }},
+                             {"when": True,
+                              "then": {
+                                  "new-key3": "val"}}
+                         ]})
+        r = data_schema.process_schema_conditionals(schema, self._ctx)
+        self.assertIsNot(r, schema)
+        self.assertEqual(["r1", "r2", "r3"], r["require"])
+        self.assertTrue("new-key" in r)
+        self.assertIsNone(r["new-key"])
+        self.assertFalse("new-key3" in r)
+        self.assertFalse("cond" in r)
+
     def test_simple_replace_when_ref_exists_is_false(self):
         schema = data_schema._Schema(
             None, True, {"$type": None,
@@ -958,6 +1020,21 @@
         self.assertIsNot(r, schema)
         self.assertEqual("string", r["$type"])
 
+    def test_allOf_true_2(self):
+        schema = data_schema._Schema(
+            None, True, {"cond": [
+                {"when": {"all-of": [
+                    True,
+                    {"ref-not-exists": '#foo3-not-existing'},
+                    {"ref-true": '#foo'}]},
+                 "then": {"$type": "string"}},
+                {"when": True,
+                 "then": {"$type": None}}
+            ]})
+        r = data_schema.process_schema_conditionals(schema, self._ctx)
+        self.assertIsNot(r, schema)
+        self.assertEqual("string", r["$type"])
+
     def test_allOf_false(self):
         schema = data_schema._Schema(
             None, True, {"cond": [
@@ -973,6 +1050,21 @@
         self.assertIsNot(r, schema)
         self.assertIsNone(r["$type"])
 
+    def test_allOf_false_2(self):
+        schema = data_schema._Schema(
+            None, True, {"cond": [
+                {"when": {"all-of": [
+                    True,
+                    {"ref-not-exists": '#foo2'},
+                    {"ref-true": '#foo'}]},
+                 "then": {"$type": "string"}},
+                {"when": True,
+                 "then": {"$type": None}}
+            ]})
+        r = data_schema.process_schema_conditionals(schema, self._ctx)
+        self.assertIsNot(r, schema)
+        self.assertIsNone(r["$type"])
+
     def test_short_allOf_true(self):
         schema = data_schema._Schema(
             None, True, {"cond": [
@@ -1018,6 +1110,21 @@
         self.assertIsNot(r, schema)
         self.assertEqual("string", r["$type"])
 
+    def test_anyOf_true_2(self):
+        schema = data_schema._Schema(
+            None, True, {"cond": [
+                {"when": {"any-of": [
+                    False,
+                    {"ref-not-exists": '#foo3-non'},
+                    {"ref-false": '#foo2'}]},
+                 "then": {"$type": "string"}},
+                {"when": True,
+                 "then": {"$type": None}}
+            ]})
+        r = data_schema.process_schema_conditionals(schema, self._ctx)
+        self.assertIsNot(r, schema)
+        self.assertEqual("string", r["$type"])
+
     def test_anyOf_false(self):
         schema = data_schema._Schema(
             None, True, {"cond": [
@@ -1048,6 +1155,20 @@
         self.assertIsNot(r, schema)
         self.assertEqual("string", r["$type"])
 
+    def test_oneOf_true_2(self):
+        schema = data_schema._Schema(
+            None, True, {"cond": [
+                {"when": {"one-of": [
+                    False,
+                    {"not": {"ref-false": '#foo'}}]},
+                 "then": {"$type": "string"}},
+                {"when": True,
+                 "then": {"$type": None}}
+            ]})
+        r = data_schema.process_schema_conditionals(schema, self._ctx)
+        self.assertIsNot(r, schema)
+        self.assertEqual("string", r["$type"])
+
     def test_oneOf_false(self):
         schema = data_schema._Schema(
             None, True, {"cond": [