tests/uevent.c

   1 /*
   2  * Copyright (c) 2018 SUSE Linux GmbH
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  16  *
  17  */
  18
  19 #include <stdbool.h>
  20 #include <stdarg.h>
  21 #include <stddef.h>
  22 #include <setjmp.h>
  23 #include <stdlib.h>
  24 #include <cmocka.h>
  25 #include "list.h"
  26 #include "uevent.h"
  27
  28 #include "globals.c"
  29
  30 /* Stringify helpers */
  31 #define _str_(x) #x
  32 #define str(x) _str_(x)
  33
  34 #define MAJOR 17
  35 #define MINOR 217
  36 #define DISK_RO 0
  37 #define DM_NAME "spam"
  38 #define WWID "foo"
  39
  40 static int setup_uev(void **state)
  41 {
  42         static char test_uid_attrs[] =
  43                 "dasd:ID_SPAM   sd:ID_BOGUS nvme:ID_EGGS    ";
  44
  45         struct uevent *uev = alloc_uevent();
  46         struct config *conf;
  47
  48         if (uev == NULL)
  49                 return -1;
  50
  51         *state = uev;
  52         uev->kernel = "sdo";
  53         uev->envp[0] = "MAJOR=" str(MAJOR);
  54         uev->envp[1] = "ID_SPAM=nonsense";
  55         uev->envp[1] = "ID_BOGUS=" WWID;
  56         uev->envp[2] = "MINOR=" str(MINOR);
  57         uev->envp[3] = "DM_NAME=" DM_NAME;
  58         uev->envp[4] = "DISK_RO=" str(DISK_RO);
  59         uev->envp[5] = NULL;
  60
  61         conf = get_multipath_config();
  62         parse_uid_attrs(test_uid_attrs, conf);
  63         put_multipath_config(conf);
  64         return 0;
  65 }
  66
  67 static int teardown(void **state)
  68 {
  69         free(*state);
  70         return 0;
  71 }
  72
  73 static void test_major_good(void **state)
  74 {
  75         struct uevent *uev = *state;
  76
  77         assert_int_equal(uevent_get_major(uev), MAJOR);
  78 }
  79
  80 static void test_minor_good(void **state)
  81 {
  82         struct uevent *uev = *state;
  83
  84         assert_int_equal(uevent_get_minor(uev), MINOR);
  85 }
  86
  87 static void test_ro_good(void **state)
  88 {
  89         struct uevent *uev = *state;
  90
  91         assert_int_equal(uevent_get_disk_ro(uev), DISK_RO);
  92 }
  93
  94 static void test_uid_attrs(void **state)
  95 {
  96         /* see test_uid_attrs above */
  97         struct config *conf = get_multipath_config();
  98         vector attrs = &conf->uid_attrs;
  99
 100         assert_int_equal(VECTOR_SIZE(attrs), 3);
 101         assert_null(get_uid_attribute_by_attrs(conf, "hda"));
 102         assert_string_equal("ID_BOGUS",
 103                             get_uid_attribute_by_attrs(conf, "sdaw"));
 104         assert_string_equal("ID_SPAM",
 105                             get_uid_attribute_by_attrs(conf, "dasdu"));
 106         assert_string_equal("ID_EGGS",
 107                             get_uid_attribute_by_attrs(conf, "nvme2n4"));
 108         put_multipath_config(conf);
 109 }
 110
 111 static void test_wwid(void **state)
 112 {
 113         struct uevent *uev = *state;
 114         uevent_get_wwid(uev, &conf);
 115
 116         assert_string_equal(uev->wwid, WWID);
 117 }
 118
 119 static void test_major_bad_0(void **state)
 120 {
 121         struct uevent *uev = *state;
 122
 123         uev->envp[0] = "MAJOR" str(MAJOR);
 124         assert_int_equal(uevent_get_major(uev), -1);
 125 }
 126
 127 static void test_major_bad_1(void **state)
 128 {
 129         struct uevent *uev = *state;
 130
 131         uev->envp[0] = "MAJOr=" str(MAJOR);
 132         assert_int_equal(uevent_get_major(uev), -1);
 133 }
 134
 135 static void test_major_bad_2(void **state)
 136 {
 137         struct uevent *uev = *state;
 138
 139         uev->envp[0] = "MAJORIE=" str(MAJOR);
 140         assert_int_equal(uevent_get_major(uev), -1);
 141 }
 142
 143 static void test_major_bad_3(void **state)
 144 {
 145         struct uevent *uev = *state;
 146
 147         uev->envp[0] = "MAJOR=max";
 148         assert_int_equal(uevent_get_major(uev), -1);
 149 }
 150
 151 static void test_major_bad_4(void **state)
 152 {
 153         struct uevent *uev = *state;
 154
 155         uev->envp[0] = "MAJOR=0x10";
 156         assert_int_equal(uevent_get_major(uev), -1);
 157 }
 158
 159 static void test_major_bad_5(void **state)
 160 {
 161         struct uevent *uev = *state;
 162
 163         uev->envp[0] = "MAJO=" str(MAJOR);
 164         assert_int_equal(uevent_get_major(uev), -1);
 165 }
 166
 167 static void test_major_bad_6(void **state)
 168 {
 169         struct uevent *uev = *state;
 170
 171         uev->envp[0] = "MAJOR=" str(-MAJOR);
 172         assert_int_equal(uevent_get_major(uev), -1);
 173 }
 174
 175 static void test_major_bad_7(void **state)
 176 {
 177         struct uevent *uev = *state;
 178
 179         uev->envp[0] = "MAJOR=";
 180         assert_int_equal(uevent_get_major(uev), -1);
 181 }
 182
 183 static void test_major_bad_8(void **state)
 184 {
 185         struct uevent *uev = *state;
 186
 187         uev->envp[0] = "MAJOR";
 188         assert_int_equal(uevent_get_major(uev), -1);
 189 }
 190
 191 static void test_dm_name_good(void **state)
 192 {
 193         struct uevent *uev = *state;
 194         char *name = uevent_get_dm_name(uev);
 195
 196         assert_string_equal(name, DM_NAME);
 197         free(name);
 198 }
 199
 200 static void test_dm_name_bad_0(void **state)
 201 {
 202         struct uevent *uev = *state;
 203         char *name;
 204
 205         uev->envp[3] = "DM_NAME" DM_NAME;
 206         name = uevent_get_dm_name(uev);
 207         assert_ptr_equal(name, NULL);
 208         free(name);
 209 }
 210
 211 static void test_dm_name_bad_1(void **state)
 212 {
 213         struct uevent *uev = *state;
 214         char *name;
 215
 216         uev->envp[3] = "DM_NAMES=" DM_NAME;
 217         name = uevent_get_dm_name(uev);
 218         assert_ptr_equal(name, NULL);
 219         free(name);
 220 }
 221
 222 static void test_dm_name_good_1(void **state)
 223 {
 224         struct uevent *uev = *state;
 225         char *name;
 226
 227         /* Note we change index 2 here */
 228         uev->envp[2] = "DM_NAME=" DM_NAME;
 229         name = uevent_get_dm_name(uev);
 230         assert_string_equal(name, DM_NAME);
 231         free(name);
 232 }
 233
 234 static void test_dm_uuid_false_0(void **state)
 235 {
 236         struct uevent *uev = *state;
 237
 238         assert_false(uevent_is_mpath(uev));
 239 }
 240
 241 static void test_dm_uuid_true_0(void **state)
 242 {
 243         struct uevent *uev = *state;
 244
 245         uev->envp[3] = "DM_UUID=mpath-foo";
 246         assert_true(uevent_is_mpath(uev));
 247 }
 248
 249 static void test_dm_uuid_false_1(void **state)
 250 {
 251         struct uevent *uev = *state;
 252
 253         uev->envp[3] = "DM_UUID.mpath-foo";
 254         assert_false(uevent_is_mpath(uev));
 255 }
 256
 257 static void test_dm_uuid_false_2(void **state)
 258 {
 259         struct uevent *uev = *state;
 260
 261         uev->envp[3] = "DM_UUID=mpath-";
 262         assert_false(uevent_is_mpath(uev));
 263 }
 264
 265 static void test_dm_uuid_false_3(void **state)
 266 {
 267         struct uevent *uev = *state;
 268
 269         uev->envp[3] = "DM_UU=mpath-foo";
 270         assert_false(uevent_is_mpath(uev));
 271 }
 272
 273 static void test_dm_uuid_false_4(void **state)
 274 {
 275         struct uevent *uev = *state;
 276
 277         uev->envp[3] = "DM_UUID=mpathfoo";
 278         assert_false(uevent_is_mpath(uev));
 279 }
 280
 281 static void test_dm_uuid_false_5(void **state)
 282 {
 283         struct uevent *uev = *state;
 284
 285         uev->envp[3] = "DM_UUID=";
 286         assert_false(uevent_is_mpath(uev));
 287 }
 288
 289 int test_uevent_get_XXX(void)
 290 {
 291         const struct CMUnitTest tests[] = {
 292                 cmocka_unit_test(test_major_good),
 293                 cmocka_unit_test(test_minor_good),
 294                 cmocka_unit_test(test_ro_good),
 295                 cmocka_unit_test(test_dm_name_good),
 296                 cmocka_unit_test(test_uid_attrs),
 297                 cmocka_unit_test(test_wwid),
 298                 cmocka_unit_test(test_major_bad_0),
 299                 cmocka_unit_test(test_major_bad_1),
 300                 cmocka_unit_test(test_major_bad_2),
 301                 cmocka_unit_test(test_major_bad_3),
 302                 cmocka_unit_test(test_major_bad_4),
 303                 cmocka_unit_test(test_major_bad_5),
 304                 cmocka_unit_test(test_major_bad_6),
 305                 cmocka_unit_test(test_major_bad_7),
 306                 cmocka_unit_test(test_major_bad_8),
 307                 cmocka_unit_test(test_dm_name_bad_0),
 308                 cmocka_unit_test(test_dm_name_bad_1),
 309                 cmocka_unit_test(test_dm_name_good_1),
 310                 cmocka_unit_test(test_dm_uuid_false_0),
 311                 cmocka_unit_test(test_dm_uuid_true_0),
 312                 cmocka_unit_test(test_dm_uuid_false_1),
 313                 cmocka_unit_test(test_dm_uuid_false_2),
 314                 cmocka_unit_test(test_dm_uuid_false_3),
 315                 cmocka_unit_test(test_dm_uuid_false_4),
 316                 cmocka_unit_test(test_dm_uuid_false_5),
 317         };
 318         return cmocka_run_group_tests(tests, setup_uev, teardown);
 319 }
 320
 321 int main(void)
 322 {
 323         int ret = 0;
 324
 325         init_test_verbosity(-1);
 326         ret += test_uevent_get_XXX();
 327         return ret;
 328 }