fix testcase FTBFS

src/mint-lib/test_mint_api.c

@@ -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;
+static struct TALER_MINT_Handle *mint;
-
-struct TALER_MINT_KeysGetHandle *dkey_get;
-
-struct TALER_MINT_DepositHandle *dh;
 
 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)
+  if (NULL != ctx_task)
-    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)
   {
-    json_enc = json_dumps (obj, JSON_INDENT(2));
+    GNUNET_SCHEDULER_cancel (ctx_task);
-    fprintf (stderr, "%s", json_enc);
+    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 cls closure
- * @param sign_keys NULL-terminated array of pointers to the mint's signing
+ * @param keys information about keys of the mint
- *          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.
  */
 static void
-read_denom_key (void *cls,
+cert_cb (void *cls,
-                struct TALER_MINT_SigningPublicKey **sign_keys,
+         const struct TALER_MINT_Keys *keys)
-                struct TALER_MINT_DenomPublicKey **denom_keys)
 {
-  unsigned int cnt;
   GNUNET_assert (NULL == cls);
-#define ERR(cond) do { if(!(cond)) break; GNUNET_break (0); return; } while (0)
+#define ERR(cond) do { if(!(cond)) break; GNUNET_break (0); GNUNET_SCHEDULER_shutdown(); return; } while (0)
-  ERR (NULL == sign_keys);
+  ERR (NULL == keys);
-  ERR (NULL == denom_keys);
+  ERR (0 == keys->num_sign_keys);
-  for (cnt = 0; NULL != sign_keys[cnt]; cnt++)
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-    GNUNET_free (sign_keys[cnt]);
+              "Read %u signing keys\n",
-  ERR (0 == cnt);
+              keys->num_sign_keys);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Read %u signing keys\n", cnt);
+  ERR (0 == keys->num_denom_keys);
-  GNUNET_free (sign_keys);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-  for (cnt = 0; NULL != denom_keys[cnt]; cnt++)
+              "Read %u denomination keys\n",
-    GNUNET_free (denom_keys[cnt]);
+              keys->num_denom_keys);
-  ERR (0 == cnt);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Read %u denomination keys\n", cnt);
-  GNUNET_free (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
+                          gettext_noop ("Testcase to test mint's HTTP API interface"),
-                          ("Testcase to test mint's HTTP API interface"),
+                          options,
-                          options, &run, NULL))
+                          &run, NULL))
     return 3;
   return (GNUNET_OK == result) ? 0 : 1;
 }