99 lines
4.2 KiB
Python
99 lines
4.2 KiB
Python
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, mask_csharp_comments
|
|
|
|
|
|
class ParityGenerationTests(unittest.TestCase):
|
|
def test_comment_masking_preserves_offsets_and_ignores_fake_tests(self) -> None:
|
|
source = '''var url = "https://example.com/[Test]"; // [Test]\n/* [TestCase(1)] */\n[Test]\n'''
|
|
masked = mask_csharp_comments(source)
|
|
self.assertEqual(len(masked), len(source))
|
|
self.assertEqual(masked.count("\n"), source.count("\n"))
|
|
self.assertIn('"https://example.com/[Test]"', masked)
|
|
self.assertEqual(masked.count("[Test]"), 2)
|
|
|
|
with tempfile.TemporaryDirectory() as temporary:
|
|
upstream = Path(temporary)
|
|
tests = upstream / "LibreMetaverse.Tests"
|
|
tests.mkdir()
|
|
(upstream / "LibreMetaverse.Rendering.Tests").mkdir()
|
|
(tests / "Comments.cs").write_text(
|
|
"""public class Comments
|
|
{
|
|
// [Test]
|
|
// public void CommentedOut() {}
|
|
[Test]
|
|
[TestCase(1)]
|
|
[TestCase(2)]
|
|
public void Cases(int value) {}
|
|
}
|
|
"""
|
|
)
|
|
self.assertEqual([case["parameter_case"] for case in extract_tests(upstream)], ["1", "2"])
|
|
|
|
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()
|