def test_unknown_tag_wrong_type_comparison(self):
n1 = ScalarNode(YAML_NS + "xyz", "foo")
n2 = SequenceNode(YAML_NS + "xyz", [ystr("foo")])
self.assertFalse(nodes_equal(n1, n2))
n1 = Node(YAML_NS + "xyz", "foo", None, None)
n2 = Node(YAML_NS + "xyz", "foo", None, None)
self.assertFalse(nodes_equal(n1, n2))
def test_set_comparison(self):
null = ScalarNode(YAML_NULL_TAG, "")
n1 = MappingNode(YAML_SET_TAG, [(ystr("a"), null), (ystr("b"), null)])
n2 = MappingNode(YAML_SET_TAG, [(ystr("b"), null), (ystr("a"), null)])
n3 = MappingNode(YAML_SET_TAG, [(ystr("b"), null), (ystr("a"), null),
(ystr("c"), null)])
n4 = MappingNode(YAML_SET_TAG, [(ystr("b"), null), (ystr("a"), null),
(ystr("d"), null)])
self.assertTrue(nodes_equal(n1, n2))
self.assertFalse(nodes_equal(n1, n3))
self.assertFalse(nodes_equal(n3, n1))
self.assertFalse(nodes_equal(n3, n4))
self.assertFalse(nodes_equal(n4, n3))
def test_map_misordered_comparison(self):
n1 = MappingNode(YAML_MAP_TAG, [(ystr("a"), ystr("foo")),
(ystr("b"), ystr("bar"))])
n2 = MappingNode(YAML_MAP_TAG, [(ystr("b"), ystr("bar")),
(ystr("a"), ystr("foo"))])
n3 = MappingNode(YAML_MAP_TAG, [(ystr("a"), ystr("bar")),
(ystr("b"), ystr("foo")),
(ystr("c"), ystr("baz"))])
n4 = MappingNode(YAML_MAP_TAG, [(ystr("a"), ystr("bar")),
(ystr("b"), ystr("foo")),
(ystr("c"), ystr("xxx"))])
n5 = MappingNode(YAML_MAP_TAG, [(ystr("a"), ystr("bar")),
(ystr("b"), ystr("foo")),
(ystr("d"), ystr("xxx"))])
self.assertTrue(nodes_equal(n1, n2))
self.assertTrue(nodes_equal(n2, n1))
self.assertFalse(nodes_equal(n1, n3))
self.assertFalse(nodes_equal(n3, n4))
self.assertFalse(nodes_equal(n4, n5))
def test_seq_comparison(self):
n1 = SequenceNode(YAML_SEQ_TAG, [])
n2 = SequenceNode(YAML_SEQ_TAG, [ystr("foo")])
n3 = SequenceNode(YAML_SEQ_TAG, [ystr("foo"), ystr("bar")])
n4 = SequenceNode(YAML_SEQ_TAG, [ystr("foo"), ystr("bar")])
n5 = SequenceNode(YAML_SEQ_TAG, [ystr("bar"), ystr("foo")])
self.assertFalse(nodes_equal(n1, n2))
self.assertFalse(nodes_equal(n1, n3))
self.assertFalse(nodes_equal(n2, n3))
self.assertTrue(nodes_equal(n3, n4))
self.assertTrue(nodes_equal(n4, n3))
self.assertFalse(nodes_equal(n3, n5))
def test_unknown_tag_comparison(self):
n1 = ScalarNode(YAML_NS + "xyz", "foo")
n2 = ScalarNode(YAML_NS + "xyz", "foo")
n3 = ScalarNode(YAML_NS + "xyz", "bar")
self.assertTrue(nodes_equal(n1, n2))
self.assertFalse(nodes_equal(n1, n3))
n1 = SequenceNode(YAML_NS + "xyz", [ystr("foo")])
n2 = SequenceNode(YAML_NS + "xyz", [ystr("foo")])
n3 = SequenceNode(YAML_NS + "xyz", [ystr("bar")])
self.assertTrue(nodes_equal(n1, n2))
self.assertFalse(nodes_equal(n1, n3))
n1 = MappingNode(YAML_NS + "xyz", [(ystr("foo"), ystr("bar"))])
n2 = MappingNode(YAML_NS + "xyz", [(ystr("foo"), ystr("bar"))])
n3 = MappingNode(YAML_NS + "xyz", [(ystr("foo"), ystr("baz"))])
self.assertTrue(nodes_equal(n1, n2))
self.assertFalse(nodes_equal(n1, n3))
def run_docs(self, template_filename, resource_filenames=(),
expected_returncode=0, expected_filename=None,
expected_errors=None, template_arg=False, local_tags=True,
output_filename=None, long_parameters=True,
format=None):
args = []
if not local_tags:
args += ["--no-local-tag" if long_parameters else "-n"]
if output_filename is not None:
args += ["--output" if long_parameters else "-o", output_filename]
if format is not None:
args += ["--format" if long_parameters else "-f", format]
if template_arg:
args += ["--template" if long_parameters else "-t",
self.testdir + template_filename]
else:
args += [self.testdir + template_filename]
args += [self.testdir + r for r in resource_filenames]
log.info("Starting CLI with args=%s", args)
with LogCapture() as log_capture:
with captured_output() as (out, err):
result = main(args)
log.info("CLI returned with code %d" % result)
out = out.getvalue()
err = err.getvalue()
if out:
log.debug("stdout: %s", out)
if err:
log.debug("stderr: %s", err)
# Redisplay the log records
for record in log_capture.records:
getLogger(record.name).handle(record)
self.assertEquals(result, expected_returncode)
if expected_filename is not None:
if format == "json":
load = json_load
load_str = json_loads
else:
load = load_str = yaml_compose_all
if output_filename:
with open(output_filename, "r") as fd:
actual = list(load(fd))
else:
actual = list(load_str(out))
with open(self.testdir + expected_filename, "r") as fd:
expected = list(load(fd))
for a_el, e_el in zip(actual, expected):
if format == "json":
self.assertEqual(a_el, e_el)
else:
try:
self.assertTrue(nodes_equal(a_el, e_el))
except:
log.error("actual=%s", a_el)
log.error("expect=%s", e_el)
raise
log_capture = str(log_capture)
if expected_errors is not None:
if isinstance(expected_errors, string_types):
self.assertIn(expected_errors, log_capture)
else:
for error in expected_errors:
self.assertIn(error, log_capture)
return
def test_unequal_tags(self):
n1 = ScalarNode(YAML_STR_TAG, "foo")
n2 = ScalarNode(YAML_NS + "bar", "foo")
self.assertFalse(nodes_equal(n1, n2))