252 lines
6.7 KiB
Python
252 lines
6.7 KiB
Python
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
import unittest
|
|
|
|
from compare_locales import compare, paths
|
|
|
|
|
|
class TestTree(unittest.TestCase):
|
|
"""Test the Tree utility class
|
|
|
|
Tree value classes need to be in-place editable
|
|
"""
|
|
|
|
def test_empty_dict(self):
|
|
tree = compare.Tree(dict)
|
|
self.assertEqual(list(tree.getContent()), [])
|
|
self.assertDictEqual(tree.toJSON(), {})
|
|
|
|
def test_disjoint_dict(self):
|
|
tree = compare.Tree(dict)
|
|
tree["one/entry"]["leaf"] = 1
|
|
tree["two/other"]["leaf"] = 2
|
|
self.assertEqual(
|
|
list(tree.getContent()),
|
|
[
|
|
(0, "key", ("one", "entry")),
|
|
(1, "value", {"leaf": 1}),
|
|
(0, "key", ("two", "other")),
|
|
(1, "value", {"leaf": 2}),
|
|
],
|
|
)
|
|
self.assertDictEqual(
|
|
tree.toJSON(), {"one/entry": {"leaf": 1}, "two/other": {"leaf": 2}}
|
|
)
|
|
self.assertMultiLineEqual(
|
|
str(tree),
|
|
"""\
|
|
one/entry
|
|
{'leaf': 1}
|
|
two/other
|
|
{'leaf': 2}\
|
|
""",
|
|
)
|
|
|
|
def test_overlapping_dict(self):
|
|
tree = compare.Tree(dict)
|
|
tree["one/entry"]["leaf"] = 1
|
|
tree["one/other"]["leaf"] = 2
|
|
self.assertEqual(
|
|
list(tree.getContent()),
|
|
[
|
|
(0, "key", ("one",)),
|
|
(1, "key", ("entry",)),
|
|
(2, "value", {"leaf": 1}),
|
|
(1, "key", ("other",)),
|
|
(2, "value", {"leaf": 2}),
|
|
],
|
|
)
|
|
self.assertDictEqual(
|
|
tree.toJSON(), {"one": {"entry": {"leaf": 1}, "other": {"leaf": 2}}}
|
|
)
|
|
|
|
|
|
class TestObserver(unittest.TestCase):
|
|
def test_simple(self):
|
|
obs = compare.Observer()
|
|
f = paths.File("/some/real/sub/path", "de/sub/path", locale="de")
|
|
obs.notify("missingEntity", f, "one")
|
|
obs.notify("missingEntity", f, "two")
|
|
obs.updateStats(f, {"missing": 15})
|
|
self.assertDictEqual(
|
|
obs.toJSON(),
|
|
{
|
|
"summary": {
|
|
"de": {
|
|
"errors": 0,
|
|
"warnings": 0,
|
|
"missing": 15,
|
|
"missing_w": 0,
|
|
"report": 0,
|
|
"obsolete": 0,
|
|
"changed": 0,
|
|
"changed_w": 0,
|
|
"unchanged": 0,
|
|
"unchanged_w": 0,
|
|
"keys": 0,
|
|
}
|
|
},
|
|
"details": {
|
|
"de/sub/path": [{"missingEntity": "one"}, {"missingEntity": "two"}]
|
|
},
|
|
},
|
|
)
|
|
|
|
def test_module(self):
|
|
obs = compare.Observer()
|
|
f = paths.File("/some/real/sub/path", "path", module="sub", locale="de")
|
|
obs.notify("missingEntity", f, "one")
|
|
obs.notify("obsoleteEntity", f, "bar")
|
|
obs.notify("missingEntity", f, "two")
|
|
obs.updateStats(f, {"missing": 15})
|
|
self.assertDictEqual(
|
|
obs.toJSON(),
|
|
{
|
|
"summary": {
|
|
"de": {
|
|
"errors": 0,
|
|
"warnings": 0,
|
|
"missing": 15,
|
|
"missing_w": 0,
|
|
"report": 0,
|
|
"obsolete": 0,
|
|
"changed": 0,
|
|
"changed_w": 0,
|
|
"unchanged": 0,
|
|
"unchanged_w": 0,
|
|
"keys": 0,
|
|
}
|
|
},
|
|
"details": {
|
|
"de/sub/path": [
|
|
{"missingEntity": "one"},
|
|
{"obsoleteEntity": "bar"},
|
|
{"missingEntity": "two"},
|
|
]
|
|
},
|
|
},
|
|
)
|
|
|
|
|
|
class TestAddRemove(unittest.TestCase):
|
|
def _test(self, left, right, ref_actions):
|
|
ar = compare.AddRemove()
|
|
ar.set_left(left)
|
|
ar.set_right(right)
|
|
actions = list(ar)
|
|
self.assertListEqual(actions, ref_actions)
|
|
|
|
def test_equal(self):
|
|
self._test(
|
|
["z", "a", "p"],
|
|
["z", "a", "p"],
|
|
[
|
|
("equal", "z"),
|
|
("equal", "a"),
|
|
("equal", "p"),
|
|
],
|
|
)
|
|
|
|
def test_add_start(self):
|
|
self._test(
|
|
["a", "p"],
|
|
["z", "a", "p"],
|
|
[
|
|
("add", "z"),
|
|
("equal", "a"),
|
|
("equal", "p"),
|
|
],
|
|
)
|
|
|
|
def test_add_middle(self):
|
|
self._test(
|
|
["z", "p"],
|
|
["z", "a", "p"],
|
|
[
|
|
("equal", "z"),
|
|
("add", "a"),
|
|
("equal", "p"),
|
|
],
|
|
)
|
|
|
|
def test_add_end(self):
|
|
self._test(
|
|
["z", "a"],
|
|
["z", "a", "p"],
|
|
[
|
|
("equal", "z"),
|
|
("equal", "a"),
|
|
("add", "p"),
|
|
],
|
|
)
|
|
|
|
def test_delete_start(self):
|
|
self._test(
|
|
["z", "a", "p"],
|
|
["a", "p"],
|
|
[
|
|
("delete", "z"),
|
|
("equal", "a"),
|
|
("equal", "p"),
|
|
],
|
|
)
|
|
|
|
def test_delete_middle(self):
|
|
self._test(
|
|
["z", "a", "p"],
|
|
["z", "p"],
|
|
[
|
|
("equal", "z"),
|
|
("delete", "a"),
|
|
("equal", "p"),
|
|
],
|
|
)
|
|
|
|
def test_delete_end(self):
|
|
self._test(
|
|
["z", "a", "p"],
|
|
["z", "a"],
|
|
[
|
|
("equal", "z"),
|
|
("equal", "a"),
|
|
("delete", "p"),
|
|
],
|
|
)
|
|
|
|
def test_replace_start(self):
|
|
self._test(
|
|
["b", "a", "p"],
|
|
["z", "a", "p"],
|
|
[
|
|
("add", "z"),
|
|
("delete", "b"),
|
|
("equal", "a"),
|
|
("equal", "p"),
|
|
],
|
|
)
|
|
|
|
def test_replace_middle(self):
|
|
self._test(
|
|
["z", "b", "p"],
|
|
["z", "a", "p"],
|
|
[
|
|
("equal", "z"),
|
|
("add", "a"),
|
|
("delete", "b"),
|
|
("equal", "p"),
|
|
],
|
|
)
|
|
|
|
def test_replace_end(self):
|
|
self._test(
|
|
["z", "a", "b"],
|
|
["z", "a", "p"],
|
|
[
|
|
("equal", "z"),
|
|
("equal", "a"),
|
|
("add", "p"),
|
|
("delete", "b"),
|
|
],
|
|
)
|