apache-ignite

1
# Licensed to the Apache Software Foundation (ASF) under one or more
2
# contributor license agreements.  See the NOTICE file distributed with
3
# this work for additional information regarding copyright ownership.
4
# The ASF licenses this file to You under the Apache License, Version 2.0
5
# (the "License"); you may not use this file except in compliance with
6
# the License.  You may obtain a copy of the License at
7
#
8
#    http://www.apache.org/licenses/LICENSE-2.0
9
#
10
# Unless required by applicable law or agreed to in writing, software
11
# distributed under the License is distributed on an "AS IS" BASIS,
12
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
# See the License for the specific language governing permissions and
14
# limitations under the License.
15

16
"""
17
Checks custom parametrizers.
18
"""
19

20
from unittest.mock import Mock
21

22
import itertools
23
import pytest
24
from ducktape.mark import parametrized, parametrize, matrix, ignore
25
from ducktape.mark.mark_expander import MarkedFunctionExpander
26

27
from ignitetest.utils import ignite_versions, ignore_if
28
from ignitetest.utils._mark import IgniteVersionParametrize
29
from ignitetest.utils.version import IgniteVersion, V_2_8_0, V_2_8_1, V_2_7_6, DEV_BRANCH
30

31

32
def expand_function(*, func, sess_ctx):
33
    """
34
    Inject parameters into function and generate context list.
35
    """
36
    assert parametrized(func)
37
    assert next(filter(lambda x: isinstance(x, IgniteVersionParametrize), func.marks), None)
38

39
    return MarkedFunctionExpander(session_context=sess_ctx, function=func).expand()
40

41

42
def mock_session_ctx(*, global_args=None):
43
    """
44
    Create mock of session context.
45
    """
46
    sess_ctx = Mock()
47
    sess_ctx.globals = global_args if global_args else {}
48

49
    return sess_ctx
50

51

52
class CheckIgniteVersions:
53
    """
54
    Checks @ignite_version parametrization.
55
    """
56
    single_params = itertools.product(
57
        [[str(V_2_8_1)], [str(V_2_8_1), str(DEV_BRANCH)]],
58
        [{}, {'ignite_versions': 'dev'}, {'ignite_versions': ['2.8.1', 'dev']}]
59
    )
60

61
    @pytest.mark.parametrize(
62
        ['versions', 'global_args'],
63
        map(lambda x: pytest.param(x[0], x[1]), single_params)
64
    )
65
    def check_injection(self, versions, global_args):
66
        """
67
        Checks parametrization with single version.
68
        """
69
        @ignite_versions(*versions, version_prefix='ver')
70
        def function(ver):
71
            return IgniteVersion(ver)
72

73
        context_list = expand_function(func=function, sess_ctx=mock_session_ctx(global_args=global_args))
74

75
        self._check_injection(context_list, versions=versions, global_args=global_args)
76

77
    pair_params = itertools.product(
78
        [[(str(DEV_BRANCH), str(V_2_8_1))], [(str(DEV_BRANCH), str(V_2_8_0)), (str(DEV_BRANCH), str(V_2_8_1))]],
79
        [{}, {'ignite_versions': [['2.8.1', '2.7.6'], ['2.8.1', '2.8.0']]}, {'ignite_versions': [['dev', '2.8.1']]}]
80
    )
81

82
    @pytest.mark.parametrize(
83
        ['versions', 'global_args'],
84
        map(lambda x: pytest.param(x[0], x[1]), pair_params)
85
    )
86
    def check_injection_pairs(self, versions, global_args):
87
        """
88
        Checks parametrization with pair of versions.
89
        """
90
        @ignite_versions(*versions, version_prefix='pair')
91
        def function(pair_1, pair_2):
92
            return IgniteVersion(pair_1), IgniteVersion(pair_2)
93

94
        context_list = expand_function(func=function, sess_ctx=mock_session_ctx(global_args=global_args))
95

96
        self._check_injection(context_list, versions=versions, global_args=global_args, pairs=True)
97

98
    @pytest.mark.parametrize(
99
        ['versions', 'version_prefix', 'global_args'],
100
        [
101
            pytest.param([(DEV_BRANCH, V_2_8_1)], 'ver', {}),
102
            pytest.param([DEV_BRANCH], 'ver', {'ignite_versions': [['dev', '2.8.1']]}),
103
            pytest.param([DEV_BRANCH], 'invalid_prefix', {})
104
        ]
105
    )
