1 #include "irc_chan.h"

     2 #include "irc_net.h"

     3 #include "test.h"

     4 

     5 

     6 static void _on_chan_self_join (struct irc_chan *chan, void *arg)

     7 {

     8     struct test_chan_ctx *ctx = arg;

     9 

    10     assert(chan == ctx->chan);

    11     

    12     ctx->on_chan_self_join = true;

    13 

    14     log_debug("on_self_join");

    15 }

    16 

    17 static void _on_chan_join (struct irc_chan *chan, const struct irc_nm *source, void *arg)

    18 {

    19     struct test_chan_ctx *ctx = arg;

    20 

    21     assert(chan == ctx->chan);

    22 

    23     // XXX: verify source

    24 

    25     ctx->on_chan_join = true;

    26 

    27     log_debug("on_join");

    28 }

    29 

    30 static void _on_chan_part (struct irc_chan *chan, const struct irc_nm *source, const char *msg, void *arg)

    31 {

    32     struct test_chan_ctx *ctx = arg;

    33 

    34     assert(chan == ctx->chan);

    35 

    36     // XXX: verify source

    37     // XXX: verify msg

    38 

    39     ctx->on_chan_part = true;

    40 

    41     log_debug("on_part");

    42 }

    43 

    44 

    45 struct irc_chan_callbacks _chan_callbacks = {

    46     .on_self_join       = _on_chan_self_join,

    47     .on_join            = _on_chan_join,

    48     .on_part            = _on_chan_part,

    49 };

    50 

    51 

    52 struct irc_chan_user* check_chan_user (struct irc_chan *chan, const char *nickname, bool exists)

    53 {

    54     struct irc_chan_user *chan_user = irc_chan_get_user(chan, nickname);

    55     

    56     if (exists && chan_user == NULL)

    57         FATAL("user %s not found in channel %s", dump_str(nickname), dump_str(irc_chan_name(chan)));

    58     

    59     if (!exists && chan_user)

    60         FATAL("user %s should not be on channel %s anymore", dump_str(nickname), dump_str(irc_chan_name(chan)));

    61 

    62     log_debug("%s, exists=%d -> %p: user=%p, nickname=%s", 

    63             nickname, exists, chan_user, chan_user ? chan_user->user : NULL, chan_user ? chan_user->user->nickname : NULL);

    64     

    65     if (chan_user)

    66         assert_strcmp(chan_user->user->nickname, nickname);

    67 

    68     return chan_user;

    69 }

    70 

    71 /**

    72  * Creates an irc_chan on the given irc_net, but does not check any output (useful for testing offline add).

    73  *

    74  * You must pass a test_chan_ctx for use with later operations, this will be initialized for you.

    75  */

    76 static struct irc_chan* setup_irc_chan_raw (struct irc_net *net, const char *channel, struct test_chan_ctx *ctx)

    77 {

    78     struct irc_chan *chan;

    79     struct irc_chan_info chan_info = {

    80         .channel        = channel,

    81     };

    82     struct error_info err;

    83     

    84     // initialize the given ctx

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

    86     ctx->channel = channel;

    87 

    88     // add a channel

    89     assert_success(irc_net_add_chan(net, &chan, &chan_info, &err));

    90     assert(!chan->joined);

    91     assert_success(irc_chan_add_callbacks(chan, &_chan_callbacks, ctx));

    92     ctx->chan = chan;

    93     

    94     // ok

    95     return chan;

    96 }

    97 

    98 /**

    99  * Checks that the JOIN request for a channel was sent, and sends the basic JOIN reply

   100  */

   101 static void do_irc_chan_join (struct transport_test *tp, struct test_chan_ctx *ctx)

   102 {

   103     // JOIN request

   104     assert(ctx->chan->joining);

   105     assert_transport_data(tp, "JOIN %s\r\n", ctx->channel);

   106 

   107     // JOIN reply

   108     transport_test_push_fmt(tp, ":mynick!user@host JOIN %s\r\n", ctx->channel);

   109     assert(!ctx->chan->joining && ctx->chan->joined);

   110     assert(ctx->on_chan_self_join);

   111 }

   112 

   113 /**

   114  * Sends a short RPL_NAMREPLY/RPL_ENDOFNAMES reply and checks that the users list matches

   115  */

   116 static void do_irc_chan_namreply (struct transport_test *tp, struct test_chan_ctx *ctx)

   117 {

   118     // RPL_NAMREPLY

   119     transport_test_push_fmt(tp, "353 mynick = %s :mynick userA +userB @userC\r\n", ctx->channel);

   120     transport_test_push_fmt(tp, "353 mynick = %s :trailingspace \r\n", ctx->channel);

   121     transport_test_push_fmt(tp, "366 mynick %s :End of NAMES\r\n", ctx->channel);

   122     

   123     // XXX: this should be an exclusive test, i.e. these should be the only ones...

   124     check_chan_user(ctx->chan, "mynick", true);

   125     check_chan_user(ctx->chan, "userA", true);

   126     check_chan_user(ctx->chan, "userB", true);

   127     check_chan_user(ctx->chan, "userC", true);

   128 }

   129 

   130 /**

   131  * Creates an irc_chan on the given irc_net, and checks up to the JOIN reply

   132  */

   133 static struct irc_chan* setup_irc_chan_join (struct transport_test *tp, struct irc_net *net, const char *channel, struct test_chan_ctx *ctx)

   134 {

   135     setup_irc_chan_raw(net, channel, ctx);

   136     do_irc_chan_join(tp, ctx);

   137 

   138     // ok

   139     return ctx->chan;

   140 }

   141 

   142 struct irc_chan* setup_irc_chan (struct transport_test *tp, struct irc_net *net, const char *channel, struct test_chan_ctx *ctx)

   143 {

   144     setup_irc_chan_raw(net, channel, ctx);

   145     do_irc_chan_join(tp, ctx);

   146     do_irc_chan_namreply(tp, ctx);

   147 

   148     // ok

   149     return ctx->chan;

   150 }

   151 

   152 

   153 void test_irc_chan_add_offline (void)

   154 {

   155     struct test_chan_ctx ctx;

   156     struct transport_test *tp = setup_transport_test();

   157     struct irc_net *net = setup_irc_net_unregistered(tp);

   158 

   159     // add an offline channel

   160     log_info("test offline irc_net_add_chan");

   161     struct irc_chan *chan = setup_irc_chan_raw(net, "#test", &ctx);

   162     assert(!chan->joining && !chan->joined);

   163 

   164     // send the registration reply

   165     log_info("test irc_conn_on_RPL_WELCOME");

   166     test_irc_net_welcome(tp, net);

   167     

   168     // test the join sequence

   169     log_info("test irc_chan_join/irc_chan_on_JOIN");

   170     do_irc_chan_join(tp, &ctx);

   171     

   172     // cleanup

   173     irc_net_destroy(net);

   174 }

   175 

   176 void test_irc_chan_namreply (void)

   177 {

   178     struct test_chan_ctx ctx;

   179     struct transport_test *tp = setup_transport_test();

   180     struct irc_net *net = setup_irc_net(tp);

   181     setup_irc_chan_join(tp, net, "#test", &ctx);

   182 

   183     log_info("test irc_chan_on_RPL_NAMREPLY");

   184     do_irc_chan_namreply(tp, &ctx);

   185 

   186     // cleanup

   187     irc_net_destroy(net);

   188 }

   189 

   190 void test_irc_chan_user_join (void)

   191 {

   192     struct test_chan_ctx ctx;

   193     struct transport_test *tp = setup_transport_test();

   194     struct irc_net *net = setup_irc_net(tp);

   195     struct irc_chan *chan = setup_irc_chan(tp, net, "#test", &ctx);

   196 

   197     // have a user join

   198     log_info("test irc_chan_on_JOIN");

   199     transport_test_push_fmt(tp, ":newuser!someone@somewhere JOIN %s\r\n", "#test");

   200     assert(ctx.on_chan_join);

   201     check_chan_user(chan, "newuser", true);

   202 

   203     // cleanup

   204     irc_net_destroy(net);

   205 }

   206 

   207 void test_irc_chan_user_part (void)

   208 {

   209     struct test_chan_ctx ctx;

   210     struct transport_test *tp = setup_transport_test();

   211     struct irc_net *net = setup_irc_net(tp);

   212     struct irc_chan *chan = setup_irc_chan(tp, net, "#test", &ctx);

   213 

   214     // have a user join

   215     log_info("test irc_chan_on_PART");

   216     transport_test_push_fmt(tp, ":userA!someone@somewhere PART %s\r\n", "#test");

   217     assert(ctx.on_chan_part); ctx.on_chan_part = NULL;

   218     check_chan_user(chan, "userA", false);

   219 

   220     // cleanup

   221     irc_net_destroy(net);

   222 }

   223 

   224 void test_irc_chan_user_kick (void)

   225 {

   226     struct test_chan_ctx ctx;

   227     struct transport_test *tp = setup_transport_test();

   228     struct irc_net *net = setup_irc_net(tp);

   229     struct irc_chan *chan = setup_irc_chan(tp, net, "#test", &ctx);

   230 

   231     // kick a user

   232     log_info("test irc_chan_on_KICK (other)");

   233     transport_test_push_fmt(tp, ":userA!someone@somewhere KICK %s userB\r\n", "#test");

   234     check_chan_user(chan, "userA", true);

   235     check_chan_user(chan, "userB", false);

   236 

   237     // cleanup

   238     irc_net_destroy(net);

   239 }

   240 

   241 void test_irc_chan_self_kick (void)

   242 {

   243     struct test_chan_ctx ctx;

   244     struct transport_test *tp = setup_transport_test();

   245     struct irc_net *net = setup_irc_net(tp);

   246     struct irc_chan *chan = setup_irc_chan(tp, net, "#test", &ctx);

   247 

   248     // kick a user

   249     log_info("test irc_chan_on_KICK (self)");

   250     transport_test_push_fmt(tp, ":userA!someone@somewhere KICK %s mynick foobar\r\n", "#test");

   251     assert(!chan->joined);

   252     assert(chan->kicked);

   253 

   254     // cleanup

   255     irc_net_destroy(net);

   256 }

   257 

   258 void test_irc_chan_user_nick (void)

   259 {

   260     struct test_chan_ctx ctx;

   261     struct transport_test *tp = setup_transport_test();

   262     struct irc_net *net = setup_irc_net(tp);

   263     struct irc_chan *chan = setup_irc_chan(tp, net, "#test", &ctx);

   264 

   265     // rename one of the users

   266     log_info("test irc_net_on_chanuser");

   267     transport_test_push_fmt(tp, ":userA!someone@somewhere NICK userA2\r\n");

   268     check_chan_user(chan, "userA", false);

   269     check_chan_user(chan, "userB", true);

   270 

   271     // cleanup

   272     irc_net_destroy(net);

   273 }

   274 

   275 void test_irc_chan_user_quit (void)

   276 {

   277     struct test_chan_ctx ctx;

   278     struct transport_test *tp = setup_transport_test();

   279     struct irc_net *net = setup_irc_net(tp);

   280     struct irc_chan *chan = setup_irc_chan(tp, net, "#test", &ctx);

   281 

   282     // rename one of the users

   283     log_info("test irc_net_on_chanuser");

   284     transport_test_push_fmt(tp, ":userA!someone@somewhere QUIT foo\r\n");

   285     check_chan_user(chan, "userA", false);

   286 

   287     // cleanup

   288     irc_net_destroy(net);

   289 }

   290 

   291 void _test_irc_chan_on_CTCP_ACTION (const struct irc_line *line, void *arg)

   292 {

   293     bool *flag = arg;

   294 

   295     log_debug("CTCP ACTION");

   296 

   297     *flag = true;

   298 }

   299 

   300 static struct irc_cmd_handler _test_irc_chan_handlers[] = {

   301     {   "CTCP ACTION",      &_test_irc_chan_on_CTCP_ACTION  },

   302     {   NULL,               NULL                            }

   303 };

   304 

   305 void test_irc_chan_CTCP_ACTION (void)

   306 {

   307     struct test_chan_ctx ctx;

   308     struct transport_test *tp = setup_transport_test();

   309     struct irc_net *net = setup_irc_net(tp);

   310     struct irc_chan *chan = setup_irc_chan(tp, net, "#test", &ctx);

   311     bool cb_ok = false;

   312 

   313     // add our handler

   314     assert_success(irc_cmd_add(&chan->handlers, _test_irc_chan_handlers, &cb_ok));

   315 

   316     // rename one of the users

   317     log_info("test irc_conn_on_CTCP_ACTION");

   318     transport_test_push_fmt(tp, ":userA!someone@somewhere PRIVMSG #test \001ACTION hello  world\001\r\n");

   319     assert(cb_ok);

   320 

   321     // cleanup

   322     irc_net_destroy(net);

   323 }

   324 

   325 void test_irc_chan_privmsg (void)

   326 {

   327     struct test_chan_ctx ctx;

   328     struct transport_test *tp = setup_transport_test();

   329     struct irc_net *net = setup_irc_net(tp);

   330     struct irc_chan *chan = setup_irc_chan(tp, net, "#test", &ctx);

   331 

   332     // rename one of the users

   333     log_info("test irc_chan_PRIVMSG");

   334     assert_success(irc_chan_PRIVMSG(chan, "foobar quux"));

   335     assert_transport_data(tp, "PRIVMSG #test :foobar quux\r\n");

   336 

   337     // cleanup

   338     irc_net_destroy(net);

   339 }

   340