1 #include "irc_conn.h"

     2 #include "test.h"

     3 

     4 static void _conn_on_registered (struct irc_conn *conn, void *arg)

     5 {

     6     struct test_conn_ctx *ctx = arg;

     7 

     8     (void) conn;

     9 

    10     if (ctx) ctx->on_registered = true;

    11 

    12     log_debug("registered");

    13 }

    14 

    15 static void _conn_on_error (struct irc_conn *conn, struct error_info *err, void *arg)

    16 {

    17     struct test_conn_ctx *ctx = arg;

    18     

    19     (void) conn;

    20     (void) err;

    21 

    22     if (ctx) ctx->on_error = true;

    23 

    24     log_debug("on_error");

    25 }

    26 

    27 static void _conn_on_quit (struct irc_conn *conn, void *arg)

    28 {

    29     struct test_conn_ctx *ctx = arg;

    30 

    31     (void) conn;

    32 

    33     if (ctx) ctx->on_quit = true;

    34 

    35     log_debug("on_quit");

    36 }

    37 

    38 static void _conn_on_TEST (const struct irc_line *line, void *arg)

    39 {

    40     struct test_conn_ctx *ctx = arg;

    41 

    42     assert(line->source);

    43     assert(!line->source->nickname && !line->source->username && line->source->hostname);

    44     assert_strcmp(line->command, "TEST");

    45     assert_strcmp(line->args[0], "arg0");

    46     assert_strnull(line->args[1]);

    47 

    48     if (ctx) ctx->on_TEST = true;

    49 

    50     log_debug("on_TEST");

    51 }

    52 

    53 static struct irc_conn_callbacks _conn_callbacks = {

    54     .on_registered      = &_conn_on_registered,

    55     .on_error           = &_conn_on_error,

    56     .on_quit            = &_conn_on_quit,

    57 };

    58 

    59 static struct irc_cmd_handler _conn_handlers[] = {

    60     {   "TEST",         &_conn_on_TEST  },

    61     {   NULL,           NULL            }

    62 };

    63 

    64 struct irc_conn* setup_irc_conn (struct transport_test *tp, bool noisy, struct test_conn_ctx *ctx)

    65 {

    66     struct irc_conn *conn;

    67     struct error_info err;

    68     struct irc_conn_register_info register_info = {

    69         "nick", "user", "realname"

    70     };

    71 

    72     // init the ctx

    73     memset(ctx, 0, sizeof(*ctx));

    74 

    75     // create the irc_conn

    76     assert_success(irc_conn_create(&conn, transport_test_cast(tp), &_conn_callbacks, ctx, &err));

    77 

    78     // test register

    79     if (noisy) log_info("test irc_conn_register");

    80     assert_success(irc_conn_register(conn, &register_info));

    81     assert_transport_data(tp, "NICK nick\r\nUSER user 0 * realname\r\n");

    82  

    83     // test on_register callback    

    84     if (noisy) log_info("test irc_conn_callbacks.on_register");

    85     transport_test_push_str(tp, "001 mynick :Blaa blaa blaa\r\n");

    86     if (ctx) assert(ctx->on_registered);

    87     assert_strcmp(conn->nickname, "mynick");

    88    

    89     // ok

    90     return conn;

    91 }

    92 

    93 void test_irc_conn (void)

    94 {

    95     struct test_conn_ctx ctx;

    96     struct transport_test *tp = setup_transport_test();

    97     struct irc_conn *conn = setup_irc_conn(tp, true, &ctx);

    98 

    99     // add our test handlers

   100     assert_success(irc_conn_add_cmd_handlers(conn, _conn_handlers, &ctx));

   101 

   102     // test on_TEST handler

   103     // XXX: come up with a better prefix

   104     log_info("test irc_conn.handlers");

   105     transport_test_push_str(tp, ":foobar-prefix TEST arg0\r\n");

   106     assert(ctx.on_TEST);

   107 

   108     // test PING/PONG

   109     log_info("test PING/PONG");

   110     transport_test_push_str(tp, "PING foo\r\n");

   111     assert_transport_data(tp, "PONG foo\r\n");

   112 

   113     // quit nicely

   114     log_info("test QUIT");

   115     assert_success(irc_conn_QUIT(conn, "bye now"));

   116     assert_transport_data(tp, "QUIT :bye now\r\n");

   117     assert(conn->quitting);

   118 

   119     transport_test_push_str(tp, "ERROR :Closing Link: Quit\r\n");

   120     transport_test_push_eof(tp);

   121     assert(conn->quit && !conn->quitting && !conn->registered);

   122     assert(ctx.on_quit);

   123     assert(!ctx.on_error);

   124 

   125     // destroy it

   126     irc_conn_destroy(conn);

   127 }

   128 

   129 void test_irc_conn_self_nick (void)

   130 {

   131     struct test_conn_ctx ctx;

   132     struct transport_test *tp = setup_transport_test();

   133     struct irc_conn *conn = setup_irc_conn(tp, false, &ctx);

   134     

   135     log_info("test irc_conn_on_NICK");

   136     transport_test_push_fmt(tp, ":mynick!user@somehost NICK mynick2\r\n");

   137     assert_strcmp(conn->nickname, "mynick2");

   138 

   139     // cleanup

   140     irc_conn_destroy(conn);

   141 }

   142