106
    def check_injection_fail(self, versions, version_prefix, global_args):
107
        """
108
        Check incorrect injecting variables with single parameter.
109
        """
110
        @ignite_versions(*versions, version_prefix=version_prefix)
111
        def function(ver):
112
            return IgniteVersion(ver)
113

114
        with pytest.raises(Exception):
115
            context_list = expand_function(func=function, sess_ctx=mock_session_ctx(global_args=global_args))
116

117
            self._check_injection(context_list, versions=versions, global_args=global_args)
118

119
    @pytest.mark.parametrize(
120
        ['versions', 'version_prefix', 'global_args'],
121
        [
122
            pytest.param([DEV_BRANCH, V_2_8_1], 'pair', {}),
123
            pytest.param([(DEV_BRANCH, V_2_8_1)], 'pair', {'ignite_versions': 'dev'}),
124
            pytest.param([(DEV_BRANCH, V_2_8_1)], 'pair', {'ignite_versions': ['dev', '2.8.1']}),
125
            pytest.param([(DEV_BRANCH, V_2_8_1)], 'invalid_prefix', {})
126
        ]
127
    )
128
    def check_injection_pairs_fail(self, versions, version_prefix, global_args):
129
        """
130
        Check incorrect injecting with pairs of versions.
131
        """
132
        @ignite_versions(*versions, version_prefix=version_prefix)
133
        def function(pair_1, pair_2):
134
            return IgniteVersion(pair_1), IgniteVersion(pair_2)
135

136
        with pytest.raises(Exception):
137
            context_list = expand_function(func=function, sess_ctx=mock_session_ctx(global_args=global_args))
138

139
            self._check_injection(context_list, versions=versions, global_args=global_args, pairs=True)
140

141
    @pytest.mark.parametrize(
142
        ['versions', 'global_args', 'result'],
143
        [pytest.param(['2.9.9', 'ignite-2.9.9', 'fork-2.9.9', 'dev', 'ignite-dev', 'fork-dev'],
144
                      {'project': 'superfork'},
145
                      ['superfork-2.9.9', 'ignite-2.9.9', 'fork-2.9.9', 'superfork-dev', 'ignite-dev', 'fork-dev']),
146
         pytest.param(['2.9.9', 'ignite-2.9.9', 'fork-2.9.9', 'dev', 'ignite-dev', 'fork-dev'],
147
                      {},  # project: ignite (default)
148
                      ['ignite-2.9.9', 'ignite-2.9.9', 'fork-2.9.9', 'ignite-dev', 'ignite-dev', 'fork-dev']),
149
         pytest.param(['10.4.42', '0.6.53', 'fork-me'],  # ignored
150
                      {'project': 'superfork',
151
                       'ignite_versions': ['2.9.9', 'ignite-2.9.9', 'fork-2.9.9', 'dev', 'ignite-dev', 'fork-dev']},
152
                      ['superfork-2.9.9', 'ignite-2.9.9', 'fork-2.9.9', 'superfork-dev', 'ignite-dev', 'fork-dev'])])
153
    def check_project_injection(self, versions, global_args, result):
154
        """
155
        Checks joining project to the version.
156
        """
157

158
        @ignite_versions(*versions, version_prefix='ver')
159
        def function(ver):
160
            return IgniteVersion(ver)
161

162
        context_list = expand_function(func=function, sess_ctx=mock_session_ctx(global_args=global_args))
163

164
        check_versions = list(map(IgniteVersion, result))
165

166
        assert len(check_versions) == len(context_list)
167

168
        for i, ctx in enumerate(reversed(context_list)):
169
            assert ctx.function() == check_versions[i]
170

171
    def check_with_others_marks(self):
172
        """
173
        Checks that ignite version parametrization works with others correctly.
174
        """
175
        @ignite_versions(str(DEV_BRANCH), str(V_2_8_1), version_prefix='ver')
176
        @parametrize(x=10, y=20)
177
        @parametrize(x=30, y=40)
178
        def function_parametrize(ver, x, y):
179
            return ver, x, y
180

181
        @ignite_versions((str(DEV_BRANCH), str(V_2_8_1)), (str(V_2_8_1), str(V_2_7_6)), version_prefix='pair')
182
        @matrix(i=[10, 20], j=[30, 40])
