merchant

testing_api_cmd_check_order_external.c (6358B)

---

 /*
   This file is part of TALER
   Copyright (C) 2026 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
   <http://www.gnu.org/licenses/>
 */
 /**
  * @file src/testing/testing_api_cmd_check_order_external.c
  * @brief command to check the external payments and refunds an order
  *        reports through GET /private/orders/$ORDER_ID
  * @author Bohdan Potuzhnyi
  * @author Volodymyr Potuzhnyi
  */
 #include "platform.h"
 struct CheckOrderExternalState;
 #define TALER_MERCHANT_GET_PRIVATE_ORDER_RESULT_CLOSURE \
   struct CheckOrderExternalState
 #include <taler/taler_exchange_service.h>
 #include <taler/taler_testing_lib.h>
 #include "taler/taler_merchant_service.h"
 #include "taler/taler_merchant_testing_lib.h"
 
 
 /**
  * State of a "check order external" CMD.
  */
 struct CheckOrderExternalState
 {
 
   /**
    * Handle for the order status request.
    */
   struct TALER_MERCHANT_GetPrivateOrderHandle *ogh;
 
   /**
    * The interpreter state.
    */
   struct TALER_TESTING_Interpreter *is;
 
   /**
    * Base URL of the merchant serving the request.
    */
   const char *merchant_url;
 
   /**
    * ID of the order to check.
    */
   const char *order_id;
 
   /**
    * Number of entries expected in "amount_external" of the contract.
    */
   unsigned int expected_payments;
 
   /**
    * Number of entries expected in "refunds_external" of the status.
    */
   unsigned int expected_refunds;
 
   /**
    * Choice the order is expected to have been paid with, -1 if the
    * contract has no choices.
    */
   int expected_choice_index;
 
 };
 
 
 /**
  * Callback for the order status request.
  *
  * @param coes closure for this function
  * @param osr response being processed
  */
 static void
 check_order_external_cb (
   struct CheckOrderExternalState *coes,
   const struct TALER_MERCHANT_GetPrivateOrderResponse *osr)
 {
   size_t payments;
   size_t refunds;
 
   coes->ogh = NULL;
   if (MHD_HTTP_OK != osr->hr.http_status)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unexpected response code %u (%d) to command %s\n",
                 osr->hr.http_status,
                 (int) osr->hr.ec,
                 TALER_TESTING_interpreter_get_current_label (coes->is));
     TALER_TESTING_interpreter_fail (coes->is);
     return;
   }
   if (TALER_MERCHANT_OSC_PAID != osr->details.ok.status)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Order `%s' is not paid, cannot check external payments\n",
                 coes->order_id);
     TALER_TESTING_interpreter_fail (coes->is);
     return;
   }
   payments = json_array_size (
     json_object_get (osr->details.ok.details.paid.contract_terms,
                      "amount_external"));
   refunds = json_array_size (osr->details.ok.details.paid.refunds_external);
   if (coes->expected_choice_index !=
       osr->details.ok.details.paid.choice_index)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Order `%s' was paid with choice %d, expected %d\n",
                 coes->order_id,
                 osr->details.ok.details.paid.choice_index,
                 coes->expected_choice_index);
     TALER_TESTING_interpreter_fail (coes->is);
     return;
   }
   if ( (payments != (size_t) coes->expected_payments) ||
        (refunds != (size_t) coes->expected_refunds) )
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Order `%s' reports %u external payments and %u external refunds, expected %u and %u\n",
                 coes->order_id,
                 (unsigned int) payments,
                 (unsigned int) refunds,
                 coes->expected_payments,
                 coes->expected_refunds);
     TALER_TESTING_interpreter_fail (coes->is);
     return;
   }
   TALER_TESTING_interpreter_next (coes->is);
 }
 
 
 /**
  * Run the "check order external" CMD.
  *
  * @param cls closure.
  * @param cmd command being run now.
  * @param is interpreter state.
  */
 static void
 check_order_external_run (void *cls,
                           const struct TALER_TESTING_Command *cmd,
                           struct TALER_TESTING_Interpreter *is)
 {
   struct CheckOrderExternalState *coes = cls;
 
   coes->is = is;
   coes->ogh = TALER_MERCHANT_get_private_order_create (
     TALER_TESTING_interpreter_get_context (is),
     coes->merchant_url,
     coes->order_id);
   GNUNET_assert (NULL != coes->ogh);
   {
     enum TALER_ErrorCode ec;
 
     ec = TALER_MERCHANT_get_private_order_start (coes->ogh,
                                                  &check_order_external_cb,
                                                  coes);
     GNUNET_assert (TALER_EC_NONE == ec);
   }
 }
 
 
 /**
  * Free the state of a "check order external" CMD.
  *
  * @param cls closure.
  * @param cmd command being run.
  */
 static void
 check_order_external_cleanup (void *cls,
                               const struct TALER_TESTING_Command *cmd)
 {
   struct CheckOrderExternalState *coes = cls;
 
   if (NULL != coes->ogh)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 "GET /private/orders/$ORDER_ID operation did not complete\n");
     TALER_MERCHANT_get_private_order_cancel (coes->ogh);
   }
   GNUNET_free (coes);
 }
 
 
 struct TALER_TESTING_Command
 TALER_TESTING_cmd_merchant_check_order_external (
   const char *label,
   const char *merchant_url,
   const char *order_id,
   unsigned int expected_payments,
   unsigned int expected_refunds,
   int expected_choice_index)
 {
   struct CheckOrderExternalState *coes;
 
   coes = GNUNET_new (struct CheckOrderExternalState);
   coes->merchant_url = merchant_url;
   coes->order_id = order_id;
   coes->expected_payments = expected_payments;
   coes->expected_refunds = expected_refunds;
   coes->expected_choice_index = expected_choice_index;
   {
     struct TALER_TESTING_Command cmd = {
       .cls = coes,
       .label = label,
       .run = &check_order_external_run,
       .cleanup = &check_order_external_cleanup
     };
 
     return cmd;
   }
 }