Vsevolod Stakhov
11 years ago
14 changed files with 93 additions and 410 deletions
-
5test/CMakeLists.txt
-
16test/Makefile.in
-
21test/rspamd_dkim_test.c
-
115test/rspamd_dns_test.c
-
8test/rspamd_expression_test.c
-
6test/rspamd_fuzzy_test.c
-
6test/rspamd_mem_pool_test.c
-
85test/rspamd_memcached_test.c
-
196test/rspamd_rcl_test.c
-
2test/rspamd_rrd_test.c
-
16test/rspamd_statfile_test.c
-
13test/rspamd_test_suite.c
-
8test/rspamd_url_test.c
-
6test/tests.h
@ -1,16 +0,0 @@ |
|||
.PHONY: clean |
|||
|
|||
all: rspamd_test_suite |
|||
|
|||
rspamd_test_suite: $(OBJECTS) $(OBJ_DEPENDS) |
|||
$(CC) $(PTHREAD_LDFLAGS) $(LDFLAGS) $(OBJECTS) $(OBJ_DEPENDS) $(LIBS) -o rspamd_test_suite |
|||
|
|||
run_test: rspamd_test_suite |
|||
gtester --verbose -k -o=rspamd_test.xml ./rspamd_test_suite |
|||
less rspamd_test.xml && rm -f rspamd_test.xml |
|||
|
|||
clean: |
|||
rm -f *.o rspamd_test_suite *.core rspamd_test.xml |
|||
|
|||
dist-clean: clean |
|||
rm -f Makefile |
|||
@ -1,110 +1,107 @@ |
|||
|
|||
#include "../src/config.h" |
|||
#include "config.h" |
|||
#include "tests.h" |
|||
#include "../src/dns.h" |
|||
#include "../src/logger.h" |
|||
#include "../src/main.h" |
|||
#include "../src/events.h" |
|||
#include "../src/cfg_file.h" |
|||
#include "dns.h" |
|||
#include "logger.h" |
|||
#include "main.h" |
|||
#include "events.h" |
|||
#include "cfg_file.h" |
|||
|
|||
static guint requests = 0; |
|||
extern struct event_base *base; |
|||
struct rspamd_dns_resolver *resolver; |
|||
|
|||
static void |
|||
test_dns_cb (struct rspamd_dns_reply *reply, gpointer arg) |
|||
gboolean |
|||
session_fin (gpointer unused) |
|||
{ |
|||
union rspamd_reply_element *elt; |
|||
GList *cur; |
|||
struct timeval tv; |
|||
|
|||
tv.tv_sec = 0; |
|||
tv.tv_usec = 0; |
|||
event_loopexit (&tv); |
|||
|
|||
msg_debug ("got reply with code %s for request %s", dns_strerror (reply->code), reply->request->requested_name); |
|||
if (reply->code == DNS_RC_NOERROR) { |
|||
cur = reply->elements; |
|||
return TRUE; |
|||
} |
|||
|
|||
static void |
|||
test_dns_cb (struct rdns_reply *reply, gpointer arg) |
|||
{ |
|||
struct rdns_reply_entry *cur; |
|||
const struct rdns_request_name *name = |
|||
rdns_request_get_name (reply->request, NULL); |
|||
|
|||
msg_debug ("got reply with code %s for request %s", |
|||
rdns_strerror (reply->code), name->name); |
|||
if (reply->code == RDNS_RC_NOERROR) { |
|||
cur = reply->entries; |
|||
while (cur) { |
|||
elt = cur->data; |
|||
switch (reply->request->type) { |
|||
case DNS_REQUEST_A: |
|||
msg_debug ("got ip: %s", inet_ntoa (elt->a.addr[0])); |
|||
switch (cur->type) { |
|||
case RDNS_REQUEST_A: |
|||
msg_debug ("got ip: %s", inet_ntoa (cur->content.a.addr)); |
|||
break; |
|||
case DNS_REQUEST_PTR: |
|||
msg_debug ("got name %s", elt->ptr.name); |
|||
case RDNS_REQUEST_PTR: |
|||
msg_debug ("got name %s", cur->content.ptr.name); |
|||
break; |
|||
case DNS_REQUEST_TXT: |
|||
msg_debug ("got txt %s", elt->txt.data); |
|||
case RDNS_REQUEST_TXT: |
|||
msg_debug ("got txt %s", cur->content.txt.data); |
|||
break; |
|||
case DNS_REQUEST_SPF: |
|||
msg_debug ("got spf %s", elt->spf.data); |
|||
case RDNS_REQUEST_SPF: |
|||
msg_debug ("got spf %s", cur->content.txt.data); |
|||
break; |
|||
case DNS_REQUEST_SRV: |
|||
msg_debug ("got srv pri: %d, weight: %d, port: %d, target: %s", elt->srv.weight, |
|||
elt->srv.priority, elt->srv.port, elt->srv.target); |
|||
case RDNS_REQUEST_SRV: |
|||
msg_debug ("got srv pri: %d, weight: %d, port: %d, target: %s", cur->content.srv.weight, |
|||
cur->content.srv.priority, cur->content.srv.port, cur->content.srv.target); |
|||
break; |
|||
case DNS_REQUEST_MX: |
|||
msg_debug ("got mx %s:%d", elt->mx.name, elt->mx.priority); |
|||
case RDNS_REQUEST_MX: |
|||
msg_debug ("got mx %s:%d", cur->content.mx.name, cur->content.mx.priority); |
|||
break; |
|||
} |
|||
cur = g_list_next (cur); |
|||
cur = cur->next; |
|||
} |
|||
} |
|||
if (-- requests == 0) { |
|||
destroy_session (reply->request->session); |
|||
session_fin (NULL); |
|||
} |
|||
} |
|||
|
|||
gboolean |
|||
session_fin (gpointer unused) |
|||
{ |
|||
struct timeval tv; |
|||
|
|||
tv.tv_sec = 0; |
|||
tv.tv_usec = 0; |
|||
event_loopexit (&tv); |
|||
|
|||
return TRUE; |
|||
} |
|||
|
|||
void |
|||
rspamd_dns_test_func () |
|||
{ |
|||
struct rspamd_dns_resolver *resolver; |
|||
|
|||
struct rspamd_config *cfg; |
|||
rspamd_mempool_t *pool; |
|||
struct rspamd_async_session *s; |
|||
struct in_addr ina; |
|||
|
|||
cfg = (struct rspamd_config *)g_malloc (sizeof (struct rspamd_config)); |
|||
bzero (cfg, sizeof (struct rspamd_config)); |
|||
cfg->cfg_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ()); |
|||
cfg->dns_retransmits = 10; |
|||
cfg->dns_timeout = 1000; |
|||
cfg->dns_retransmits = 2; |
|||
cfg->dns_timeout = 0.5; |
|||
|
|||
pool = rspamd_mempool_new (rspamd_mempool_suggest_size ()); |
|||
|
|||
s = new_async_session (pool, session_fin, NULL, NULL, NULL); |
|||
|
|||
resolver = dns_resolver_init (base, cfg); |
|||
|
|||
ina.s_addr = inet_addr ("81.19.70.3"); |
|||
resolver = dns_resolver_init (NULL, base, cfg); |
|||
|
|||
requests ++; |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, DNS_REQUEST_A, "google.com")); |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, RDNS_REQUEST_A, "google.com")); |
|||
requests ++; |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, DNS_REQUEST_PTR, &ina)); |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, RDNS_REQUEST_PTR, "81.19.70.3")); |
|||
requests ++; |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, DNS_REQUEST_MX, "rambler.ru")); |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, RDNS_REQUEST_MX, "rambler.ru")); |
|||
requests ++; |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, DNS_REQUEST_TXT, "rambler.ru")); |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, RDNS_REQUEST_TXT, "rambler.ru")); |
|||
requests ++; |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, DNS_REQUEST_TXT, "google.com")); |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, RDNS_REQUEST_TXT, "google.com")); |
|||
requests ++; |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, DNS_REQUEST_SPF, "rambler.ru")); |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, RDNS_REQUEST_SPF, "rambler.ru")); |
|||
requests ++; |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, DNS_REQUEST_SRV, "xmpp-server", "tcp", "jabber.org")); |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, RDNS_REQUEST_SRV, "_xmpp-server._tcp.jabber.org")); |
|||
requests ++; |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, DNS_REQUEST_TXT, "non-existent.arpa")); |
|||
g_assert (make_dns_request (resolver, s, pool, test_dns_cb, NULL, RDNS_REQUEST_TXT, "non-existent.arpa")); |
|||
|
|||
g_assert (resolver != NULL); |
|||
|
|||
|
|||
|
|||
event_loop (0); |
|||
} |
|||
@ -1,85 +0,0 @@ |
|||
#include "../src/config.h" |
|||
#include "../src/main.h" |
|||
#include "../src/cfg_file.h" |
|||
#include "../src/memcached.h" |
|||
#include "tests.h" |
|||
|
|||
static const u_char *buf = "test"; |
|||
|
|||
static void |
|||
memcached_callback (memcached_ctx_t *ctx, memc_error_t error, void *data) |
|||
{ |
|||
struct timeval tv; |
|||
|
|||
switch (ctx->op) { |
|||
case CMD_CONNECT: |
|||
if (error != OK) { |
|||
msg_warn ("Connect failed, skipping test"); |
|||
memc_close_ctx (ctx); |
|||
tv.tv_sec = 0; |
|||
tv.tv_usec = 0; |
|||
event_loopexit (&tv); |
|||
} |
|||
msg_debug ("Connect ok"); |
|||
memc_set (ctx, ctx->param, 60); |
|||
break; |
|||
case CMD_READ: |
|||
g_assert (error == OK); |
|||
g_assert (!memcmp(ctx->param->buf, buf, ctx->param->bufsize)); |
|||
msg_debug ("Read ok"); |
|||
memc_close_ctx (ctx); |
|||
tv.tv_sec = 0; |
|||
tv.tv_usec = 0; |
|||
event_loopexit (&tv); |
|||
break; |
|||
case CMD_WRITE: |
|||
if (error != OK) { |
|||
msg_warn ("Connect failed, skipping test"); |
|||
memc_close_ctx (ctx); |
|||
tv.tv_sec = 0; |
|||
tv.tv_usec = 0; |
|||
event_loopexit (&tv); |
|||
} |
|||
msg_debug ("Write ok"); |
|||
ctx->param->buf = g_malloc (sizeof (buf)); |
|||
bzero (ctx->param->buf, sizeof (buf)); |
|||
memc_get (ctx, ctx->param); |
|||
break; |
|||
default: |
|||
return; |
|||
} |
|||
} |
|||
|
|||
void |
|||
rspamd_memcached_test_func () |
|||
{ |
|||
memcached_ctx_t *ctx; |
|||
memcached_param_t *param; |
|||
struct in_addr addr; |
|||
|
|||
ctx = g_malloc (sizeof (memcached_ctx_t)); |
|||
param = g_malloc (sizeof (memcached_param_t)); |
|||
bzero (ctx, sizeof (memcached_ctx_t)); |
|||
bzero (param, sizeof (memcached_param_t)); |
|||
|
|||
event_init (); |
|||
|
|||
ctx->callback = memcached_callback; |
|||
ctx->callback_data = (void *)param; |
|||
ctx->protocol = TCP_TEXT; |
|||
inet_aton ("127.0.0.1", &addr); |
|||
memcpy (&ctx->addr, &addr, sizeof (struct in_addr)); |
|||
ctx->port = htons (11211); |
|||
ctx->timeout.tv_sec = 1; |
|||
ctx->timeout.tv_usec = 0; |
|||
ctx->sock = -1; |
|||
ctx->options = MEMC_OPT_DEBUG; |
|||
rspamd_strlcpy (param->key, buf, sizeof (param->key)); |
|||
param->buf = buf; |
|||
param->bufsize = strlen (buf); |
|||
ctx->param = param; |
|||
g_assert (memc_init_ctx (ctx) != -1); |
|||
|
|||
event_loop (0); |
|||
} |
|||
|
|||
@ -1,196 +0,0 @@ |
|||
/* Copyright (c) 2013, Vsevolod Stakhov |
|||
* All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions are met: |
|||
* * Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* * Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY |
|||
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
|||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
* DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY |
|||
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
|||
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
|||
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
|||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
*/ |
|||
|
|||
#include "config.h" |
|||
#include "rcl/rcl.h" |
|||
#include "main.h" |
|||
#include "json/jansson.h" |
|||
#include "tests.h" |
|||
|
|||
const gchar *rcl_test_valid[] = { |
|||
/* Json like */ |
|||
"{" |
|||
"\"key1\": value;" |
|||
"\"key1\": value2;" |
|||
"\"key1\": \"value;\"" |
|||
"}\n", |
|||
/* Nginx like */ |
|||
"section1 { param1 = value; param2 = value, " |
|||
"section3 {param = value; param2 = value, param3 = [\"value1\", value2, 100500]}}\n" |
|||
"section2 { param1 = {key = value}, param1 = [\"key\"]}", |
|||
/* Numbers */ |
|||
"key = 1s\n" |
|||
"key2 = 1min\n" |
|||
"key3 = 1kb\n" |
|||
"key4 = 5M\n" |
|||
"key5 = 10mS\n" |
|||
"key6 = 10y\n", |
|||
/* Strings */ |
|||
"key = \"some string\";" |
|||
"key1 = /some/path;" |
|||
"key3 = 111some," |
|||
"key4: s1," |
|||
"\"key5\": \"\\n\\r123\"", |
|||
"" |
|||
"#packagesite http//pkg.freebsd.org/freebsd-9-amd64/latest\n" |
|||
"#packagesite http//pkg.freebsd.org/freebsd-9-amd64/latest\n" |
|||
"packagesite: http//pkg.freebsd.org/freebsd-9-amd64/latest\n" |
|||
"ALIAS : {\n" |
|||
" all-depends: query %dn-%dv,\n" |
|||
" annotations: info -A,\n" |
|||
" build-depends: info -qd,\n" |
|||
" download: fetch,\n" |
|||
" iinfo: info -i -g -x,\n" |
|||
" isearch: search -i -g -x,\n" |
|||
" leaf: query -e '%a == 0' '%n-%v',\n" |
|||
" leaf: query -e '%a == 0' '%n-%v',\n" |
|||
" list: info -ql,\n" |
|||
" origin: info -qo,\n" |
|||
" provided-depends: info -qb,\n" |
|||
" raw: info -R,\n" |
|||
" required-depends: info -qr,\n" |
|||
" shared-depends: info -qB,\n" |
|||
" show: info -f -k,\n" |
|||
" size: info -sq,\n" |
|||
" }\n" |
|||
"\n" |
|||
"repo_dirs : [\n" |
|||
" /home/bapt,\n" |
|||
" /usr/local/etc\n" |
|||
"]\n" |
|||
"", |
|||
/* Macros */ |
|||
"section1 {key = value; section {\n" |
|||
"param = \"value\";\n" |
|||
"param2 = value\n" |
|||
"array = [ 1, 1mb, test]}\n" |
|||
".includes \"./test.cfg\"}", |
|||
NULL |
|||
}; |
|||
|
|||
static const gchar test_pubkey[] = "" |
|||
"-----BEGIN PUBLIC KEY-----\n" |
|||
"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDlhk2u5nbTVgEskmS+qZcAj339\n" |
|||
"bLwEK/TXdd0G3d4BVKpF712frw+YwetRdmRRYL5EdjiF01Bv3s6QmsThAJX/li/c\n" |
|||
"Q15YFxhvq9DZ0qJmL7e1NzORo6m/WLRK9wxWA+PXSvSUKrlZ3kt9ygD4z5QZ3/td\n" |
|||
"qil9VM6Mz7P1HJ0KywIDAQAB\n" |
|||
"-----END PUBLIC KEY-----\n"; |
|||
|
|||
void |
|||
rspamd_rcl_test_func (void) |
|||
{ |
|||
struct rspamd_cl_parser *parser, *parser2; |
|||
rspamd_cl_object_t *obj; |
|||
const gchar **cur; |
|||
guchar *emitted; |
|||
GError *err = NULL; |
|||
struct timespec start, end; |
|||
gdouble seconds; |
|||
json_t *json; |
|||
json_error_t jerr; |
|||
|
|||
cur = rcl_test_valid; |
|||
while (*cur != NULL) { |
|||
parser = rspamd_cl_parser_new (RSPAMD_CL_FLAG_KEY_LOWERCASE); |
|||
rspamd_cl_pubkey_add (parser, test_pubkey, sizeof (test_pubkey) - 1, &err); |
|||
g_assert_no_error (err); |
|||
g_assert (parser != NULL); |
|||
rspamd_cl_parser_add_chunk (parser, *cur, strlen (*cur), &err); |
|||
g_assert_no_error (err); |
|||
obj = rspamd_cl_parser_get_object (parser, &err); |
|||
g_assert_no_error (err); |
|||
/* Test config emitting */ |
|||
emitted = rspamd_cl_object_emit (obj, RSPAMD_CL_EMIT_CONFIG); |
|||
g_assert (emitted != NULL); |
|||
msg_debug ("got config output: %s", emitted); |
|||
parser2 = rspamd_cl_parser_new (RSPAMD_CL_FLAG_KEY_LOWERCASE); |
|||
g_assert (parser2 != NULL); |
|||
rspamd_cl_parser_add_chunk (parser2, emitted, strlen (emitted), &err); |
|||
g_assert_no_error (err); |
|||
rspamd_cl_parser_free (parser2); |
|||
g_free (emitted); |
|||
/* Test json emitted */ |
|||
emitted = rspamd_cl_object_emit (obj, RSPAMD_CL_EMIT_JSON); |
|||
g_assert (emitted != NULL); |
|||
msg_debug ("got json output: %s", emitted); |
|||
parser2 = rspamd_cl_parser_new (RSPAMD_CL_FLAG_KEY_LOWERCASE); |
|||
g_assert (parser2 != NULL); |
|||
rspamd_cl_parser_add_chunk (parser2, emitted, strlen (emitted), &err); |
|||
g_assert_no_error (err); |
|||
rspamd_cl_parser_free (parser2); |
|||
g_free (emitted); |
|||
/* Compact json */ |
|||
emitted = rspamd_cl_object_emit (obj, RSPAMD_CL_EMIT_JSON_COMPACT); |
|||
g_assert (emitted != NULL); |
|||
msg_debug ("got json compacted output: %s", emitted); |
|||
parser2 = rspamd_cl_parser_new (RSPAMD_CL_FLAG_KEY_LOWERCASE); |
|||
g_assert (parser2 != NULL); |
|||
rspamd_cl_parser_add_chunk (parser2, emitted, strlen (emitted), &err); |
|||
g_assert_no_error (err); |
|||
rspamd_cl_parser_free (parser2); |
|||
g_free (emitted); |
|||
|
|||
/* Cleanup */ |
|||
rspamd_cl_parser_free (parser); |
|||
rspamd_cl_obj_unref (obj); |
|||
cur ++; |
|||
} |
|||
|
|||
/* Load a big json */ |
|||
parser = rspamd_cl_parser_new (RSPAMD_CL_FLAG_KEY_LOWERCASE); |
|||
clock_gettime (CLOCK_MONOTONIC, &start); |
|||
rspamd_cl_parser_add_file (parser, "./rcl_test.json", &err); |
|||
g_assert_no_error (err); |
|||
obj = rspamd_cl_parser_get_object (parser, &err); |
|||
g_assert_no_error (err); |
|||
clock_gettime (CLOCK_MONOTONIC, &end); |
|||
seconds = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1000000000.; |
|||
msg_info ("rcl: parsed json in %.4f seconds", seconds); |
|||
/* Test config emitting */ |
|||
clock_gettime (CLOCK_MONOTONIC, &start); |
|||
emitted = rspamd_cl_object_emit (obj, RSPAMD_CL_EMIT_CONFIG); |
|||
g_assert (emitted != NULL); |
|||
clock_gettime (CLOCK_MONOTONIC, &end); |
|||
seconds = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1000000000.; |
|||
msg_info ("rcl: emitted object in %.4f seconds", seconds); |
|||
rspamd_cl_parser_free (parser); |
|||
rspamd_cl_obj_unref (obj); |
|||
g_free (emitted); |
|||
|
|||
clock_gettime (CLOCK_MONOTONIC, &start); |
|||
json = json_load_file ("./rcl_test.json", &jerr); |
|||
g_assert (json != NULL); |
|||
clock_gettime (CLOCK_MONOTONIC, &end); |
|||
seconds = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1000000000.; |
|||
msg_info ("jansson: parsed json in %.4f seconds", seconds); |
|||
|
|||
clock_gettime (CLOCK_MONOTONIC, &start); |
|||
emitted = json_dumps (json, 0); |
|||
g_assert (emitted != NULL); |
|||
clock_gettime (CLOCK_MONOTONIC, &end); |
|||
seconds = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1000000000.; |
|||
msg_info ("jansson: emitted object in %.4f seconds", seconds); |
|||
|
|||
//json_decref (json); |
|||
g_free (emitted); |
|||
} |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue