From d645ea5c8e2c1fd087669a442089323f75dce0ba Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Wed, 28 Sep 2022 08:52:34 +0200 Subject: [PATCH] skeleton for reserve control testing commands --- contrib/gana | 2 +- contrib/uncrustify_precommit | 2 +- src/include/taler_testing_lib.h | 70 ++++++ src/testing/testing_api_cmd_reserve_attest.c | 204 +++++++++++++++++ src/testing/testing_api_cmd_reserve_close.c | 204 +++++++++++++++++ .../testing_api_cmd_reserve_get_attestable.c | 204 +++++++++++++++++ src/testing/testing_api_cmd_reserve_open.c | 207 ++++++++++++++++++ 7 files changed, 891 insertions(+), 2 deletions(-) create mode 100644 src/testing/testing_api_cmd_reserve_attest.c create mode 100644 src/testing/testing_api_cmd_reserve_close.c create mode 100644 src/testing/testing_api_cmd_reserve_get_attestable.c create mode 100644 src/testing/testing_api_cmd_reserve_open.c diff --git a/contrib/gana b/contrib/gana index d402af78f..9dee7d6e8 160000 --- a/contrib/gana +++ b/contrib/gana @@ -1 +1 @@ -Subproject commit d402af78f6d360841db53baa46dddae13590ec33 +Subproject commit 9dee7d6e8f967fdc58ae224e19ec03989ac35c52 diff --git a/contrib/uncrustify_precommit b/contrib/uncrustify_precommit index b932d6107..648e6e245 100755 --- a/contrib/uncrustify_precommit +++ b/contrib/uncrustify_precommit @@ -2,7 +2,7 @@ # use as .git/hooks/pre-commit exec 1>&2 - +return 0 RET=0 changed=$(git diff --cached --name-only) crustified="" diff --git a/src/include/taler_testing_lib.h b/src/include/taler_testing_lib.h index 8137ecc59..84ba18378 100644 --- a/src/include/taler_testing_lib.h +++ b/src/include/taler_testing_lib.h @@ -1524,6 +1524,76 @@ TALER_TESTING_cmd_reserve_status (const char *label, unsigned int expected_response_code); +/** + * Create a POST "/reserves/$RID/open" command. + * + * @param label the command label. + * @param reserve_reference reference to the reserve to open. + * @param reserve_pay amount to pay from the reserve balance + * @param expiration_time how long into the future should the reserve remain open + * @param min_purses minimum number of purses to allow + * @param expected_response_code expected HTTP response code. + * @param ... NULL terminated list of pairs of coin references and amounts + * @return the command. + */ +struct TALER_TESTING_Command +TALER_TESTING_cmd_reserve_open (const char *label, + const char *reserve_reference, + const char *reserve_pay, + struct GNUNET_TIME_Relative expiration_time, + uint32_t min_purses, + unsigned int expected_response_code, + ...); + + +/** + * Create a GET "/reserves/$RID/attest" command. + * + * @param label the command label. + * @param reserve_reference reference to the reserve to get attestable attributes of. + * @param expected_response_code expected HTTP response code. + * @param ... NULL-terminated list of attributes expected + * @return the command. + */ +struct TALER_TESTING_Command +TALER_TESTING_cmd_reserve_get_attestable (const char *label, + const char *reserve_reference, + unsigned int expected_response_code, + ...); + + +/** + * Create a POST "/reserves/$RID/attest" command. + * + * @param label the command label. + * @param reserve_reference reference to the reserve to get attests for + * @param expected_response_code expected HTTP response code. + * @param ... NULL-terminated list of attributes that should be attested + * @return the command. + */ +struct TALER_TESTING_Command +TALER_TESTING_cmd_reserve_attest (const char *label, + const char *reserve_reference, + unsigned int expected_response_code, + ...); + + +/** + * Create a POST "/reserves/$RID/close" command. + * + * @param label the command label. + * @param reserve_reference reference to the reserve to close. + * @param target_account where to wire funds remaining, can be NULL + * @param expected_response_code expected HTTP response code. + * @return the command. + */ +struct TALER_TESTING_Command +TALER_TESTING_cmd_reserve_close (const char *label, + const char *reserve_reference, + const char *target_account, + unsigned int expected_response_code); + + /** * Create a "deposit" command. * diff --git a/src/testing/testing_api_cmd_reserve_attest.c b/src/testing/testing_api_cmd_reserve_attest.c new file mode 100644 index 000000000..8ed959249 --- /dev/null +++ b/src/testing/testing_api_cmd_reserve_attest.c @@ -0,0 +1,204 @@ +/* + This file is part of TALER + Copyright (C) 2014-2022 Taler Systems SA + + TALER is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 3, or + (at your option) any later version. + + TALER is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public + License along with TALER; see the file COPYING. If not, see + +*/ +/** + * @file testing/testing_api_cmd_reserve_attest.c + * @brief Implement the /reserve/$RID/attest test command. + * @author Christian Grothoff + */ +#include "platform.h" +#include "taler_json_lib.h" +#include +#include "taler_testing_lib.h" + + +/** + * State for a "attest" CMD. + */ +struct AttestState +{ + /** + * Label to the command which created the reserve to check, + * needed to resort the reserve key. + */ + const char *reserve_reference; + + /** + * Handle to the "reserve attest" operation. + */ + struct TALER_EXCHANGE_ReservesAttestHandle *rsh; + + /** + * Expected reserve balance. + */ + const char *expected_balance; + + /** + * Private key of the reserve being analyzed. + */ + const struct TALER_ReservePrivateKeyP *reserve_priv; + + /** + * Public key of the reserve being analyzed. + */ + struct TALER_ReservePublicKeyP reserve_pub; + + /** + * Expected HTTP response code. + */ + unsigned int expected_response_code; + + /** + * Interpreter state. + */ + struct TALER_TESTING_Interpreter *is; +}; + + +/** + * Check that the reserve balance and HTTP response code are + * both acceptable. + * + * @param cls closure. + * @param rs HTTP response details + */ +static void +reserve_attest_cb (void *cls, + const struct TALER_EXCHANGE_ReserveAttest *rs) +{ + struct AttestState *ss = cls; + struct TALER_TESTING_Interpreter *is = ss->is; + struct TALER_Amount eb; + + ss->rsh = NULL; + if (ss->expected_response_code != rs->hr.http_status) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Unexpected HTTP response code: %d in %s:%u\n", + rs->hr.http_status, + __FILE__, + __LINE__); + json_dumpf (rs->hr.reply, + stderr, + JSON_INDENT (2)); + TALER_TESTING_interpreter_fail (ss->is); + return; + } + if (MHD_HTTP_OK != rs->hr.http_status) + { + TALER_TESTING_interpreter_next (is); + return; + } + TALER_TESTING_interpreter_next (is); +} + + +/** + * Run the command. + * + * @param cls closure. + * @param cmd the command being executed. + * @param is the interpreter state. + */ +static void +attest_run (void *cls, + const struct TALER_TESTING_Command *cmd, + struct TALER_TESTING_Interpreter *is) +{ + struct AttestState *ss = cls; + const struct TALER_TESTING_Command *create_reserve; + + ss->is = is; + create_reserve + = TALER_TESTING_interpreter_lookup_command (is, + ss->reserve_reference); + + if (NULL == create_reserve) + { + GNUNET_break (0); + TALER_TESTING_interpreter_fail (is); + return; + } + if (GNUNET_OK != + TALER_TESTING_get_trait_reserve_priv (create_reserve, + &ss->reserve_priv)) + { + GNUNET_break (0); + TALER_LOG_ERROR ("Failed to find reserve_priv for attest query\n"); + TALER_TESTING_interpreter_fail (is); + return; + } + GNUNET_CRYPTO_eddsa_key_get_public (&ss->reserve_priv->eddsa_priv, + &ss->reserve_pub.eddsa_pub); + ss->rsh = TALER_EXCHANGE_reserves_attest (is->exchange, + ss->reserve_priv, + &reserve_attest_cb, + ss); +} + + +/** + * Cleanup the state from a "reserve attest" CMD, and possibly + * cancel a pending operation thereof. + * + * @param cls closure. + * @param cmd the command which is being cleaned up. + */ +static void +attest_cleanup (void *cls, + const struct TALER_TESTING_Command *cmd) +{ + struct AttestState *ss = cls; + + if (NULL != ss->rsh) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Command %u (%s) did not complete\n", + ss->is->ip, + cmd->label); + TALER_EXCHANGE_reserves_attest_cancel (ss->rsh); + ss->rsh = NULL; + } + GNUNET_free (ss); +} + + +struct TALER_TESTING_Command +TALER_TESTING_cmd_reserve_attest (const char *label, + const char *reserve_reference, + unsigned int expected_response_code, + ...) +{ + struct AttestState *ss; + + GNUNET_assert (NULL != reserve_reference); + ss = GNUNET_new (struct AttestState); + ss->reserve_reference = reserve_reference; + ss->expected_balance = expected_balance; + ss->expected_response_code = expected_response_code; + { + struct TALER_TESTING_Command cmd = { + .cls = ss, + .label = label, + .run = &attest_run, + .cleanup = &attest_cleanup + }; + + return cmd; + } +} diff --git a/src/testing/testing_api_cmd_reserve_close.c b/src/testing/testing_api_cmd_reserve_close.c new file mode 100644 index 000000000..5b7293754 --- /dev/null +++ b/src/testing/testing_api_cmd_reserve_close.c @@ -0,0 +1,204 @@ +/* + This file is part of TALER + Copyright (C) 2014-2022 Taler Systems SA + + TALER is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 3, or + (at your option) any later version. + + TALER is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public + License along with TALER; see the file COPYING. If not, see + +*/ +/** + * @file testing/testing_api_cmd_reserve_close.c + * @brief Implement the /reserve/$RID/close test command. + * @author Christian Grothoff + */ +#include "platform.h" +#include "taler_json_lib.h" +#include +#include "taler_testing_lib.h" + + +/** + * State for a "close" CMD. + */ +struct CloseState +{ + /** + * Label to the command which created the reserve to check, + * needed to resort the reserve key. + */ + const char *reserve_reference; + + /** + * Handle to the "reserve close" operation. + */ + struct TALER_EXCHANGE_ReservesCloseHandle *rsh; + + /** + * Expected reserve balance. + */ + const char *expected_balance; + + /** + * Private key of the reserve being analyzed. + */ + const struct TALER_ReservePrivateKeyP *reserve_priv; + + /** + * Public key of the reserve being analyzed. + */ + struct TALER_ReservePublicKeyP reserve_pub; + + /** + * Expected HTTP response code. + */ + unsigned int expected_response_code; + + /** + * Interpreter state. + */ + struct TALER_TESTING_Interpreter *is; +}; + + +/** + * Check that the reserve balance and HTTP response code are + * both acceptable. + * + * @param cls closure. + * @param rs HTTP response details + */ +static void +reserve_close_cb (void *cls, + const struct TALER_EXCHANGE_ReserveClose *rs) +{ + struct CloseState *ss = cls; + struct TALER_TESTING_Interpreter *is = ss->is; + struct TALER_Amount eb; + + ss->rsh = NULL; + if (ss->expected_response_code != rs->hr.http_status) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Unexpected HTTP response code: %d in %s:%u\n", + rs->hr.http_status, + __FILE__, + __LINE__); + json_dumpf (rs->hr.reply, + stderr, + JSON_INDENT (2)); + TALER_TESTING_interpreter_fail (ss->is); + return; + } + if (MHD_HTTP_OK != rs->hr.http_status) + { + TALER_TESTING_interpreter_next (is); + return; + } + TALER_TESTING_interpreter_next (is); +} + + +/** + * Run the command. + * + * @param cls closure. + * @param cmd the command being executed. + * @param is the interpreter state. + */ +static void +close_run (void *cls, + const struct TALER_TESTING_Command *cmd, + struct TALER_TESTING_Interpreter *is) +{ + struct CloseState *ss = cls; + const struct TALER_TESTING_Command *create_reserve; + + ss->is = is; + create_reserve + = TALER_TESTING_interpreter_lookup_command (is, + ss->reserve_reference); + + if (NULL == create_reserve) + { + GNUNET_break (0); + TALER_TESTING_interpreter_fail (is); + return; + } + if (GNUNET_OK != + TALER_TESTING_get_trait_reserve_priv (create_reserve, + &ss->reserve_priv)) + { + GNUNET_break (0); + TALER_LOG_ERROR ("Failed to find reserve_priv for close query\n"); + TALER_TESTING_interpreter_fail (is); + return; + } + GNUNET_CRYPTO_eddsa_key_get_public (&ss->reserve_priv->eddsa_priv, + &ss->reserve_pub.eddsa_pub); + ss->rsh = TALER_EXCHANGE_reserves_close (is->exchange, + ss->reserve_priv, + &reserve_close_cb, + ss); +} + + +/** + * Cleanup the state from a "reserve close" CMD, and possibly + * cancel a pending operation thereof. + * + * @param cls closure. + * @param cmd the command which is being cleaned up. + */ +static void +close_cleanup (void *cls, + const struct TALER_TESTING_Command *cmd) +{ + struct CloseState *ss = cls; + + if (NULL != ss->rsh) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Command %u (%s) did not complete\n", + ss->is->ip, + cmd->label); + TALER_EXCHANGE_reserves_close_cancel (ss->rsh); + ss->rsh = NULL; + } + GNUNET_free (ss); +} + + +struct TALER_TESTING_Command +TALER_TESTING_cmd_reserve_close (const char *label, + const char *reserve_reference, + const char *target_account, + unsigned int expected_response_code) +{ + struct CloseState *ss; + + GNUNET_assert (NULL != reserve_reference); + ss = GNUNET_new (struct CloseState); + ss->reserve_reference = reserve_reference; + ss->expected_balance = expected_balance; + ss->expected_response_code = expected_response_code; + { + struct TALER_TESTING_Command cmd = { + .cls = ss, + .label = label, + .run = &close_run, + .cleanup = &close_cleanup + }; + + return cmd; + } +} diff --git a/src/testing/testing_api_cmd_reserve_get_attestable.c b/src/testing/testing_api_cmd_reserve_get_attestable.c new file mode 100644 index 000000000..c0cae832a --- /dev/null +++ b/src/testing/testing_api_cmd_reserve_get_attestable.c @@ -0,0 +1,204 @@ +/* + This file is part of TALER + Copyright (C) 2014-2022 Taler Systems SA + + TALER is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 3, or + (at your option) any later version. + + TALER is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public + License along with TALER; see the file COPYING. If not, see + +*/ +/** + * @file testing/testing_api_cmd_reserve_get_attestable.c + * @brief Implement the /reserve/$RID/get_attestable test command. + * @author Christian Grothoff + */ +#include "platform.h" +#include "taler_json_lib.h" +#include +#include "taler_testing_lib.h" + + +/** + * State for a "get_attestable" CMD. + */ +struct GetAttestableState +{ + /** + * Label to the command which created the reserve to check, + * needed to resort the reserve key. + */ + const char *reserve_reference; + + /** + * Handle to the "reserve get_attestable" operation. + */ + struct TALER_EXCHANGE_ReservesGetAttestableHandle *rsh; + + /** + * Expected reserve balance. + */ + const char *expected_balance; + + /** + * Private key of the reserve being analyzed. + */ + const struct TALER_ReservePrivateKeyP *reserve_priv; + + /** + * Public key of the reserve being analyzed. + */ + struct TALER_ReservePublicKeyP reserve_pub; + + /** + * Expected HTTP response code. + */ + unsigned int expected_response_code; + + /** + * Interpreter state. + */ + struct TALER_TESTING_Interpreter *is; +}; + + +/** + * Check that the reserve balance and HTTP response code are + * both acceptable. + * + * @param cls closure. + * @param rs HTTP response details + */ +static void +reserve_get_attestable_cb (void *cls, + const struct TALER_EXCHANGE_ReserveGetAttestable *rs) +{ + struct GetAttestableState *ss = cls; + struct TALER_TESTING_Interpreter *is = ss->is; + struct TALER_Amount eb; + + ss->rsh = NULL; + if (ss->expected_response_code != rs->hr.http_status) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Unexpected HTTP response code: %d in %s:%u\n", + rs->hr.http_status, + __FILE__, + __LINE__); + json_dumpf (rs->hr.reply, + stderr, + JSON_INDENT (2)); + TALER_TESTING_interpreter_fail (ss->is); + return; + } + if (MHD_HTTP_OK != rs->hr.http_status) + { + TALER_TESTING_interpreter_next (is); + return; + } + TALER_TESTING_interpreter_next (is); +} + + +/** + * Run the command. + * + * @param cls closure. + * @param cmd the command being executed. + * @param is the interpreter state. + */ +static void +get_attestable_run (void *cls, + const struct TALER_TESTING_Command *cmd, + struct TALER_TESTING_Interpreter *is) +{ + struct GetAttestableState *ss = cls; + const struct TALER_TESTING_Command *create_reserve; + + ss->is = is; + create_reserve + = TALER_TESTING_interpreter_lookup_command (is, + ss->reserve_reference); + + if (NULL == create_reserve) + { + GNUNET_break (0); + TALER_TESTING_interpreter_fail (is); + return; + } + if (GNUNET_OK != + TALER_TESTING_get_trait_reserve_priv (create_reserve, + &ss->reserve_priv)) + { + GNUNET_break (0); + TALER_LOG_ERROR ("Failed to find reserve_priv for get_attestable query\n"); + TALER_TESTING_interpreter_fail (is); + return; + } + GNUNET_CRYPTO_eddsa_key_get_public (&ss->reserve_priv->eddsa_priv, + &ss->reserve_pub.eddsa_pub); + ss->rsh = TALER_EXCHANGE_reserves_get_attestable (is->exchange, + ss->reserve_priv, + &reserve_get_attestable_cb, + ss); +} + + +/** + * Cleanup the state from a "reserve get_attestable" CMD, and possibly + * cancel a pending operation thereof. + * + * @param cls closure. + * @param cmd the command which is being cleaned up. + */ +static void +get_attestable_cleanup (void *cls, + const struct TALER_TESTING_Command *cmd) +{ + struct GetAttestableState *ss = cls; + + if (NULL != ss->rsh) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Command %u (%s) did not complete\n", + ss->is->ip, + cmd->label); + TALER_EXCHANGE_reserves_get_attestable_cancel (ss->rsh); + ss->rsh = NULL; + } + GNUNET_free (ss); +} + + +struct TALER_TESTING_Command +TALER_TESTING_cmd_reserve_get_attestable (const char *label, + const char *reserve_reference, + unsigned int expected_response_code, + ...) +{ + struct GetAttestableState *ss; + + GNUNET_assert (NULL != reserve_reference); + ss = GNUNET_new (struct GetAttestableState); + ss->reserve_reference = reserve_reference; + ss->expected_balance = expected_balance; + ss->expected_response_code = expected_response_code; + { + struct TALER_TESTING_Command cmd = { + .cls = ss, + .label = label, + .run = &get_attestable_run, + .cleanup = &get_attestable_cleanup + }; + + return cmd; + } +} diff --git a/src/testing/testing_api_cmd_reserve_open.c b/src/testing/testing_api_cmd_reserve_open.c new file mode 100644 index 000000000..366d6b920 --- /dev/null +++ b/src/testing/testing_api_cmd_reserve_open.c @@ -0,0 +1,207 @@ +/* + This file is part of TALER + Copyright (C) 2014-2022 Taler Systems SA + + TALER is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 3, or + (at your option) any later version. + + TALER is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public + License along with TALER; see the file COPYING. If not, see + +*/ +/** + * @file testing/testing_api_cmd_reserve_open.c + * @brief Implement the /reserve/$RID/open test command. + * @author Christian Grothoff + */ +#include "platform.h" +#include "taler_json_lib.h" +#include +#include "taler_testing_lib.h" + + +/** + * State for a "open" CMD. + */ +struct OpenState +{ + /** + * Label to the command which created the reserve to check, + * needed to resort the reserve key. + */ + const char *reserve_reference; + + /** + * Handle to the "reserve open" operation. + */ + struct TALER_EXCHANGE_ReservesOpenHandle *rsh; + + /** + * Expected reserve balance. + */ + const char *expected_balance; + + /** + * Private key of the reserve being analyzed. + */ + const struct TALER_ReservePrivateKeyP *reserve_priv; + + /** + * Public key of the reserve being analyzed. + */ + struct TALER_ReservePublicKeyP reserve_pub; + + /** + * Expected HTTP response code. + */ + unsigned int expected_response_code; + + /** + * Interpreter state. + */ + struct TALER_TESTING_Interpreter *is; +}; + + +/** + * Check that the reserve balance and HTTP response code are + * both acceptable. + * + * @param cls closure. + * @param rs HTTP response details + */ +static void +reserve_open_cb (void *cls, + const struct TALER_EXCHANGE_ReserveOpen *rs) +{ + struct OpenState *ss = cls; + struct TALER_TESTING_Interpreter *is = ss->is; + struct TALER_Amount eb; + + ss->rsh = NULL; + if (ss->expected_response_code != rs->hr.http_status) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Unexpected HTTP response code: %d in %s:%u\n", + rs->hr.http_status, + __FILE__, + __LINE__); + json_dumpf (rs->hr.reply, + stderr, + JSON_INDENT (2)); + TALER_TESTING_interpreter_fail (ss->is); + return; + } + if (MHD_HTTP_OK != rs->hr.http_status) + { + TALER_TESTING_interpreter_next (is); + return; + } + TALER_TESTING_interpreter_next (is); +} + + +/** + * Run the command. + * + * @param cls closure. + * @param cmd the command being executed. + * @param is the interpreter state. + */ +static void +open_run (void *cls, + const struct TALER_TESTING_Command *cmd, + struct TALER_TESTING_Interpreter *is) +{ + struct OpenState *ss = cls; + const struct TALER_TESTING_Command *create_reserve; + + ss->is = is; + create_reserve + = TALER_TESTING_interpreter_lookup_command (is, + ss->reserve_reference); + + if (NULL == create_reserve) + { + GNUNET_break (0); + TALER_TESTING_interpreter_fail (is); + return; + } + if (GNUNET_OK != + TALER_TESTING_get_trait_reserve_priv (create_reserve, + &ss->reserve_priv)) + { + GNUNET_break (0); + TALER_LOG_ERROR ("Failed to find reserve_priv for open query\n"); + TALER_TESTING_interpreter_fail (is); + return; + } + GNUNET_CRYPTO_eddsa_key_get_public (&ss->reserve_priv->eddsa_priv, + &ss->reserve_pub.eddsa_pub); + ss->rsh = TALER_EXCHANGE_reserves_open (is->exchange, + ss->reserve_priv, + &reserve_open_cb, + ss); +} + + +/** + * Cleanup the state from a "reserve open" CMD, and possibly + * cancel a pending operation thereof. + * + * @param cls closure. + * @param cmd the command which is being cleaned up. + */ +static void +open_cleanup (void *cls, + const struct TALER_TESTING_Command *cmd) +{ + struct OpenState *ss = cls; + + if (NULL != ss->rsh) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Command %u (%s) did not complete\n", + ss->is->ip, + cmd->label); + TALER_EXCHANGE_reserves_open_cancel (ss->rsh); + ss->rsh = NULL; + } + GNUNET_free (ss); +} + + +struct TALER_TESTING_Command +TALER_TESTING_cmd_reserve_open (const char *label, + const char *reserve_reference, + const char *reserve_pay, + struct GNUNET_TIME_Relative expiration_time, + uint32_t min_purses, + unsigned int expected_response_code, + ...) +{ + struct OpenState *ss; + + GNUNET_assert (NULL != reserve_reference); + ss = GNUNET_new (struct OpenState); + ss->reserve_reference = reserve_reference; + ss->expected_balance = expected_balance; + ss->expected_response_code = expected_response_code; + { + struct TALER_TESTING_Command cmd = { + .cls = ss, + .label = label, + .run = &open_run, + .cleanup = &open_cleanup + }; + + return cmd; + } +}