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()
  39 {
  40         int ret;
  41         enum lttng_action_status status;
  42         struct lttng_action *notify_action = nullptr, *notify_action_from_buffer = nullptr;
  43         struct lttng_rate_policy *policy = nullptr, *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 = nullptr;
  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 = nullptr;
  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()
 102 {
 103         int ret;
 104         enum lttng_action_status status;
 105         struct lttng_action *rotate_session_action = nullptr,
 106                             *rotate_session_action_from_buffer = nullptr;
 107         struct lttng_rate_policy *policy = nullptr, *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(nullptr, nullptr);
 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, nullptr);
 130         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 131         status = lttng_action_rotate_session_set_session_name(nullptr, 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 = nullptr;
 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 = nullptr;
 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()
 191 {
 192         int ret;
 193         enum lttng_action_status status;
 194         struct lttng_action *start_session_action = nullptr,
 195                             *start_session_action_from_buffer = nullptr;
 196         struct lttng_rate_policy *policy = nullptr, *default_policy;
 197         struct lttng_payload payload;
 198         const char *session_name = "my_session_name";
 199         const char *get_session_name;
 200
 201         lttng_payload_init(&payload);
 202
 203         /* To set. */
 204         policy = lttng_rate_policy_every_n_create(100);
 205         /* For comparison. */
 206         default_policy = lttng_rate_policy_every_n_create(1);
 207
 208         LTTNG_ASSERT(policy && default_policy);
 209
 210         start_session_action = lttng_action_start_session_create();
 211         ok(start_session_action, "Create start_session action");
 212         ok(lttng_action_get_type(start_session_action) == LTTNG_ACTION_TYPE_START_SESSION,
 213            "Action has type LTTNG_ACTION_TYPE_START_SESSION");
 214
 215         /* Session name setter. */
 216         status = lttng_action_start_session_set_session_name(nullptr, nullptr);
 217         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 218         status = lttng_action_start_session_set_session_name(start_session_action, nullptr);
 219         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 220         status = lttng_action_start_session_set_session_name(nullptr, session_name);
 221         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 222
 223         /* Set the session name */
 224         status = lttng_action_start_session_set_session_name(start_session_action, session_name);
 225         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 226
 227         status = lttng_action_start_session_get_session_name(start_session_action,
 228                                                              &get_session_name);
 229         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 230            "Get session name, expected `%s` got `%s`",
 231            session_name,
 232            get_session_name);
 233
 234         /* Validate the default policy for a start_session action. */
 235         {
 236                 const struct lttng_rate_policy *cur_policy = nullptr;
 237                 status = lttng_action_start_session_get_rate_policy(start_session_action,
 238                                                                     &cur_policy);
 239                 ok(status == LTTNG_ACTION_STATUS_OK &&
 240                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 241                    "Default policy is every n=1");
 242         }
 243
 244         /* Set a custom policy. */
 245         status = lttng_action_start_session_set_rate_policy(start_session_action, policy);
 246         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 247
 248         /* Validate the custom policy for a start_session action. */
 249         {
 250                 const struct lttng_rate_policy *cur_policy = nullptr;
 251                 status = lttng_action_start_session_get_rate_policy(start_session_action,
 252                                                                     &cur_policy);
 253                 ok(status == LTTNG_ACTION_STATUS_OK &&
 254                            lttng_rate_policy_is_equal(policy, cur_policy),
 255                    "start_session action policy get");
 256         }
 257
 258         /* Ser/des tests. */
 259         ret = lttng_action_serialize(start_session_action, &payload);
 260         ok(ret == 0, "Action start_session serialized");
 261
 262         {
 263                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 264                 (void) lttng_action_create_from_payload(&view, &start_session_action_from_buffer);
 265         }
 266         ok(start_session_action_from_buffer,
 267            "start_session action created from payload is non-null");
 268
 269         ok(lttng_action_is_equal(start_session_action, start_session_action_from_buffer),
 270            "Serialized and de-serialized start_session action are equal");
 271
 272         lttng_rate_policy_destroy(default_policy);
 273         lttng_rate_policy_destroy(policy);
 274         lttng_action_destroy(start_session_action);
 275         lttng_action_destroy(start_session_action_from_buffer);
 276         lttng_payload_reset(&payload);
 277 }
 278
 279 static void test_action_stop_session()
 280 {
 281         int ret;
 282         enum lttng_action_status status;
 283         struct lttng_action *stop_session_action = nullptr,
 284                             *stop_session_action_from_buffer = nullptr;
 285         struct lttng_rate_policy *policy = nullptr, *default_policy;
 286         struct lttng_payload payload;
 287         const char *session_name = "my_session_name";
 288         const char *get_session_name;
 289
 290         lttng_payload_init(&payload);
 291
 292         /* To set. */
 293         policy = lttng_rate_policy_every_n_create(100);
 294         /* For comparison. */
 295         default_policy = lttng_rate_policy_every_n_create(1);
 296
 297         LTTNG_ASSERT(policy && default_policy);
 298
 299         stop_session_action = lttng_action_stop_session_create();
 300         ok(stop_session_action, "Create stop_session action");
 301         ok(lttng_action_get_type(stop_session_action) == LTTNG_ACTION_TYPE_STOP_SESSION,
 302            "Action has type LTTNG_ACTION_TYPE_STOP_SESSION");
 303
 304         /* Session name setter. */
 305         status = lttng_action_stop_session_set_session_name(nullptr, nullptr);
 306         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 307         status = lttng_action_stop_session_set_session_name(stop_session_action, nullptr);
 308         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 309         status = lttng_action_stop_session_set_session_name(nullptr, session_name);
 310         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 311
 312         /* Set the session name */
 313         status = lttng_action_stop_session_set_session_name(stop_session_action, session_name);
 314         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 315
 316         status = lttng_action_stop_session_get_session_name(stop_session_action, &get_session_name);
 317         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 318            "Get session name, expected `%s` got `%s`",
 319            session_name,
 320            get_session_name);
 321
 322         /* Validate the default policy for a stop_session action. */
 323         {
 324                 const struct lttng_rate_policy *cur_policy = nullptr;
 325                 status =
 326                         lttng_action_stop_session_get_rate_policy(stop_session_action, &cur_policy);
 327                 ok(status == LTTNG_ACTION_STATUS_OK &&
 328                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 329                    "Default policy is every n=1");
 330         }
 331
 332         /* Set a custom policy. */
 333         status = lttng_action_stop_session_set_rate_policy(stop_session_action, policy);
 334         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 335
 336         /* Validate the custom policy for a stop_session action. */
 337         {
 338                 const struct lttng_rate_policy *cur_policy = nullptr;
 339                 status =
 340                         lttng_action_stop_session_get_rate_policy(stop_session_action, &cur_policy);
 341                 ok(status == LTTNG_ACTION_STATUS_OK &&
 342                            lttng_rate_policy_is_equal(policy, cur_policy),
 343                    "stop_session action policy get");
 344         }
 345
 346         /* Ser/des tests. */
 347         ret = lttng_action_serialize(stop_session_action, &payload);
 348         ok(ret == 0, "Action stop_session serialized");
 349
 350         {
 351                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 352                 (void) lttng_action_create_from_payload(&view, &stop_session_action_from_buffer);
 353         }
 354         ok(stop_session_action_from_buffer, "stop_session action created from payload is non-null");
 355
 356         ok(lttng_action_is_equal(stop_session_action, stop_session_action_from_buffer),
 357            "Serialized and de-serialized stop_session action are equal");
 358
 359         lttng_rate_policy_destroy(default_policy);
 360         lttng_rate_policy_destroy(policy);
 361         lttng_action_destroy(stop_session_action);
 362         lttng_action_destroy(stop_session_action_from_buffer);
 363         lttng_payload_reset(&payload);
 364 }
 365
 366 static void test_action_snapshot_session()
 367 {
 368         int ret;
 369         enum lttng_action_status status;
 370         struct lttng_action *snapshot_session_action = nullptr,
 371                             *snapshot_session_action_from_buffer = nullptr;
 372         struct lttng_rate_policy *policy = nullptr, *default_policy;
 373         struct lttng_payload payload;
 374         const char *session_name = "my_session_name";
 375         const char *get_session_name;
 376
 377         lttng_payload_init(&payload);
 378
 379         /* To set. */
 380         policy = lttng_rate_policy_every_n_create(100);
 381         /* For comparison. */
 382         default_policy = lttng_rate_policy_every_n_create(1);
 383
 384         LTTNG_ASSERT(policy && default_policy);
 385
 386         snapshot_session_action = lttng_action_snapshot_session_create();
 387         ok(snapshot_session_action, "Create snapshot_session action");
 388         ok(lttng_action_get_type(snapshot_session_action) == LTTNG_ACTION_TYPE_SNAPSHOT_SESSION,
 389            "Action has type LTTNG_ACTION_TYPE_SNAPSHOT_SESSION");
 390
 391         /* Session name setter. */
 392         status = lttng_action_snapshot_session_set_session_name(nullptr, nullptr);
 393         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,NULL) expect invalid");
 394         status = lttng_action_snapshot_session_set_session_name(snapshot_session_action, nullptr);
 395         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (object,NULL) expect invalid");
 396         status = lttng_action_snapshot_session_set_session_name(nullptr, session_name);
 397         ok(status == LTTNG_ACTION_STATUS_INVALID, "Set session name (NULL,object) expect invalid");
 398
 399         /* Set the session name */
 400         status = lttng_action_snapshot_session_set_session_name(snapshot_session_action,
 401                                                                 session_name);
 402         ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
 403
 404         status = lttng_action_snapshot_session_get_session_name(snapshot_session_action,
 405                                                                 &get_session_name);
 406         ok(status == LTTNG_ACTION_STATUS_OK && !strcmp(session_name, get_session_name),
 407            "Get session name, expected `%s` got `%s`",
 408            session_name,
 409            get_session_name);
 410
 411         /* Validate the default policy for a snapshot_session action. */
 412         {
 413                 const struct lttng_rate_policy *cur_policy = nullptr;
 414                 status = lttng_action_snapshot_session_get_rate_policy(snapshot_session_action,
 415                                                                        &cur_policy);
 416                 ok(status == LTTNG_ACTION_STATUS_OK &&
 417                            lttng_rate_policy_is_equal(default_policy, cur_policy),
 418                    "Default policy is every n=1");
 419         }
 420
 421         /* Set a custom policy. */
 422         status = lttng_action_snapshot_session_set_rate_policy(snapshot_session_action, policy);
 423         ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
 424
 425         /* Validate the custom policy for a snapshot_session action. */
 426         {
 427                 const struct lttng_rate_policy *cur_policy = nullptr;
 428                 status = lttng_action_snapshot_session_get_rate_policy(snapshot_session_action,
 429                                                                        &cur_policy);
 430                 ok(status == LTTNG_ACTION_STATUS_OK &&
 431                            lttng_rate_policy_is_equal(policy, cur_policy),
 432                    "snapshot_session action policy get");
 433         }
 434
 435         /* Ser/des tests. */
 436         ret = lttng_action_serialize(snapshot_session_action, &payload);
 437         ok(ret == 0, "Action snapshot_session serialized");
 438
 439         {
 440                 struct lttng_payload_view view = lttng_payload_view_from_payload(&payload, 0, -1);
 441                 (void) lttng_action_create_from_payload(&view,
 442                                                         &snapshot_session_action_from_buffer);
 443         }
 444         ok(snapshot_session_action_from_buffer,
 445            "snapshot_session action created from payload is non-null");
 446
 447         ok(lttng_action_is_equal(snapshot_session_action, snapshot_session_action_from_buffer),
 448            "Serialized and de-serialized snapshot_session action are equal");
 449
 450         lttng_rate_policy_destroy(default_policy);
 451         lttng_rate_policy_destroy(policy);
 452         lttng_action_destroy(snapshot_session_action);
 453         lttng_action_destroy(snapshot_session_action_from_buffer);
 454         lttng_payload_reset(&payload);
 455 }
 456
 457 int main()
 458 {
 459         plan_tests(NUM_TESTS);
 460         test_action_notify();
 461         test_action_rotate_session();
 462         test_action_start_session();
 463         test_action_stop_session();
 464         test_action_snapshot_session();
 465         return exit_status();
 466 }