Debian Codegraph @

src/vendor/azure-uamqp-c/tests/sasl_anonymous_ut/sasl_anonymous_ut.c

raw
1 // Copyright (c) Microsoft. All rights reserved.
2 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
4 #ifdef __cplusplus
5 #include <cstdint>
6 #include <cstddef>
7 #else
8 #include <stdint.h>
9 #include <stddef.h>
10 #endif
11
12 #include "azure_macro_utils/macro_utils.h"
13 #include "testrunnerswitcher.h"
14 #include "umock_c/umock_c.h"
15 #include "umock_c/umocktypes_charptr.h"
16
17 #if defined _MSC_VER
18 #pragma warning(disable: 4054) /* MSC incorrectly fires this */
19 #endif
20
21 static void* my_gballoc_malloc(size_t size)
22 {
23 return malloc(size);
24 }
25
26 static void my_gballoc_free(void* ptr)
27 {
28 free(ptr);
29 }
30
31 #define ENABLE_MOCKS
32
33 #include "azure_c_shared_utility/gballoc.h"
34
35 #undef ENABLE_MOCKS
36
37 #include "azure_uamqp_c/sasl_anonymous.h"
38
39 static TEST_MUTEX_HANDLE g_testByTest;
40
41 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
42
43 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
44 {
45 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
46 }
47
48 BEGIN_TEST_SUITE(sasl_anonymous_ut)
49
50 TEST_SUITE_INITIALIZE(suite_init)
51 {
52 int result;
53
54 g_testByTest = TEST_MUTEX_CREATE();
55 ASSERT_IS_NOT_NULL(g_testByTest);
56
57 umock_c_init(on_umock_c_error);
58
59 result = umocktypes_charptr_register_types();
60 ASSERT_ARE_EQUAL(int, 0, result);
61
62 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
63 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
64 }
65
66 TEST_SUITE_CLEANUP(suite_cleanup)
67 {
68 umock_c_deinit();
69
70 TEST_MUTEX_DESTROY(g_testByTest);
71 }
72
73 TEST_FUNCTION_INITIALIZE(method_init)
74 {
75 if (TEST_MUTEX_ACQUIRE(g_testByTest))
76 {
77 ASSERT_FAIL("our mutex is ABANDONED. Failure in test framework");
78 }
79
80 umock_c_reset_all_calls();
81 }
82
83 TEST_FUNCTION_CLEANUP(method_cleanup)
84 {
85 TEST_MUTEX_RELEASE(g_testByTest);
86 }
87
88 /* saslanonymous_create */
89
90 /* Tests_SRS_SASL_ANONYMOUS_01_001: [`saslanonymous_create` shall return on success a non-NULL handle to a new SASL anonymous mechanism.]*/
91 TEST_FUNCTION(saslanonymous_create_with_valid_args_succeeds)
92 {
93 // arrange
94 CONCRETE_SASL_MECHANISM_HANDLE result;
95 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
96
97 // act
98 result = saslanonymous_get_interface()->concrete_sasl_mechanism_create((void*)0x4242);
99
100 // assert
101 ASSERT_IS_NOT_NULL(result);
102 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
103
104 // cleanup
105 saslanonymous_get_interface()->concrete_sasl_mechanism_destroy(result);
106 }
107
108 /* Tests_SRS_SASL_ANONYMOUS_01_002: [If allocating the memory needed for the SASL anonymous instance fails then `saslanonymous_create` shall return NULL.] */
109 TEST_FUNCTION(when_allocating_memory_fails_then_saslanonymous_create_fails)
110 {
111 // arrange
112 CONCRETE_SASL_MECHANISM_HANDLE result;
113 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG))
114 .SetReturn(NULL);
115
116 // act
117 result = saslanonymous_get_interface()->concrete_sasl_mechanism_create((void*)0x4242);
118
119 // assert
120 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
121 ASSERT_IS_NULL(result);
122 }
123
124 /* Tests_SRS_SASL_ANONYMOUS_01_003: [Since this is the ANONYMOUS SASL mechanism, `config` shall be ignored.]*/
125 TEST_FUNCTION(saslanonymous_create_with_NULL_config_succeeds)
126 {
127 // arrange
128 CONCRETE_SASL_MECHANISM_HANDLE result;
129 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG));
130
131 // act
132 result = saslanonymous_get_interface()->concrete_sasl_mechanism_create(NULL);
133
134 // assert
135 ASSERT_IS_NOT_NULL(result);
136 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
137
138 // cleanup
139 saslanonymous_get_interface()->concrete_sasl_mechanism_destroy(result);
140 }
141
142 /* saslanonymous_destroy */
143
144 /* Tests_SRS_SASL_ANONYMOUS_01_004: [`saslanonymous_destroy` shall free all resources associated with the SASL mechanism.] */
145 TEST_FUNCTION(saslanonymous_destroy_frees_the_allocated_resources)
146 {
147 // arrange
148 CONCRETE_SASL_MECHANISM_HANDLE result = saslanonymous_get_interface()->concrete_sasl_mechanism_create(NULL);
149 umock_c_reset_all_calls();
150
151 STRICT_EXPECTED_CALL(gballoc_free(IGNORED_PTR_ARG));
152
153 // act
154 saslanonymous_get_interface()->concrete_sasl_mechanism_destroy(result);
155
156 // assert
157 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
158 }
159
160 /* Tests_SRS_SASL_ANONYMOUS_01_005: [If the argument `concrete_sasl_mechanism` is NULL, `saslanonymous_destroy` shall do nothing.]*/
161 TEST_FUNCTION(saslanonymous_destroy_with_NULL_argument_does_nothing)
162 {
163 // arrange
164
165 // act
166 saslanonymous_get_interface()->concrete_sasl_mechanism_destroy(NULL);
167
168 // assert
169 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
170 }
171
172 /* saslanonymous_get_init_bytes */
173
174 /* Tests_SRS_SASL_ANONYMOUS_01_006: [`saslanonymous_get_init_bytes` shall validate the `concrete_sasl_mechanism` argument and set the length of the `init_bytes` argument to be zero.] */
175 /* Tests_SRS_SASL_ANONYMOUS_01_012: [The bytes field of `init_buffer` shall be set to NULL.] */
176 /* Tests_SRS_SASL_ANONYMOUS_01_011: [On success `saslanonymous_get_init_bytes` shall return zero.] */
177 TEST_FUNCTION(saslannymous_get_init_bytes_sets_the_bytes_to_NULL_and_length_to_zero)
178 {
179 // arrange
180 CONCRETE_SASL_MECHANISM_HANDLE saslanonymous = saslanonymous_get_interface()->concrete_sasl_mechanism_create(NULL);
181 SASL_MECHANISM_BYTES init_bytes;
182 int result;
183 umock_c_reset_all_calls();
184
185 // act
186 result = saslanonymous_get_interface()->concrete_sasl_mechanism_get_init_bytes(saslanonymous, &init_bytes);
187
188 // assert
189 ASSERT_IS_NULL(init_bytes.bytes);
190 ASSERT_ARE_EQUAL(size_t, 0, init_bytes.length);
191 ASSERT_ARE_EQUAL(int, 0, result);
192 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
193
194 // cleanup
195 saslanonymous_get_interface()->concrete_sasl_mechanism_destroy(saslanonymous);
196 }
197
198 /* Tests_SRS_SASL_ANONYMOUS_01_007: [If any argument is NULL, `saslanonymous_get_init_bytes` shall return a non-zero value.]*/
199 TEST_FUNCTION(saslannymous_get_init_bytes_with_NULL_concrete_sasl_mechanism_fails)
200 {
201 // arrange
202 SASL_MECHANISM_BYTES init_bytes;
203 int result;
204 umock_c_reset_all_calls();
205
206 // act
207 result = saslanonymous_get_interface()->concrete_sasl_mechanism_get_init_bytes(NULL, &init_bytes);
208
209 // assert
210 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
211 ASSERT_ARE_NOT_EQUAL(int, 0, result);
212 }
213
214 /* Tests_SRS_SASL_ANONYMOUS_01_007: [If any argument is NULL, `saslanonymous_get_init_bytes` shall return a non-zero value.]*/
215 TEST_FUNCTION(saslannymous_get_init_bytes_with_NULL_init_bytes_fails)
216 {
217 // arrange
218 CONCRETE_SASL_MECHANISM_HANDLE saslanonymous = saslanonymous_get_interface()->concrete_sasl_mechanism_create(NULL);
219 int result;
220 umock_c_reset_all_calls();
221
222 // act
223 result = saslanonymous_get_interface()->concrete_sasl_mechanism_get_init_bytes(saslanonymous, NULL);
224
225 // assert
226 ASSERT_ARE_NOT_EQUAL(int, 0, result);
227 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
228
229 // cleanup
230 saslanonymous_get_interface()->concrete_sasl_mechanism_destroy(saslanonymous);
231 }
232
233 /* saslanonymous_get_mechanism_name */
234
235 /* Tests_SRS_SASL_ANONYMOUS_01_008: [`saslanonymous_get_mechanism_name` shall validate the argument `concrete_sasl_mechanism` and on success it shall return a pointer to the string `ANONYMOUS`.] */
236 TEST_FUNCTION(saslanonymous_get_mechanism_name_with_non_NULL_concrete_sasl_mechanism_succeeds)
237 {
238 // arrange
239 CONCRETE_SASL_MECHANISM_HANDLE saslanonymous = saslanonymous_get_interface()->concrete_sasl_mechanism_create(NULL);
240 const char* result;
241 umock_c_reset_all_calls();
242
243 // act
244 result = saslanonymous_get_interface()->concrete_sasl_mechanism_get_mechanism_name(saslanonymous);
245
246 // assert
247 ASSERT_ARE_EQUAL(char_ptr, "ANONYMOUS", result);
248 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
249
250 // cleanup
251 saslanonymous_get_interface()->concrete_sasl_mechanism_destroy(saslanonymous);
252 }
253
254 /* Tests_SRS_SASL_ANONYMOUS_01_009: [If the argument `concrete_sasl_mechanism` is NULL, `saslanonymous_get_mechanism_name` shall return NULL.] */
255 TEST_FUNCTION(saslanonymous_get_mechanism_name_with_NULL_concrete_sasl_mechanism_fails)
256 {
257 // arrange
258
259 // act
260 const char* result = saslanonymous_get_interface()->concrete_sasl_mechanism_get_mechanism_name(NULL);
261
262 // assert
263 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
264 ASSERT_IS_NULL(result);
265 }
266
267 /* saslanonymous_challenge */
268
269 /* Tests_SRS_SASL_ANONYMOUS_01_013: [`saslanonymous_challenge` shall set the `buffer` field to NULL and `size` to 0 in the `response_bytes` argument as the ANONYMOUS SASL mechanism does not implement challenge/response.] */
270 /* Tests_SRS_SASL_ANONYMOUS_01_014: [On success, `saslanonymous_challenge` shall return 0.] */
271 TEST_FUNCTION(saslanonymous_challenge_returns_a_NULL_response_bytes_buffer)
272 {
273 // arrange
274 CONCRETE_SASL_MECHANISM_HANDLE saslanonymous = saslanonymous_get_interface()->concrete_sasl_mechanism_create(NULL);
275 SASL_MECHANISM_BYTES challenge_bytes;
276 SASL_MECHANISM_BYTES response_bytes;
277 int result;
278 umock_c_reset_all_calls();
279
280 // act
281 result = saslanonymous_get_interface()->concrete_sasl_mechanism_challenge(saslanonymous, &challenge_bytes, &response_bytes);
282
283 // assert
284 ASSERT_ARE_EQUAL(int, 0, result);
285 ASSERT_IS_NULL(response_bytes.bytes);
286 ASSERT_ARE_EQUAL(size_t, 0, response_bytes.length);
287 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
288
289 // cleanup
290 saslanonymous_get_interface()->concrete_sasl_mechanism_destroy(saslanonymous);
291 }
292
293 /* Tests_SRS_SASL_ANONYMOUS_01_014: [On success, `saslanonymous_challenge` shall return 0.] */
294 TEST_FUNCTION(saslanonymous_with_NULL_challenge_bytes_returns_a_NULL_response_bytes_buffer)
295 {
296 // arrange
297 CONCRETE_SASL_MECHANISM_HANDLE saslanonymous = saslanonymous_get_interface()->concrete_sasl_mechanism_create(NULL);
298 SASL_MECHANISM_BYTES response_bytes;
299 int result;
300 umock_c_reset_all_calls();
301
302 // act
303 result = saslanonymous_get_interface()->concrete_sasl_mechanism_challenge(saslanonymous, NULL, &response_bytes);
304
305 // assert
306 ASSERT_ARE_EQUAL(int, 0, result);
307 ASSERT_IS_NULL(response_bytes.bytes);
308 ASSERT_ARE_EQUAL(size_t, 0, response_bytes.length);
309 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
310
311 // cleanup
312 saslanonymous_get_interface()->concrete_sasl_mechanism_destroy(saslanonymous);
313 }
314
315 /* Tests_SRS_SASL_ANONYMOUS_01_015: [If the `concrete_sasl_mechanism` or `response_bytes` argument is NULL then `saslanonymous_challenge` shall fail and return a non-zero value.] */
316 TEST_FUNCTION(saslanonymous_challenge_with_NULL_handle_fails)
317 {
318 // arrange
319 SASL_MECHANISM_BYTES challenge_bytes;
320 SASL_MECHANISM_BYTES response_bytes;
321 int result;
322
323 // act
324 result = saslanonymous_get_interface()->concrete_sasl_mechanism_challenge(NULL, &challenge_bytes, &response_bytes);
325
326 // assert
327 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
328 ASSERT_ARE_NOT_EQUAL(int, 0, result);
329 }
330
331 /* Tests_SRS_SASL_ANONYMOUS_01_015: [If the `concrete_sasl_mechanism` or `response_bytes` argument is NULL then `saslanonymous_challenge` shall fail and return a non-zero value.] */
332 TEST_FUNCTION(saslanonymous_challenge_with_NULL_response_bytes_fails)
333 {
334 // arrange
335 CONCRETE_SASL_MECHANISM_HANDLE saslanonymous = saslanonymous_get_interface()->concrete_sasl_mechanism_create(NULL);
336 SASL_MECHANISM_BYTES challenge_bytes;
337 int result;
338 umock_c_reset_all_calls();
339
340 // act
341 result = saslanonymous_get_interface()->concrete_sasl_mechanism_challenge(saslanonymous, &challenge_bytes, NULL);
342
343 // assert
344 ASSERT_ARE_NOT_EQUAL(int, 0, result);
345 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
346
347 // cleanup
348 saslanonymous_get_interface()->concrete_sasl_mechanism_destroy(saslanonymous);
349 }
350
351 /* saslanonymous_get_interface */
352
353 /* Tests_SRS_SASL_ANONYMOUS_01_010: [`saslanonymous_get_interface` shall return a pointer to a `SASL_MECHANISM_INTERFACE_DESCRIPTION` structure that contains pointers to the functions: `saslanonymous_create`, `saslanonymous_destroy`, `saslanonymous_get_init_bytes`, `saslanonymous_get_mechanism_name`, `saslanonymous_challenge`.] */
354 TEST_FUNCTION(saslanonymous_get_interface_returns_the_sasl_anonymous_mechanism_interface)
355 {
356 // arrange
357
358 // act
359 const SASL_MECHANISM_INTERFACE_DESCRIPTION* result = saslanonymous_get_interface();
360
361 // assert
362 ASSERT_IS_NOT_NULL(result->concrete_sasl_mechanism_create);
363 ASSERT_IS_NOT_NULL(result->concrete_sasl_mechanism_destroy);
364 ASSERT_IS_NOT_NULL(result->concrete_sasl_mechanism_get_init_bytes);
365 ASSERT_IS_NOT_NULL(result->concrete_sasl_mechanism_get_mechanism_name);
366 ASSERT_IS_NOT_NULL(result->concrete_sasl_mechanism_challenge);
367 }
368
369 END_TEST_SUITE(sasl_anonymous_ut)