Merge pull request #55 from boukeversteegh/pr/xfail-tests

Add intentionally failing test-cases for unimplemented bug-fixes

Author: nat-n

betterproto/tests/README.md

@@ -73,3 +73,18 @@ The following tests are automatically executed for all cases:
   - `betterproto/tests/output_reference` — *reference implementation classes*
 - `pipenv run test`
 
+## Intentionally Failing tests
+
+The standard test suite includes tests that fail by intention. These tests document known bugs and missing features that are intended to be corrented in the future.
+
+When running `pytest`, they show up as `x` or  `X` in the test results.
+
+```
+betterproto/tests/test_inputs.py ..x...x..x...x.X........xx........x.....x.......x.xx....x...................... [ 84%]
+```
+
+- `.` — PASSED
+- `x` — XFAIL: expected failure
+- `X` — XPASS: expected failure, but still passed
+
+Test cases marked for expected failure are declared in [inputs/xfail.py](inputs.xfail.py)

betterproto/tests/generate.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python
+import glob
 import os
+import shutil
 import sys
 from typing import Set
 
@@ -17,33 +19,48 @@
 os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
 
 
+def clear_directory(path: str):
+    for file_or_directory in glob.glob(os.path.join(path, "*")):
+        if os.path.isdir(file_or_directory):
+            shutil.rmtree(file_or_directory)
+        else:
+            os.remove(file_or_directory)
+
+
 def generate(whitelist: Set[str]):
     path_whitelist = {os.path.realpath(e) for e in whitelist if os.path.exists(e)}
     name_whitelist = {e for e in whitelist if not os.path.exists(e)}
 
     test_case_names = set(get_directories(inputs_path))
 
     for test_case_name in sorted(test_case_names):
-        test_case_path = os.path.realpath(os.path.join(inputs_path, test_case_name))
+        test_case_input_path = os.path.realpath(
+            os.path.join(inputs_path, test_case_name)
+        )
 
         if (
             whitelist
-            and test_case_path not in path_whitelist
+            and test_case_input_path not in path_whitelist
             and test_case_name not in name_whitelist
         ):
             continue
 
-        case_output_dir_reference = os.path.join(output_path_reference, test_case_name)
-        case_output_dir_betterproto = os.path.join(
+        test_case_output_path_reference = os.path.join(
+            output_path_reference, test_case_name
+        )
+        test_case_output_path_betterproto = os.path.join(
             output_path_betterproto, test_case_name
         )
 
         print(f"Generating output for {test_case_name}")
-        os.makedirs(case_output_dir_reference, exist_ok=True)
-        os.makedirs(case_output_dir_betterproto, exist_ok=True)
+        os.makedirs(test_case_output_path_reference, exist_ok=True)
+        os.makedirs(test_case_output_path_betterproto, exist_ok=True)
+
+        clear_directory(test_case_output_path_reference)
+        clear_directory(test_case_output_path_betterproto)
 
-        protoc_reference(test_case_path, case_output_dir_reference)
-        protoc_plugin(test_case_path, case_output_dir_betterproto)
+        protoc_reference(test_case_input_path, test_case_output_path_reference)
+        protoc_plugin(test_case_input_path, test_case_output_path_betterproto)
 
 
 HELP = "\n".join(

betterproto/tests/inputs/googletypes_response/test_googletypes_response.py

@@ -43,11 +43,14 @@ async def test_channel_receives_wrapped_type(
 async def test_service_unwraps_response(
     service_method: Callable[[TestStub], Any], wrapper_class: Callable, value
 ):
+    """
+    grpclib does not unwrap wrapper values returned by services
+    """
     wrapped_value = wrapper_class()
     wrapped_value.value = value
     service = TestStub(MockChannel(responses=[wrapped_value]))
 
     response_value = await service_method(service)
 
-    assert type(response_value) == value
+    assert response_value == value
     assert type(response_value) == type(value)

betterproto/tests/inputs/import_child_package_from_package/child.proto

@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+package package.childpackage;
+
+message ChildMessage {
+
+}

betterproto/tests/inputs/import_child_package_from_package/import_child_package_from_package.proto

@@ -0,0 +1,9 @@
+syntax = "proto3";
+
+import "package_message.proto";
+
+// Tests generated imports when a message in a package refers to a message in a nested child package.
+
+message Test {
+  package.PackageMessage message = 1;
+}

betterproto/tests/inputs/import_child_package_from_package/package_message.proto

@@ -0,0 +1,9 @@
+syntax = "proto3";
+
+import "child.proto";
+
+package package;
+
+message PackageMessage {
+    package.childpackage.ChildMessage c = 1;
+}

betterproto/tests/inputs/import_child_package_from_root/child.proto

@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+package childpackage;
+
+message Message {
+
+}

betterproto/tests/inputs/import_child_package_from_root/import_child_package_from_root.proto

@@ -0,0 +1,9 @@
+syntax = "proto3";
+
+import "child.proto";
+
+// Tests generated imports when a message in root refers to a message in a child package.
+
+message Test {
+  childpackage.Message child = 1;
+}

betterproto/tests/inputs/import_circular_dependency/import_circular_dependency.proto

@@ -0,0 +1,28 @@
+syntax = "proto3";
+
+import "root.proto";
+import "other.proto";
+
+// This test-case verifies that future implementations will support circular dependencies in the generated python files.
+//
+// This becomes important when generating 1 python file/module per package, rather than 1 file per proto file.
+//
+// Scenario:
+//
+//     The proto messages depend on each other in a non-circular way:
+//
+//           Test -------> RootPackageMessage <--------------.
+//             `------------------------------------> OtherPackageMessage
+//
+//     Test and RootPackageMessage are in different files, but belong to the same package (root):
+//
+//           (Test -------> RootPackageMessage) <------------.
+//             `------------------------------------> OtherPackageMessage
+//
+//     After grouping the packages into single files or modules, a circular dependency is created:
+//
+//           (root: Test & RootPackageMessage) <-------> (other: OtherPackageMessage)
+message Test {
+  RootPackageMessage message = 1;
+  other.OtherPackageMessage other =2;
+}

betterproto/tests/inputs/import_circular_dependency/other.proto

@@ -0,0 +1,8 @@
+syntax = "proto3";
+
+import "root.proto";
+package other;
+
+message OtherPackageMessage {
+    RootPackageMessage rootPackageMessage = 1;
+}