Move tests; Add .pyi for test protobuf

Author: pcisar

test/base_test.proto tests/base_test.prototest/base_test.proto renamed to tests/base_test.proto

@@ -0,0 +1,56 @@
+from google.protobuf import any_pb2 as _any_pb2
+from google.protobuf import struct_pb2 as _struct_pb2
+from google.protobuf.internal import containers as _containers
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class TestEnum(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = []
+    TEST_UNKNOWN: _ClassVar[TestEnum]
+    TEST_READY: _ClassVar[TestEnum]
+    TEST_RUNNING: _ClassVar[TestEnum]
+    TEST_WAITING: _ClassVar[TestEnum]
+    TEST_SUSPENDED: _ClassVar[TestEnum]
+    TEST_FINISHED: _ClassVar[TestEnum]
+    TEST_ABORTED: _ClassVar[TestEnum]
+    TEST_CREATED: _ClassVar[TestEnum]
+    TEST_BLOCKED: _ClassVar[TestEnum]
+    TEST_STOPPED: _ClassVar[TestEnum]
+    TEST_TERMINATED: _ClassVar[TestEnum]
+TEST_UNKNOWN: TestEnum
+TEST_READY: TestEnum
+TEST_RUNNING: TestEnum
+TEST_WAITING: TestEnum
+TEST_SUSPENDED: TestEnum
+TEST_FINISHED: TestEnum
+TEST_ABORTED: TestEnum
+TEST_CREATED: TestEnum
+TEST_BLOCKED: TestEnum
+TEST_STOPPED: TestEnum
+TEST_TERMINATED: TestEnum
+
+class TestState(_message.Message):
+    __slots__ = ["name", "test"]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    TEST_FIELD_NUMBER: _ClassVar[int]
+    name: str
+    test: TestEnum
+    def __init__(self, name: _Optional[str] = ..., test: _Optional[_Union[TestEnum, str]] = ...) -> None: ...
+
+class TestCollection(_message.Message):
+    __slots__ = ["name", "tests", "context", "annotation", "supplement"]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    TESTS_FIELD_NUMBER: _ClassVar[int]
+    CONTEXT_FIELD_NUMBER: _ClassVar[int]
+    ANNOTATION_FIELD_NUMBER: _ClassVar[int]
+    SUPPLEMENT_FIELD_NUMBER: _ClassVar[int]
+    name: str
+    tests: _containers.RepeatedCompositeFieldContainer[TestState]
+    context: _struct_pb2.Struct
+    annotation: _struct_pb2.Struct
+    supplement: _containers.RepeatedCompositeFieldContainer[_any_pb2.Any]
+    def __init__(self, name: _Optional[str] = ..., tests: _Optional[_Iterable[_Union[TestState, _Mapping]]] = ..., context: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., annotation: _Optional[_Union[_struct_pb2.Struct, _Mapping]] = ..., supplement: _Optional[_Iterable[_Union[_any_pb2.Any, _Mapping]]] = ...) -> None: ...

test/base_test_pb2.py tests/base_test_pb2.pytest/base_test_pb2.py renamed to tests/base_test_pb2.py

@@ -38,6 +38,7 @@
 from unittest import TestCase, mock, main as unittest_main
 from uuid import UUID
 from decimal import Decimal
+import sys
 import io
 import os
 import platform
@@ -1110,7 +1111,7 @@ def test_simple(self):
         opt.validate()
         opt.load_config(self.conf, PRESENT_S)
         self.assertEqual(opt.value, self.PRESENT_VAL)
-        self.assertEqual(opt.get_as_str(), 'THREE | TWO')
+        self.assertEqual(opt.get_as_str(), 'THREE | TWO' if sys.version_info.minor < 11 else 'TWO|THREE')
         self.assertIsInstance(opt.value, opt.datatype)
         opt.clear()
         self.assertIsNone(opt.value)
@@ -1188,7 +1189,11 @@ def test_allowed_values(self):
         self.assertEqual(opt.value, self.DEFAULT_VAL)
         with self.assertRaises(ValueError) as cm:
             opt.set_value(self.NEW_VAL)
-        self.assertEqual(cm.exception.args, ("Illegal value 'SimpleIntFlag.FIVE' for flag option 'option_name'",))
+        if sys.version_info.minor < 11:
+            exc_args = ("Illegal value 'SimpleIntFlag.FIVE' for flag option 'option_name'",)
+        else:
+            exc_args = ("Illegal value '16' for flag option 'option_name'",)
+        self.assertEqual(cm.exception.args, exc_args)
     def test_default(self):
         opt = config.FlagOption('option_name', SimpleIntFlag, 'description', default=self.DEFAULT_OPT_VAL)
         self.assertEqual(opt.name, 'option_name')
@@ -1251,9 +1256,15 @@ def test_proto(self):
         self.assertFalse('option_name' in self.proto.options)
     def test_get_config(self):
         opt = config.FlagOption('option_name', SimpleIntFlag, 'description', default=self.DEFAULT_OPT_VAL)
-        lines = """; description
+        if sys.version_info.minor < 11:
+            lines = """; description
 ; Type: flag [one, two, three, four, five]
 ;option_name = four | three
+"""
+        else:
+            lines = """; description
+; Type: flag [one, two, three, four, five]
+;option_name = three|four
 """
         self.assertEqual(opt.get_config(), lines)
         lines = """; description
@@ -2274,7 +2285,11 @@ def test_bad_value(self):
         opt = config.PyExprOption('option_name', 'description')
         with self.assertRaises(SyntaxError) as cm:
             opt.load_config(self.conf, BAD_S)
-        self.assertEqual(cm.exception.args, ('invalid syntax', ('PyExpr', 1, 15, 'This is not a valid Python expression')))
+        if sys.version_info.minor < 10:
+            exc_args = ('PyExpr', 1, 15, 'This is not a valid Python expression')
+        else:
+            exc_args = ('PyExpr', 1, 15, 'This is not a valid Python expression', 1, 20)
+        self.assertEqual(cm.exception.args, ('invalid syntax', exc_args))
         with self.assertRaises(TypeError) as cm:
             opt.set_value(10.0)
         self.assertEqual(cm.exception.args, ("Option 'option_name' value must be a 'PyExpr', not 'float'",))
@@ -2430,7 +2445,11 @@ def test_bad_value(self):
         opt = config.PyCodeOption('option_name', 'description')
         with self.assertRaises(SyntaxError) as cm:
             opt.load_config(self.conf, BAD_S)
-        self.assertEqual(cm.exception.args, ('invalid syntax', ('PyCode', 1, 15, 'This is not a valid Python code block\n')))
+        if sys.version_info.minor < 10:
+            exc_args = ('PyCode', 1, 15, 'This is not a valid Python code block\n')
+        else:
+            exc_args = ('PyCode', 1, 15, 'This is not a valid Python code block\n', 1, 20)
+        self.assertEqual(cm.exception.args, ('invalid syntax', exc_args))
         with self.assertRaises(TypeError) as cm:
             opt.set_value(10.0)
         self.assertEqual(cm.exception.args, ("Option 'option_name' value must be a 'PyCode', not 'float'",))

tests/base_test_pb2.pyi

@@ -57,29 +57,29 @@ def value_signal(value):
 
 slot_signature = inspect.Signature.from_callable(value_signal)
 
-def testFunc(test, value):
+def _Func(test, value):
     """A test standalone function for signals to attach onto"""
     test.checkval = value
     test.func_call_count += 1
 
-testFunc_signature = inspect.Signature.from_callable(testFunc)
+testFunc_signature = inspect.Signature.from_callable(_Func)
 
-def testFuncWithKWDeafult(test, value, kiwi=None):
+def _FuncWithKWDeafult(test, value, kiwi=None):
     """A test standalone function with excess default keyword argument for signals to attach onto"""
     test.checkval = value
     test.func_call_count += 1
 
-def testFuncWithKW(test, value, *, kiwi):
+def _FuncWithKW(test, value, *, kiwi):
     """A test standalone function with excess keyword argument for signals to attach onto"""
     test.checkval = value
     test.func_call_count += 1
 
-def testLocalEmit(signal_instance):
+def _LocalEmit(signal_instance):
     """A test standalone function for signals to emit at local level"""
     exec('signal_instance.emit()')
 
 
-def testModuleEmit(signal_instance):
+def _ModuleEmit(signal_instance):
     """A test standalone function for signals to emit at module level"""
     signal_instance.emit()
 
@@ -208,40 +208,40 @@ def __init__(self, methodName='runTest'):
     def test_PartialConnect(self):
         """Tests connecting signals to partials"""
         partialSignal = Signal(nopar_signature)
-        partialSignal.connect(partial(testFunc, self, 'Partial'))
+        partialSignal.connect(partial(_Func, self, 'Partial'))
         self.assertEqual(len(partialSignal._slots), 1, "Expected single connected slot")
 
     def test_PartialConnectKWDifferOk(self):
         """Tests connecting signals to partials"""
         partialSignal = Signal(nopar_signature)
-        partialSignal.connect(partial(testFuncWithKWDeafult, self, 'Partial'))
+        partialSignal.connect(partial(_FuncWithKWDeafult, self, 'Partial'))
         self.assertEqual(len(partialSignal._slots), 1, "Expected single connected slot")
 
     def test_PartialConnectKWDifferBad(self):
         """Tests connecting signals to partials"""
         partialSignal = Signal(nopar_signature)
         with self.assertRaises(ValueError):
-            partialSignal.connect(partial(testFuncWithKW, self, 'Partial'))
+            partialSignal.connect(partial(_FuncWithKW, self, 'Partial'))
         self.assertEqual(len(partialSignal._slots), 0, "Expected single connected slot")
 
     def test_PartialConnectDuplicate(self):
         """Tests connecting signals to partials"""
         partialSignal = Signal(nopar_signature)
-        func = partial(testFunc, self, 'Partial')
+        func = partial(_Func, self, 'Partial')
         partialSignal.connect(func)
         partialSignal.connect(func)
         self.assertEqual(len(partialSignal._slots), 1, "Expected single connected slot")
 
     def test_LambdaConnect(self):
         """Tests connecting signals to lambdas"""
         lambdaSignal = Signal(slot_signature)
-        lambdaSignal.connect(lambda value: testFunc(self, value))
+        lambdaSignal.connect(lambda value: _Func(self, value))
         self.assertEqual(len(lambdaSignal._slots), 1, "Expected single connected slot")
 
     def test_LambdaConnectDuplicate(self):
         """Tests connecting signals to duplicate lambdas"""
         lambdaSignal = Signal(slot_signature)
-        func = lambda value: testFunc(self, value)
+        func = lambda value: _Func(self, value)
         lambdaSignal.connect(func)
         lambdaSignal.connect(func)
         self.assertEqual(len(lambdaSignal._slots), 1, "Expected single connected slot")
@@ -274,14 +274,14 @@ def test_MethodConnectDifferentInstances(self):
     def test_FunctionConnect(self):
         """Test connecting signals to standalone functions"""
         funcSignal = Signal(testFunc_signature)
-        funcSignal.connect(testFunc)
+        funcSignal.connect(_Func)
         self.assertEqual(len(funcSignal._slots), 1, "Expected single connected slot")
 
     def test_FunctionConnectDuplicate(self):
         """Test that each function connection is unique"""
         funcSignal = Signal(testFunc_signature)
-        funcSignal.connect(testFunc)
-        funcSignal.connect(testFunc)
+        funcSignal.connect(_Func)
+        funcSignal.connect(_Func)
         self.assertEqual(len(funcSignal._slots), 1, "Expected single connected slot")
 
     def test_ConnectNonCallable(self):
@@ -293,15 +293,15 @@ def test_ConnectNonCallable(self):
     def test_EmitToPartial(self):
         """Test emitting signals to partial"""
         partialSignal = Signal(nopar_signature)
-        partialSignal.connect(partial(testFunc, self, 'Partial'))
+        partialSignal.connect(partial(_Func, self, 'Partial'))
         partialSignal.emit()
         self.assertEqual(self.checkval, 'Partial')
         self.assertEqual(self.func_call_count, 1, "Expected function to be called once")
 
     def test_EmitToLambda(self):
         """Test emitting signal to lambda"""
         lambdaSignal = Signal(slot_signature)
-        lambdaSignal.connect(lambda value: testFunc(self, value))
+        lambdaSignal.connect(lambda value: _Func(self, value))
         lambdaSignal.emit('Lambda')
         self.assertEqual(self.checkval, 'Lambda')
         self.assertEqual(self.func_call_count, 1, "Expected function to be called once")
@@ -327,7 +327,7 @@ def test_EmitToMethodOnDeletedInstance(self):
     def test_EmitToFunction(self):
         """Test emitting signal to standalone function"""
         funcSignal = Signal(testFunc_signature)
-        funcSignal.connect(testFunc)
+        funcSignal.connect(_Func)
         funcSignal.emit(self, 'Function')
         self.assertEqual(self.checkval, 'Function')
         self.assertEqual(self.func_call_count, 1, "Expected function to be called once")
@@ -347,15 +347,15 @@ def ToDelete(test, value):
     def test_PartialDisconnect(self):
         """Test disconnecting partial function"""
         partialSignal = Signal(nopar_signature)
-        part = partial(testFunc, self, 'Partial')
+        part = partial(_Func, self, 'Partial')
         partialSignal.connect(part)
         partialSignal.disconnect(part)
         self.assertEqual(self.checkval, None, "Slot was not removed from signal")
 
     def test_PartialDisconnectUnconnected(self):
         """Test disconnecting unconnected partial function"""
         partialSignal = Signal(slot_signature)
-        part = partial(testFunc, self, 'Partial')
+        part = partial(_Func, self, 'Partial')
         try:
             partialSignal.disconnect(part)
         except:
@@ -364,15 +364,15 @@ def test_PartialDisconnectUnconnected(self):
     def test_LambdaDisconnect(self):
         """Test disconnecting lambda function"""
         lambdaSignal = Signal(slot_signature)
-        func = lambda value: testFunc(self, value)
+        func = lambda value: _Func(self, value)
         lambdaSignal.connect(func)
         lambdaSignal.disconnect(func)
         self.assertEqual(len(lambdaSignal._slots), 0, "Slot was not removed from signal")
 
     def test_LambdaDisconnectUnconnected(self):
         """Test disconnecting unconnected lambda function"""
         lambdaSignal = Signal(slot_signature)
-        func = lambda value: testFunc(self, value)
+        func = lambda value: _Func(self, value)
         try:
             lambdaSignal.disconnect(func)
         except:
@@ -398,15 +398,15 @@ def test_MethodDisconnectUnconnected(self):
     def test_FunctionDisconnect(self):
         """Test disconnecting function"""
         funcSignal = Signal(testFunc_signature)
-        funcSignal.connect(testFunc)
-        funcSignal.disconnect(testFunc)
+        funcSignal.connect(_Func)
+        funcSignal.disconnect(_Func)
         self.assertEqual(len(funcSignal._slots), 0, "Slot was not removed from signal")
 
     def test_FunctionDisconnectUnconnected(self):
         """Test disconnecting unconnected function"""
         funcSignal = Signal(slot_signature)
         try:
-            funcSignal.disconnect(testFunc)
+            funcSignal.disconnect(_Func)
         except:
             self.fail("Disconnecting unconnected function should not raise")
 
@@ -422,7 +422,7 @@ def test_ClearSlots(self):
         """Test clearing all slots"""
         multiSignal = Signal(slot_signature)
         func = lambda value: self.setVal(value)
-        multiSignal.connect(partial(testFunc, self))
+        multiSignal.connect(partial(_Func, self))
         multiSignal.connect(self.setVal)
         multiSignal.clear()
         self.assertEqual(len(multiSignal._slots), 0, "Not all slots were removed from signal")