tests/unit/test_action.cpp

   1 /*
   2  * test_action.c
   3  *
   4  * Unit tests for the notification API.
   5  *
   6  * Copyright (C) 2017 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
   7  *
   8  * SPDX-License-Identifier: MIT
   9  *
  10  */
  11
  12 #include <common/payload-view.hpp>
  13 #include <common/payload.hpp>
  14
  15 #include <lttng/action/action-internal.hpp>
  16 #include <lttng/action/action.h>
  17 #include <lttng/action/notify.h>
  18 #include <lttng/action/rate-policy-internal.hpp>
  19 #include <lttng/action/rate-policy.h>
  20 #include <lttng/action/rotate-session.h>
  21 #include <lttng/action/snapshot-session.h>
  22 #include <lttng/action/start-session.h>
  23 #include <lttng/action/stop-session.h>
  24
  25 #include <inttypes.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <tap/tap.h>
  29 #include <unistd.h>
  30
  31 /* For error.h */
  32 int lttng_opt_quiet = 1;
  33 int lttng_opt_verbose;
  34 int lttng_opt_mi;
  35
  36 #define NUM_TESTS 60
  37
  38 static void test_action_notify(void)
  39 {
  40         int ret;
  41         enum lttng_action_status status;
  42         struct lttng_action *notify_action = NULL, *notify_action_from_buffer = NULL;
  43         struct lttng_rate_policy *policy = NULL, *default_policy;
  44         struct lttng_payload payload;
  45
  46         lttng_payload_init(&payload);
  47
  48         /* To set. */
  49         policy = lttng_rate_policy_every_n_create(100);
  50         /* For comparison. */
  51         default_policy = lttng_rate_policy_every_n_create(1);
  52
  53         LTTNG_ASSERT(policy && default_policy);
  54
  55         notify_action = lttng_action_notify_create();
  56         ok(notify_action, "Create notify action");
  57         ok(lttng_action_get_type(notify_action) == LTTNG_ACTION_TYPE_NOTIFY,
  58            "Action has type LTTNG_ACTION_TYPE_NOTIFY");
  59
  60         /* Validate the default policy for a notify action. */
  61         {
  62                 const struct lttng_rate_policy *cur_policy = NULL;
  63                 status = lttng_action_notify_get_rate_policy(notify_action, &cur_policy);
  64                 ok(status == LTTNG_ACTION_STATUS_OK &&
  65                            lttng_rate_policy_is_equal(default_policy, cur_policy),
  66                    "Default policy is every n=1");
  67         }
  68
  69         /* Set a custom policy. */
  70         status = lttng_action_notify_set_rate_policy(notify_action, policy);
  71         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
  72
  73         /* Validate the custom policy for a notify action. */
  74         {
  75                 const struct lttng_rate_policy *cur_policy = NULL;
  76                 status = lttng_action_notify_get_rate_policy(notify_action, &cur_policy);
  77                 ok(status == LTTNG_ACTION_STATUS_OK &&
  78                            lttng_rate_policy_is_equal(policy, cur_policy),
  79                    "Notify action policy get");
  80         }
  81
  82         ret = lttng_action_serialize(notify_action, &payload);
  83         ok(ret == 0, "Action notify serialized");
  84
  85         {
  86                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
  87                 (void) lttng_action_create_from_payload(&view, &notify_action_from_buffer);
  88         }
  89         ok(notify_action_from_buffer, "Notify action created from payload is non-null");
  90
  91         ok(lttng_action_is_equal(notify_action, notify_action_from_buffer),
  92            "Serialized and de-serialized notify action are equal");
  93
  94         lttng_rate_policy_destroy(default_policy);
  95         lttng_rate_policy_destroy(policy);
  96         lttng_action_destroy(notify_action);
  97         lttng_action_destroy(notify_action_from_buffer);
  98         lttng_payload_reset(&payload);
  99 }
 100
 101 static void test_action_rotate_session(void)
 102 {
 103         int ret;
 104         enum lttng_action_status status;
 105         struct lttng_action *rotate_session_action = NULL,
 106                             *rotate_session_action_from_buffer = NULL;
 107         struct lttng_rate_policy *policy = NULL, *default_policy;
 108         struct lttng_payload payload;
 109         const char *session_name = "my_session_name";
 110         const char *get_session_name;
 111
 112         lttng_payload_init(&payload);
 113
 114         /* To set. */
 115         policy = lttng_rate_policy_every_n_create(100);
 116         /* For comparison. */
 117         default_policy = lttng_rate_policy_every_n_create(1);
 118
 119         LTTNG_ASSERT(policy && default_policy);
 120
 121         rotate_session_action = lttng_action_rotate_session_create();
 122         ok(rotate_session_action, "Create rotate_session action");
 123         ok(lttng_action_get_type(rotate_session_action) == LTTNG_ACTION_TYPE_ROTATE_SESSION,
 124            "Action has type LTTNG_ACTION_TYPE_ROTATE_SESSION");
 125
 126         /* Session name setter. */
 127         status = lttng_action_rotate_session_set_session_name(NULL, NULL);
 128         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 129         status = lttng_action_rotate_session_set_session_name(rotate_session_action, NULL);
 130         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 131         status = lttng_action_rotate_session_set_session_name(NULL, session_name);
 132         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 133
 134         /* Set the session name */
 135         status = lttng_action_rotate_session_set_session_name(rotate_session_action, session_name);
 136         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 137
 138         status = lttng_action_rotate_session_get_session_name(rotate_session_action,
 139                                                               &get_session_name);
 140         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 141            "Get session name, expected `%s` got `%s`",
 142            session_name,
 143            get_session_name);
 144
 145         /* Validate the default policy for a rotate_session action. */
 146         {
 147                 const struct lttng_rate_policy *cur_policy = NULL;
 148                 status = lttng_action_rotate_session_get_rate_policy(rotate_session_action,
 149                                                                      &cur_policy);
 150                 ok(status == LTTNG_ACTION_STATUS_OK &&
 151                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 152                    "Default policy is every n=1");
 153         }
 154
 155         /* Set a custom policy. */
 156         status = lttng_action_rotate_session_set_rate_policy(rotate_session_action, policy);
 157         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 158
 159         /* Validate the custom policy for a rotate_session action. */
 160         {
 161                 const struct lttng_rate_policy *cur_policy = NULL;
 162                 status = lttng_action_rotate_session_get_rate_policy(rotate_session_action,
 163                                                                      &cur_policy);
 164                 ok(status == LTTNG_ACTION_STATUS_OK &&
 165                            lttng_rate_policy_is_equal(policy, cur_policy),
 166                    "rotate_session action policy get");
 167         }
 168
 169         /* Ser/des tests. */
 170         ret = lttng_action_serialize(rotate_session_action, &payload);
 171         ok(ret == 0, "Action rotate_session serialized");
 172
 173         {
 174                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 175                 (void) lttng_action_create_from_payload(&view, &rotate_session_action_from_buffer);
 176         }
 177         ok(rotate_session_action_from_buffer,
 178            "rotate_session action created from payload is non-null");
 179
 180         ok(lttng_action_is_equal(rotate_session_action, rotate_session_action_from_buffer),
 181            "Serialized and de-serialized rotate_session action are equal");
 182
 183         lttng_rate_policy_destroy(default_policy);
 184         lttng_rate_policy_destroy(policy);
 185         lttng_action_destroy(rotate_session_action);
 186         lttng_action_destroy(rotate_session_action_from_buffer);
 187         lttng_payload_reset(&payload);
 188 }
 189
 190 static void test_action_start_session(void)
 191 {
 192         int ret;
 193         enum lttng_action_status status;
 194         struct lttng_action *start_session_action = NULL, *start_session_action_from_buffer = NULL;
 195         struct lttng_rate_policy *policy = NULL, *default_policy;
 196         struct lttng_payload payload;
 197         const char *session_name = "my_session_name";
 198         const char *get_session_name;
 199
 200         lttng_payload_init(&payload);
 201
 202         /* To set. */
 203         policy = lttng_rate_policy_every_n_create(100);
 204         /* For comparison. */
 205         default_policy = lttng_rate_policy_every_n_create(1);
 206
 207         LTTNG_ASSERT(policy && default_policy);
 208
 209         start_session_action = lttng_action_start_session_create();
 210         ok(start_session_action, "Create start_session action");
 211         ok(lttng_action_get_type(start_session_action) == LTTNG_ACTION_TYPE_START_SESSION,
 212            "Action has type LTTNG_ACTION_TYPE_START_SESSION");
 213
 214         /* Session name setter. */
 215         status = lttng_action_start_session_set_session_name(NULL, NULL);
 216         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 217         status = lttng_action_start_session_set_session_name(start_session_action, NULL);
 218         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 219         status = lttng_action_start_session_set_session_name(NULL, session_name);
 220         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 221
 222         /* Set the session name */
 223         status = lttng_action_start_session_set_session_name(start_session_action, session_name);
 224         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 225
 226         status = lttng_action_start_session_get_session_name(start_session_action,
 227                                                              &get_session_name);
 228         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 229            "Get session name, expected `%s` got `%s`",
 230            session_name,
 231            get_session_name);
 232
 233         /* Validate the default policy for a start_session action. */
 234         {
 235                 const struct lttng_rate_policy *cur_policy = NULL;
 236                 status = lttng_action_start_session_get_rate_policy(start_session_action,
 237                                                                     &cur_policy);
 238                 ok(status == LTTNG_ACTION_STATUS_OK &&
 239                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 240                    "Default policy is every n=1");
 241         }
 242
 243         /* Set a custom policy. */
 244         status = lttng_action_start_session_set_rate_policy(start_session_action, policy);
 245         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 246
 247         /* Validate the custom policy for a start_session action. */
 248         {
 249                 const struct lttng_rate_policy *cur_policy = NULL;
 250                 status = lttng_action_start_session_get_rate_policy(start_session_action,
 251                                                                     &cur_policy);
 252                 ok(status == LTTNG_ACTION_STATUS_OK &&
 253                            lttng_rate_policy_is_equal(policy, cur_policy),
 254                    "start_session action policy get");
 255         }
 256
 257         /* Ser/des tests. */
 258         ret = lttng_action_serialize(start_session_action, &payload);
 259         ok(ret == 0, "Action start_session serialized");
 260
 261         {
 262                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 263                 (void) lttng_action_create_from_payload(&view, &start_session_action_from_buffer);
 264         }
 265         ok(start_session_action_from_buffer,
 266            "start_session action created from payload is non-null");
 267
 268         ok(lttng_action_is_equal(start_session_action, start_session_action_from_buffer),
 269            "Serialized and de-serialized start_session action are equal");
 270
 271         lttng_rate_policy_destroy(default_policy);
 272         lttng_rate_policy_destroy(policy);
 273         lttng_action_destroy(start_session_action);
 274         lttng_action_destroy(start_session_action_from_buffer);
 275         lttng_payload_reset(&payload);
 276 }
 277
 278 static void test_action_stop_session(void)
 279 {
 280         int ret;
 281         enum lttng_action_status status;
 282         struct lttng_action *stop_session_action = NULL, *stop_session_action_from_buffer = NULL;
 283         struct lttng_rate_policy *policy = NULL, *default_policy;
 284         struct lttng_payload payload;
 285         const char *session_name = "my_session_name";
 286         const char *get_session_name;
 287
 288         lttng_payload_init(&payload);
 289
 290         /* To set. */
 291         policy = lttng_rate_policy_every_n_create(100);
 292         /* For comparison. */
 293         default_policy = lttng_rate_policy_every_n_create(1);
 294
 295         LTTNG_ASSERT(policy && default_policy);
 296
 297         stop_session_action = lttng_action_stop_session_create();
 298         ok(stop_session_action, "Create stop_session action");
 299         ok(lttng_action_get_type(stop_session_action) == LTTNG_ACTION_TYPE_STOP_SESSION,
 300            "Action has type LTTNG_ACTION_TYPE_STOP_SESSION");
 301
 302         /* Session name setter. */
 303         status = lttng_action_stop_session_set_session_name(NULL, NULL);
 304         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 305         status = lttng_action_stop_session_set_session_name(stop_session_action, NULL);
 306         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 307         status = lttng_action_stop_session_set_session_name(NULL, session_name);
 308         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 309
 310         /* Set the session name */
 311         status = lttng_action_stop_session_set_session_name(stop_session_action, session_name);
 312         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 313
 314         status = lttng_action_stop_session_get_session_name(stop_session_action, &get_session_name);
 315         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 316            "Get session name, expected `%s` got `%s`",
 317            session_name,
 318            get_session_name);
 319
 320         /* Validate the default policy for a stop_session action. */
 321         {
 322                 const struct lttng_rate_policy *cur_policy = NULL;
 323                 status =
 324                         lttng_action_stop_session_get_rate_policy(stop_session_action, &cur_policy);
 325                 ok(status == LTTNG_ACTION_STATUS_OK &&
 326                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 327                    "Default policy is every n=1");
 328         }
 329
 330         /* Set a custom policy. */
 331         status = lttng_action_stop_session_set_rate_policy(stop_session_action, policy);
 332         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 333
 334         /* Validate the custom policy for a stop_session action. */
 335         {
 336                 const struct lttng_rate_policy *cur_policy = NULL;
 337                 status =
 338                         lttng_action_stop_session_get_rate_policy(stop_session_action, &cur_policy);
 339                 ok(status == LTTNG_ACTION_STATUS_OK &&
 340                            lttng_rate_policy_is_equal(policy, cur_policy),
 341                    "stop_session action policy get");
 342         }
 343
 344         /* Ser/des tests. */
 345         ret = lttng_action_serialize(stop_session_action, &payload);
 346         ok(ret == 0, "Action stop_session serialized");
 347
 348         {
 349                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 350                 (void) lttng_action_create_from_payload(&view, &stop_session_action_from_buffer);
 351         }
 352         ok(stop_session_action_from_buffer, "stop_session action created from payload is non-null");
 353
 354         ok(lttng_action_is_equal(stop_session_action, stop_session_action_from_buffer),
 355            "Serialized and de-serialized stop_session action are equal");
 356
 357         lttng_rate_policy_destroy(default_policy);
 358         lttng_rate_policy_destroy(policy);
 359         lttng_action_destroy(stop_session_action);
 360         lttng_action_destroy(stop_session_action_from_buffer);
 361         lttng_payload_reset(&payload);
 362 }
 363
 364 static void test_action_snapshot_session(void)
 365 {
 366         int ret;
 367         enum lttng_action_status status;
 368         struct lttng_action *snapshot_session_action = NULL,
 369                             *snapshot_session_action_from_buffer = NULL;
 370         struct lttng_rate_policy *policy = NULL, *default_policy;
 371         struct lttng_payload payload;
 372         const char *session_name = "my_session_name";
 373         const char *get_session_name;
 374
 375         lttng_payload_init(&payload);
 376
 377         /* To set. */
 378         policy = lttng_rate_policy_every_n_create(100);
 379         /* For comparison. */
 380         default_policy = lttng_rate_policy_every_n_create(1);
 381
 382         LTTNG_ASSERT(policy && default_policy);
 383
 384         snapshot_session_action = lttng_action_snapshot_session_create();
 385         ok(snapshot_session_action, "Create snapshot_session action");
 386         ok(lttng_action_get_type(snapshot_session_action) == LTTNG_ACTION_TYPE_SNAPSHOT_SESSION,
 387            "Action has type LTTNG_ACTION_TYPE_SNAPSHOT_SESSION");
 388
 389         /* Session name setter. */
 390         status = lttng_action_snapshot_session_set_session_name(NULL, NULL);
 391         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 392         status = lttng_action_snapshot_session_set_session_name(snapshot_session_action, NULL);
 393         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 394         status = lttng_action_snapshot_session_set_session_name(NULL, session_name);
 395         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 396
 397         /* Set the session name */
 398         status = lttng_action_snapshot_session_set_session_name(snapshot_session_action,
 399                                                                 session_name);
 400         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 401
 402         status = lttng_action_snapshot_session_get_session_name(snapshot_session_action,
 403                                                                 &get_session_name);
 404         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 405            "Get session name, expected `%s` got `%s`",
 406            session_name,
 407            get_session_name);
 408
 409         /* Validate the default policy for a snapshot_session action. */
 410         {
 411                 const struct lttng_rate_policy *cur_policy = NULL;
 412                 status = lttng_action_snapshot_session_get_rate_policy(snapshot_session_action,
 413                                                                        &cur_policy);
 414                 ok(status == LTTNG_ACTION_STATUS_OK &&
 415                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 416                    "Default policy is every n=1");
 417         }
 418
 419         /* Set a custom policy. */
 420         status = lttng_action_snapshot_session_set_rate_policy(snapshot_session_action, policy);
 421         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 422
 423         /* Validate the custom policy for a snapshot_session action. */
 424         {
 425                 const struct lttng_rate_policy *cur_policy = NULL;
 426                 status = lttng_action_snapshot_session_get_rate_policy(snapshot_session_action,
 427                                                                        &cur_policy);
 428                 ok(status == LTTNG_ACTION_STATUS_OK &&
 429                            lttng_rate_policy_is_equal(policy, cur_policy),
 430                    "snapshot_session action policy get");
 431         }
 432
 433         /* Ser/des tests. */
 434         ret = lttng_action_serialize(snapshot_session_action, &payload);
 435         ok(ret == 0, "Action snapshot_session serialized");
 436
 437         {
 438                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 439                 (void) lttng_action_create_from_payload(&view,
 440                                                         &snapshot_session_action_from_buffer);
 441         }
 442         ok(snapshot_session_action_from_buffer,
 443            "snapshot_session action created from payload is non-null");
 444
 445         ok(lttng_action_is_equal(snapshot_session_action, snapshot_session_action_from_buffer),
 446            "Serialized and de-serialized snapshot_session action are equal");
 447
 448         lttng_rate_policy_destroy(default_policy);
 449         lttng_rate_policy_destroy(policy);
 450         lttng_action_destroy(snapshot_session_action);
 451         lttng_action_destroy(snapshot_session_action_from_buffer);
 452         lttng_payload_reset(&payload);
 453 }
 454
 455 int main(void)
 456 {
 457         plan_tests(NUM_TESTS);
 458         test_action_notify();
 459         test_action_rotate_session();
 460         test_action_start_session();
 461         test_action_stop_session();
 462         test_action_snapshot_session();
 463         return exit_status();
 464 }