Drop RF 3.1 support

src/robotlibcore.py

@@ -30,9 +30,7 @@
     typing = None
 
 from robot.api.deco import keyword  # noqa F401
-from robot import __version__ as robot_version
 
-RF31 = robot_version < '3.2'
 
 __version__ = '2.2.2.dev1'
 
@@ -195,9 +193,7 @@ def _get_default_and_named_args(cls, arg_spec, function):
         formated_args = []
         for arg in args:
             if defaults:
-                formated_args.append(
-                    cls._format_defaults(arg, defaults.pop())
-                )
+                formated_args.append((arg, defaults.pop()))
             else:
                 formated_args.append(arg)
         formated_args.reverse()
@@ -225,15 +221,9 @@ def _get_kw_only(cls, arg_spec):
                 kw_only_args.append(arg)
             else:
                 value = arg_spec.kwonlydefaults.get(arg, '')
-                kw_only_args.append(cls._format_defaults(arg, value))
+                kw_only_args.append((arg, value))
         return kw_only_args
 
-    @classmethod
-    def _format_defaults(cls, arg, value):
-        if RF31:
-            return '{}={}'.format(arg, value)
-        return arg, value
-
     @classmethod
     def _get_types(cls, function):
         if function is None:

utest/test_get_keyword_types.py

@@ -1,9 +1,7 @@
-import pytest
-
+from typing import List, Union
 
-from robotlibcore import RF31
+import pytest
 
-from typing import List, Union
 from DynamicTypesAnnotationsLibrary import DynamicTypesAnnotationsLibrary
 from DynamicTypesAnnotationsLibrary import CustomObject
 from DynamicTypesLibrary import DynamicTypesLibrary
@@ -29,14 +27,7 @@ def test_types_disabled(lib):
     assert types is None
 
 
-@pytest.mark.skipif(not RF31, reason='Only for RF3.1')
-def test_keyword_types_and_bool_default_rf31(lib):
-    types = lib.get_keyword_types('keyword_robot_types_and_bool_default')
-    assert types == {'arg1': str}
-
-
-@pytest.mark.skipif(RF31, reason='Only for RF3.2+')
-def test_keyword_types_and_bool_default_rf32(lib):
+def test_keyword_types_and_bool_default(lib):
     types = lib.get_keyword_types('keyword_robot_types_and_bool_default')
     assert types == {'arg1': str}
 
@@ -56,14 +47,7 @@ def test_not_keyword(lib):
         lib.get_keyword_types('not_keyword')
 
 
-@pytest.mark.skipif(RF31, reason='Only for RF3.2+')
-def test_keyword_none_rf32(lib):
-    types = lib.get_keyword_types('keyword_none')
-    assert types == {}
-
-
-@pytest.mark.skipif(not RF31, reason='Only for RF3.2+')
-def test_keyword_none_rf31(lib):
+def test_keyword_none(lib):
     types = lib.get_keyword_types('keyword_none')
     assert types == {}
 
@@ -114,7 +98,7 @@ def test_keyword_with_annotation_external_class(lib_types):
     assert types == {'arg': CustomObject}
 
 
-def test_keyword_with_annotation_and_default(lib_types):
+def test_keyword_with_annotation_and_default_part2(lib_types):
     types = lib_types.get_keyword_types('keyword_default_and_annotation')
     assert types == {'arg1': int, 'arg2': Union[bool, str]}
 
@@ -163,13 +147,6 @@ def test_keyword_only_arguments(lib_types):
     assert types == {}
 
 
-@pytest.mark.skipif(RF31, reason='Only for RF3.2+')
-def test_keyword_only_arguments_many(lib_types):
-    types = lib_types.get_keyword_types('keyword_only_arguments_many')
-    assert types == {}
-
-
-@pytest.mark.skipif(not RF31, reason='Only for RF3.1')
 def test_keyword_only_arguments_many(lib_types):
     types = lib_types.get_keyword_types('keyword_only_arguments_many')
     assert types == {}
@@ -180,26 +157,12 @@ def test_keyword_mandatory_and_keyword_only_arguments(lib_types):
     assert types == {'arg': int, 'some': bool}
 
 
-@pytest.mark.skipif(RF31, reason='Only for RF3.2+')
-def test_keyword_only_arguments_many_positional_and_default_rf32(lib_types):
+def test_keyword_only_arguments_many_positional_and_default(lib_types):
     types = lib_types.get_keyword_types('keyword_only_arguments_many_positional_and_default')
     assert types == {'four': Union[int, str], 'six': Union[bool, str]}
 
 
-@pytest.mark.skipif(not RF31, reason='Only for RF3.1')
-def test_keyword_only_arguments_many_positional_and_default_rf31(lib_types):
-    types = lib_types.get_keyword_types('keyword_only_arguments_many_positional_and_default')
-    assert types == {'four': Union[int, str], 'six': Union[bool, str]}
-
-
-@pytest.mark.skipif(RF31, reason='Only for RF3.2+')
-def test_keyword_all_args_rf32(lib_types):
-    types = lib_types.get_keyword_types('keyword_all_args')
-    assert types == {}
-
-
-@pytest.mark.skipif(not RF31, reason='Only for RF3.1')
-def test_keyword_all_args_rf31(lib_types):
+def test_keyword_all_args(lib_types):
     types = lib_types.get_keyword_types('keyword_all_args')
     assert types == {}
 

utest/test_keyword_builder.py

@@ -1,6 +1,6 @@
 import pytest
 
-from robotlibcore import RF31, KeywordBuilder
+from robotlibcore import KeywordBuilder
 from moc_library import MockLibrary
 from DynamicTypesAnnotationsLibrary import DynamicTypesAnnotationsLibrary
 
@@ -32,52 +32,31 @@ def test_positional_args(lib):
     assert spec.argument_specification == ['arg1', 'arg2']
 
 
-@pytest.mark.skipif(RF31, reason='Only for RF3.2+')
-def test_positional_and_named_rf32(lib):
+def test_positional_and_named(lib):
     spec = KeywordBuilder.build(lib.positional_and_default)
     assert spec.argument_specification == ['arg1', 'arg2', ('named1', 'string1'), ('named2', 123)]
 
 
-@pytest.mark.skipif(not RF31, reason='Only for RF3.1')
-def test_positional_and_named_rf31(lib):
-    spec = KeywordBuilder.build(lib.positional_and_default)
-    assert spec.argument_specification == ['arg1', 'arg2', 'named1=string1', 'named2=123']
-
-
-@pytest.mark.skipif(RF31, reason='Only for RF3.2+')
-def test_named_only_rf32(lib):
+def test_named_only(lib):
     spec = KeywordBuilder.build(lib.default_only)
     assert spec.argument_specification == [('named1', 'string1'), ('named2', 123)]
 
 
-@pytest.mark.skipif(not RF31, reason='Only for RF3.1')
-def test_named_only_rf31(lib):
-    spec = KeywordBuilder.build(lib.default_only)
-    assert spec.argument_specification == ['named1=string1', 'named2=123']
-
-
 def test_varargs_and_kwargs(lib):
     spec = KeywordBuilder.build(lib.varargs_kwargs)
     assert spec.argument_specification == ['*vargs', '**kwargs']
 
 
-def test_named_only(lib):
+def test_named_only_part2(lib):
     spec = KeywordBuilder.build(lib.named_only)
     assert spec.argument_specification == ['*varargs', 'key1', 'key2']
 
 
-@pytest.mark.skipif(RF31, reason='Only for RF3.2+')
-def test_named_only_rf32(lib):
+def test_named_only(lib):
     spec = KeywordBuilder.build(lib.named_only_with_defaults)
     assert spec.argument_specification == ['*varargs', 'key1', 'key2', ('key3', 'default1'), ('key4', True)]
 
 
-@pytest.mark.skipif(not RF31, reason='Only for RF3.1')
-def test_named_only_rf31(lib):
-    spec = KeywordBuilder.build(lib.named_only_with_defaults)
-    assert spec.argument_specification == ['*varargs', 'key1', 'key2', 'key3=default1', 'key4=True']
-
-
 def test_types_in_keyword_deco(lib):
     spec = KeywordBuilder.build(lib.positional_args)
     assert spec.argument_types == {'arg1': str, 'arg2': int}
@@ -103,17 +82,8 @@ def test_optional_none(lib):
     assert spec.argument_types == {'arg1': str, 'arg2': str}
 
 
