Add durable NUnit parity harness

tools/test_generate_surface.py

@@ -0,0 +1,71 @@
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from generate_surface import check_test_parity, extract_tests, generate_tests
+
+
+class ParityGenerationTests(unittest.TestCase):
+    def test_reviewed_rust_test_is_preserved_and_excluded_from_placeholders(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            upstream = root / "upstream"
+            source = upstream / "LibreMetaverse.Tests" / "ExampleTests.cs"
+            source.parent.mkdir(parents=True)
+            (upstream / "LibreMetaverse.Rendering.Tests").mkdir()
+            source.write_text(
+                """namespace LibreMetaverse.Tests;
+[Category("Example")]
+public class ExampleTests
+{
+    [TestCase(1, Description = "one")]
+    public void KeepsIdentity(int value) { Assert.That(value, Is.EqualTo(1)); }
+    [Test]
+    public void RemainsPending() { Assert.Pass(); }
+}
+"""
+            )
+            reviewed, _pending = extract_tests(upstream)
+            output = root / "output"
+            rust_file = output / "tests" / "compat" / "tests" / "example.rs"
+            rust_file.parent.mkdir(parents=True)
+            rust_file.write_text(
+                f"// parity-case: {reviewed['id']} {reviewed['body_sha256']} translated\n"
+                "#[test]\nfn translated_case() {}\n"
+            )
+            original = rust_file.read_bytes()
+
+            with patch("generate_surface.EXPECTED_TESTS", 2):
+                self.assertEqual(generate_tests(upstream, output), 2)
+                self.assertEqual(rust_file.read_bytes(), original)
+                generated = output / "tests/compat/tests/generated_parity.rs"
+                self.assertNotIn(reviewed["id"], generated.read_text())
+                catalog = json.loads((output / "tests/upstream-tests.json").read_text())
+                self.assertEqual(catalog["tests"][0]["status"], "translated")
+                self.assertEqual(catalog["tests"][0]["rust_test"], "translated_case")
+                self.assertEqual(check_test_parity(output)["unreviewed"], 1)
+
+                generated_text = generated.read_text()
+                generated.write_text(generated_text.replace("// parity-case:", "// missing-case:", 1))
+                with self.assertRaisesRegex(RuntimeError, "Missing Rust parity cases"):
+                    check_test_parity(output)
+
+                generated.write_text(generated_text)
+                pending = catalog["tests"][1]
+                duplicate = (
+                    f"// parity-case: {pending['id']} {pending['body_sha256']} pending\n"
+                    "#[test]\nfn duplicate_case() {}\n"
+                )
+                generated.write_text(duplicate + generated_text)
+                with self.assertRaisesRegex(RuntimeError, "Duplicate Rust parity cases"):
+                    check_test_parity(output)
+
+                generated.write_text(generated_text.replace(pending["body_sha256"], "0" * 64, 1))
+                with self.assertRaisesRegex(RuntimeError, "Drifted reviewed C# test bodies"):
+                    check_test_parity(output)
+
+
+if __name__ == "__main__":
+    unittest.main()