taler/exchange
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix testcase FTBFS

Browse Source
This commit is contained in:
Christian Grothoff 2015-06-18 01:17:01 +02:00
parent 5740506b24
commit a32e2b869f
1 changed files with 112 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

238
src/mint-lib/test_mint_api.c
View File

@ -19,116 +19,41 @@
* @brief testcase to test mint's HTTP API interface
* @author Sree Harsha Totakura <sreeharsha@totakura.in>
*/
#include "platform.h"
#include "taler_util.h"
#include "taler_mint_service.h"
struct TALER_MINT_Context *ctx;
static struct TALER_MINT_Context *ctx;
struct TALER_MINT_Handle *mint;
struct TALER_MINT_KeysGetHandle *dkey_get;
struct TALER_MINT_DepositHandle *dh;
static struct TALER_MINT_Handle *mint;
static struct GNUNET_SCHEDULER_Task *shutdown_task;
static struct GNUNET_SCHEDULER_Task *ctx_task;
static int result;
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
do_shutdown (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
shutdown_task = NULL;
if (NULL != dkey_get)
TALER_MINT_keys_get_cancel (dkey_get);
dkey_get = NULL;
if (NULL != dh)
TALER_MINT_deposit_submit_cancel (dh);
dh = NULL;
TALER_MINT_disconnect (mint);
mint = NULL;
TALER_MINT_fini (ctx);
ctx = NULL;
}
/**
* Callbacks of this type are used to serve the result of submitting a deposit
* permission object to a mint
*
* @param cls closure
* @param status 1 for successful deposit, 2 for retry, 0 for failure
* @param obj the received JSON object; can be NULL if it cannot be constructed
* from the reply
* @param emsg in case of unsuccessful deposit, this contains a human readable
* explanation.
*/
static void
deposit_status (void *cls,
int status,
json_t *obj,
char *emsg)
{
char *json_enc;
dh = NULL;
json_enc = NULL;
if (NULL != obj)
if (NULL != ctx_task)
{
json_enc = json_dumps (obj, JSON_INDENT(2));
fprintf (stderr, "%s", json_enc);
GNUNET_SCHEDULER_cancel (ctx_task);
ctx_task = NULL;
}
if (NULL != mint)
{
TALER_MINT_disconnect (mint);
mint = NULL;
}
if (NULL != ctx)
{
TALER_MINT_fini (ctx);
ctx = NULL;
}
if (1 == status)
result = GNUNET_OK;
else
GNUNET_break (0);
if (NULL != emsg)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Deposit failed: %s\n", emsg);
GNUNET_SCHEDULER_shutdown ();
}
/**
* Functions of this type are called to signal completion of an asynchronous call.
*
* @param cls closure
* @param emsg if the asynchronous call could not be completed due to an error,
* this parameter contains a human readable error message
*/
static void
cont (void *cls, const char *emsg)
{
json_t *dp;
char rnd_32[32];
char rnd_64[64];
char *enc_32;
char *enc_64;
GNUNET_assert (NULL == cls);
dkey_get = NULL;
if (NULL != emsg)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s\n", emsg);
enc_32 = GNUNET_STRINGS_data_to_string_alloc (rnd_32, sizeof (rnd_32));
enc_64 = GNUNET_STRINGS_data_to_string_alloc (rnd_64, sizeof (rnd_64));
dp = json_pack ("{s:s s:o s:s s:s s:s s:s s:s s:s s:s s:s}",
"type", "DIRECT_DEPOSIT",
"wire", json_pack ("{s:s}", "type", "SEPA"),
"C", enc_32,
"K", enc_32,
"ubsig", enc_64,
"M", enc_32,
"H_a", enc_64,
"H_wire", enc_64,
"csig", enc_64,
"m", "B1C5GP2RB1C5G");
GNUNET_free (enc_32);
GNUNET_free (enc_64);
dh = TALER_MINT_deposit_submit_json (mint,
deposit_status,
NULL,
dp);
json_decref (dp);
}
@ -137,37 +62,86 @@ cont (void *cls, const char *emsg)
* denomination keys of the mint. No TALER_MINT_*() functions should be called
* in this callback.
*
* @param cls closure passed to TALER_MINT_keys_get()
* @param sign_keys NULL-terminated array of pointers to the mint's signing
* keys. NULL if no signing keys are retrieved.
* @param denom_keys NULL-terminated array of pointers to the mint's
* denomination keys; will be NULL if no signing keys are retrieved.
* @param cls closure
* @param keys information about keys of the mint
*/
static void
read_denom_key (void *cls,
struct TALER_MINT_SigningPublicKey **sign_keys,
struct TALER_MINT_DenomPublicKey **denom_keys)
cert_cb (void *cls,
const struct TALER_MINT_Keys *keys)
{
unsigned int cnt;
GNUNET_assert (NULL == cls);
#define ERR(cond) do { if(!(cond)) break; GNUNET_break (0); return; } while (0)
ERR (NULL == sign_keys);
ERR (NULL == denom_keys);
for (cnt = 0; NULL != sign_keys[cnt]; cnt++)
GNUNET_free (sign_keys[cnt]);
ERR (0 == cnt);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Read %u signing keys\n", cnt);
GNUNET_free (sign_keys);
for (cnt = 0; NULL != denom_keys[cnt]; cnt++)
GNUNET_free (denom_keys[cnt]);
ERR (0 == cnt);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Read %u denomination keys\n", cnt);
GNUNET_free (denom_keys);
#define ERR(cond) do { if(!(cond)) break; GNUNET_break (0); GNUNET_SCHEDULER_shutdown(); return; } while (0)
ERR (NULL == keys);
ERR (0 == keys->num_sign_keys);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Read %u signing keys\n",
keys->num_sign_keys);
ERR (0 == keys->num_denom_keys);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Read %u denomination keys\n",
keys->num_denom_keys);
#undef ERR
/* TODO: start running rest of test suite here! */
return;
}
/**
* Task that runs the context's event loop with the GNUnet scheduler.
*
* @param cls unused
* @param tc scheduler context (unused)
*/
static void
context_task (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
long timeout;
int max_fd;
fd_set read_fd_set;
fd_set write_fd_set;
fd_set except_fd_set;
struct GNUNET_NETWORK_FDSet *rs;
struct GNUNET_NETWORK_FDSet *ws;
struct GNUNET_TIME_Relative delay;
ctx_task = NULL;
TALER_MINT_perform (ctx);
max_fd = -1;
timeout = -1;
FD_ZERO (&read_fd_set);
FD_ZERO (&write_fd_set);
FD_ZERO (&except_fd_set);
TALER_MINT_get_select_info (ctx,
&read_fd_set,
&write_fd_set,
&except_fd_set,
&max_fd,
&timeout);
if (timeout >= 0)
delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
timeout);
else
delay = GNUNET_TIME_UNIT_FOREVER_REL;
rs = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_copy_native (rs,
&read_fd_set,
max_fd);
ws = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_copy_native (ws,
&write_fd_set,
max_fd + 1);
ctx_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
delay,
rs,
ws,
&context_task,
cls);
GNUNET_NETWORK_fdset_destroy (rs);
GNUNET_NETWORK_fdset_destroy (ws);
}
/**
* Main function that will be run by the scheduler.
*
@ -177,24 +151,36 @@ read_denom_key (void *cls,
* @param config configuration
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
run (void *cls,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *config)
{
ctx = TALER_MINT_init ();
mint = TALER_MINT_connect (ctx, "localhost", 4241, NULL);
GNUNET_assert (NULL != ctx);
ctx_task = GNUNET_SCHEDULER_add_now (&context_task,
ctx);
mint = TALER_MINT_connect (ctx,
"http://localhost:8080",
&cert_cb, NULL,
TALER_MINT_OPTION_END);
GNUNET_assert (NULL != mint);
dkey_get = TALER_MINT_keys_get (mint,
&read_denom_key, NULL,
&cont, NULL);
GNUNET_assert (NULL != dkey_get);
shutdown_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 5),
&do_shutdown, NULL);
}
/**
* Main function for the testcase for the mint API.
*
* @param argc expected to be 1
* @param argv expected to only contain the program name
*/
int
main (int argc, char * const *argv)
main (int argc,
char * const *argv)
{
static struct GNUNET_GETOPT_CommandLineOption options[] = {
GNUNET_GETOPT_OPTION_END
@ -203,9 +189,9 @@ main (int argc, char * const *argv)
result = GNUNET_SYSERR;
if (GNUNET_OK !=
GNUNET_PROGRAM_run (argc, argv, "test-mint-api",
gettext_noop
("Testcase to test mint's HTTP API interface"),
options, &run, NULL))
gettext_noop ("Testcase to test mint's HTTP API interface"),
options,
&run, NULL))
return 3;
return (GNUNET_OK == result) ? 0 : 1;
}