-@pytest.mark.skipif(RF31, reason='For RF 3.2')
-def test_complex_deco_rf32(dyn_types):
+def test_complex_deco(dyn_types):
     spec = KeywordBuilder.build(dyn_types.keyword_with_deco_and_signature)
     assert spec.argument_types == {'arg1': bool, 'arg2': bool}
     assert spec.argument_specification == [('arg1', False), ('arg2', False)]
     assert spec.documentation == "Test me doc here"
-
-
-@pytest.mark.skipif(not RF31, reason='For RF 3.2')
-def test_complex_deco_rf31(dyn_types):
-    spec = KeywordBuilder.build(dyn_types.keyword_with_deco_and_signature)
-    assert spec.argument_types == {'arg1': bool, 'arg2': bool}
-    assert spec.argument_specification == ['arg1=False', 'arg2=False']
-    assert spec.documentation == "Test me doc here"

utest/test_robotlibcore.py

@@ -1,5 +1,4 @@
 import pytest
-from robot import __version__ as robot_version
 
 from robotlibcore import HybridCore
 from HybridLibrary import HybridLibrary
@@ -96,21 +95,7 @@ def test_getattr():
             "'%s' object has no attribute 'non_existing'" % type(lib).__name__
 
 
-@pytest.mark.skipif(robot_version >= '3.2', reason='For RF 3.1')
-def test_get_keyword_arguments_rf31():
-    args = DynamicLibrary().get_keyword_arguments
-    assert args('mandatory') == ['arg1', 'arg2']
-    assert args('defaults') == ['arg1', 'arg2=default', 'arg3=3']
-    assert args('varargs_and_kwargs') == ['*args', '**kws']
-    assert args('kwargs_only') == ['**kws']
-    assert args('all_arguments') == ['mandatory', 'default=value', '*varargs', '**kwargs']
-    assert args('__init__') == ['arg=None']
-    with pytest.raises(AttributeError):
-        args('__foobar__')
-
-
-@pytest.mark.skipif(robot_version < '3.2', reason='For RF 3.2 or greater')
-def test_get_keyword_arguments_rf32():
+def test_get_keyword_arguments():
     args = DynamicLibrary().get_keyword_arguments
     assert args('mandatory') == ['arg1', 'arg2']
     assert args('defaults') == ['arg1', ('arg2', 'default'), ('arg3', 3)]
@@ -122,8 +107,7 @@ def test_get_keyword_arguments_rf32():
         args('__foobar__')
 
 
-@pytest.mark.skipif(robot_version < '3.2', reason='For RF 3.2 or greater')
-def test_keyword_only_arguments_for_get_keyword_arguments_rf32():
+def test_keyword_only_arguments_for_get_keyword_arguments():
     args = DynamicTypesAnnotationsLibrary(1).get_keyword_arguments
     assert args('keyword_only_arguments') == ['*varargs', ('some', 111)]
     assert args('keyword_only_arguments_many') == ['*varargs', ('some', 'value'), ('other', None)]
@@ -134,18 +118,6 @@ def test_keyword_only_arguments_for_get_keyword_arguments_rf32():
     assert args('keyword_with_deco_and_signature') == [('arg1', False), ('arg2', False)]
 
 
-@pytest.mark.skipif(robot_version >= '3.2', reason='For RF 3.1')
-def test_keyword_only_arguments_for_get_keyword_arguments_rf31():
-    args = DynamicTypesAnnotationsLibrary(1).get_keyword_arguments
-    assert args('keyword_only_arguments') == ['*varargs', 'some=111']
-    assert args('keyword_only_arguments_many') == ['*varargs', 'some=value', 'other=None']
-    assert args('keyword_only_arguments_no_default') == ['*varargs', 'other']
-    assert args('keyword_only_arguments_default_and_no_default') == ['*varargs', 'other', 'value=False']
-    all_args = ['mandatory', 'positional=1', '*varargs', 'other', 'value=False', '**kwargs']
-    assert args('keyword_all_args') == all_args
-    assert args('keyword_with_deco_and_signature') == ['arg1=False', 'arg2=False']
-
-
 def test_get_keyword_documentation():
     doc = DynamicLibrary().get_keyword_documentation
     assert doc('function') == ''