183
        def function_matrix(pair_1, pair_2, i, j):
184
            return pair_1, pair_2, i, j
185

186
        @ignore(ver=str(DEV_BRANCH))
187
        @ignite_versions(str(DEV_BRANCH), str(V_2_8_1), version_prefix='ver')
188
        def function_ignore(ver):
189
            return ver
190

191
        context_list = expand_function(func=function_parametrize, sess_ctx=mock_session_ctx())
192
        context_list += expand_function(func=function_matrix, sess_ctx=mock_session_ctx())
193
        context_list += expand_function(func=function_ignore, sess_ctx=mock_session_ctx())
194

195
        assert len(context_list) == 14
196

197
        parametrized_context = list(filter(lambda x: x.function_name == function_parametrize.__name__, context_list))
198
        assert len(parametrized_context) == 4
199
        for ctx in parametrized_context:
200
            args = ctx.injected_args
201
            assert len(args) == 3
202
            assert ctx.function() == (args['ver'], args['x'], args['y'])
203

204
        matrix_context = list(filter(lambda x: x.function_name == function_matrix.__name__, context_list))
205
        assert len(matrix_context) == 8
206
        for ctx in matrix_context:
207
            args = ctx.injected_args
208
            assert len(args) == 4
209
            assert ctx.function() == (args['pair_1'], args['pair_2'], args['i'], args['j'])
210

211
        assert len(list(filter(lambda x: x.function_name == function_ignore.__name__, context_list))) == 2
212
        assert len(list(filter(lambda x: x.ignore, context_list))) == 1
213

214
    @staticmethod
215
    def _check_injection(context_list, *, versions, global_args=None, pairs=False):
216
        if global_args:
217
            global_versions = global_args['ignite_versions']
218

219
            if isinstance(global_versions, str):
220
                check_versions = [IgniteVersion(global_versions)]
221
            elif isinstance(global_args['ignite_versions'], tuple):
222
                check_versions = [tuple(map(IgniteVersion, global_versions))]
223
            elif pairs:
224
                check_versions = list(map(lambda x: (IgniteVersion(x[0]), IgniteVersion(x[1])), global_versions))
225
            else:
226
                check_versions = list(map(IgniteVersion, global_versions))
227
        else:
228
            if not pairs:
229
                check_versions = list(map(IgniteVersion, versions))
230
            else:
231
                check_versions = list(map(lambda x: (IgniteVersion(x[0]), IgniteVersion(x[1])), versions))
232

233
        assert len(context_list) == len(check_versions)
234

235
        for i, ctx in enumerate(sorted(context_list, key=lambda x: x.function())):
236
            assert ctx.function() == check_versions[i]
237

238

239
class CheckVersionIf:
240
    """
241
    Checks @version_if parametrization.
242
    """
243
    def check_common(self):
244
        """
245
        Check common scenarios with @ignite_versions parametrization.
246
        """
247
        @ignore_if(lambda version, globals: version == V_2_8_0, variable_name='ver')
248
        @ignite_versions(str(DEV_BRANCH), str(V_2_8_0), version_prefix='ver')
249
        def function_1(ver):
250
            return IgniteVersion(ver)
251

252
        @ignore_if(lambda ver, globals: ver == V_2_7_6, variable_name='ver_1')
253
        @ignore_if(lambda ver, globals: ver >= V_2_8_0, variable_name='ver_2')
254
        @ignite_versions((str(V_2_8_1), str(V_2_8_0)), (str(V_2_8_0), str(V_2_7_6)), version_prefix='ver')
255
        def function_2(ver_1, ver_2):
256
            return IgniteVersion(ver_1), IgniteVersion(ver_2)
257

258
        @ignite_versions(str(DEV_BRANCH), str(V_2_8_0))
259
        def function_3(ignite_version):
260
            return IgniteVersion(ignite_version)
261

262
        context_list = expand_function(func=function_1, sess_ctx=mock_session_ctx())
263
        context_list += expand_function(func=function_2, sess_ctx=mock_session_ctx())
264
        context_list += expand_function(func=function_3, sess_ctx=mock_session_ctx())
265

266
        assert len(context_list) == 6
267

268
        assert next(filter(lambda x: x.injected_args['ver'] == str(V_2_8_0), context_list)).ignore
269
        assert not next(filter(lambda x: x.injected_args['ver'] == str(DEV_BRANCH), context_list)).ignore
270