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