path: root/src/testing/testing_api_cmd_post_using_templates.c

/*
  This file is part of TALER
  Copyright (C) 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
  <http://www.gnu.org/licenses/>
*/
/**
 * @file testing_api_cmd_post_using_templates.c
 * @brief command to test POST /using-templates
 * @author Priscilla HUANG
 */
#include "platform.h"
#include <taler/taler_exchange_service.h>
#include <taler/taler_testing_lib.h>
#include "taler_merchant_service.h"
#include "taler_merchant_testing_lib.h"

/**
 * State of a "POST /templates" CMD.
 */
struct PostUsingTemplatesState
{

  /**
   * Handle for a "GET using-template" request.
   */
  struct TALER_MERCHANT_UsingTemplatesPostHandle *iph;

  /**
   * The interpreter state.
   */
  struct TALER_TESTING_Interpreter *is;

  /**
   * The (initial) POST /orders/$ID/claim operation handle.
   * The logic is such that after an order creation,
   * we immediately claim the order.
   */
  struct TALER_MERCHANT_OrderClaimHandle *och;

  /**
   * Base URL of the merchant serving the request.
   */
  const char *merchant_url;

  /**
   * Summary given by the customer.
   */
  const char *summary;

  /**
   * Amount given by the customer.
   */
  struct TALER_Amount amount;

  /**
   * Label of a command that created the template we should use.
   */
  const char *template_ref;

  /**
   * Order id.
   */
  const char *order_id;

  /**
   * The order id we expect the merchant to assign (if not NULL).
   */
  const char *expected_order_id;

  /**
   * Contract terms obtained from the backend.
   */
  json_t *contract_terms;

  /**
   * Order submitted to the backend.
   */
  json_t *order_terms;

  /**
   * Contract terms hash code.
   */
  struct TALER_PrivateContractHashP h_contract_terms;

  /**
   * Merchant signature over the orders.
   */
  struct TALER_MerchantSignatureP merchant_sig;

  /**
   * Merchant public key.
   */
  struct TALER_MerchantPublicKeyP merchant_pub;

  /**
   * The nonce.
   */
  struct GNUNET_CRYPTO_EddsaPublicKey nonce;

  /**
   * The claim token
   */
  struct TALER_ClaimTokenP claim_token;

  /**
   * Should the command also CLAIM the order?
   */
  bool with_claim;

  /**
   * If not NULL, the command should duplicate the request and verify the
   * response is the same as in this command.
   */
  const char *duplicate_of;

  /**
   * Encoded key for the payment verification.
   */
  const char **template_pos_key;

  /**
   * Expected HTTP response code.
   */
  unsigned int http_status;

};

/**
 * Used to fill the "orders" CMD state with backend-provided
 * values.  Also double-checks that the order was correctly
 * created.
 *
 * @param cls closure
 * @param hr HTTP response we got
 * @param contract_terms contract terms of this order
 * @param sig merchant's signature
 * @param hash hash over the contract
 */
static void
orders_claim_cb (void *cls,
                 const struct TALER_MERCHANT_HttpResponse *hr,
                 const json_t *contract_terms,
                 const struct TALER_MerchantSignatureP *sig,
                 const struct TALER_PrivateContractHashP *hash)
{
  struct PostUsingTemplatesState *tis = cls;
  struct TALER_MerchantPublicKeyP merchant_pub;
  const char *error_name;
  unsigned int error_line;
  struct GNUNET_JSON_Specification spec[] = {
    GNUNET_JSON_spec_fixed_auto ("merchant_pub",
                                 &merchant_pub),
    GNUNET_JSON_spec_end ()
  };

  tis->och = NULL;
  if (tis->http_status != hr->http_status)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Expected status %u, got %u\n",
                tis->http_status,
                hr->http_status);
    TALER_TESTING_FAIL (tis->is);
  }

  tis->contract_terms = json_deep_copy (contract_terms);
  tis->h_contract_terms = *hash;
  tis->merchant_sig = *sig;
  if (GNUNET_OK !=
      GNUNET_JSON_parse (contract_terms,
                         spec,
                         &error_name,
                         &error_line))
  {
    char *log;

    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Parser failed on %s:%u\n",
                error_name,
                error_line);
    log = json_dumps (tis->contract_terms,
                      JSON_INDENT (1));
    fprintf (stderr,
             "%s\n",
             log);
    free (log);
    TALER_TESTING_FAIL (tis->is);
  }
  tis->merchant_pub = merchant_pub;
  TALER_TESTING_interpreter_next (tis->is);
}


/**
 * Callback for a POST /using-templates operation.
 *
 * @param cls closure for this function
 * @param por response being processed
 */
static void
post_using_templates_cb (void *cls,
                         const struct TALER_MERCHANT_PostOrdersReply *por)
{
  struct PostUsingTemplatesState *tis = cls;

  tis->iph = NULL;
  if (tis->http_status != por->hr.http_status)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Unexpected response code %u (%d) to command %s\n",
                por->hr.http_status,
                (int) por->hr.ec,
                TALER_TESTING_interpreter_get_current_label (tis->is));
    TALER_TESTING_interpreter_fail (tis->is);
    return;
  }
  if (0 == tis->http_status)
  {
    TALER_LOG_DEBUG ("/using_templates, expected 0 status code\n");
    TALER_TESTING_interpreter_next (tis->is);
    return;
  }
  // check the rest of the function to adapt to using_template
  switch (por->hr.http_status)
  {
  case MHD_HTTP_OK:
    if (NULL != por->details.ok.token)
      tis->claim_token = *por->details.ok.token;
    tis->order_id = GNUNET_strdup (por->details.ok.order_id);
    if ((NULL != tis->expected_order_id) &&
        (0 != strcmp (por->details.ok.order_id,
                      tis->expected_order_id)))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Order id assigned does not match\n");
      TALER_TESTING_interpreter_fail (tis->is);
      return;
    }
    if (NULL != tis->duplicate_of)
    {
      const struct TALER_TESTING_Command *order_cmd;
      const struct TALER_ClaimTokenP *prev_token;
      struct TALER_ClaimTokenP zero_token = {0};

      order_cmd = TALER_TESTING_interpreter_lookup_command (
        tis->is,
        tis->duplicate_of);
      if (GNUNET_OK !=
          TALER_TESTING_get_trait_claim_token (order_cmd,
                                               &prev_token))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Could not fetch previous order claim token\n");
        TALER_TESTING_interpreter_fail (tis->is);
        return;
      }
      if (NULL == por->details.ok.token)
        prev_token = &zero_token;
      if (0 != GNUNET_memcmp (prev_token,
                              por->details.ok.token))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Claim tokens for identical requests do not match\n");
        TALER_TESTING_interpreter_fail (tis->is);
        return;
      }
    }
    break;
  case MHD_HTTP_NOT_FOUND:
    TALER_TESTING_interpreter_next (tis->is);
    return;
  case MHD_HTTP_GONE:
    TALER_TESTING_interpreter_next (tis->is);
    return;
  case MHD_HTTP_CONFLICT:
    TALER_TESTING_interpreter_next (tis->is);
    return;
  default:
    {
      char *s = json_dumps (por->hr.reply,
                            JSON_COMPACT);
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Unexpected status code from /orders: %u (%d) at %s; JSON: %s\n",
                  por->hr.http_status,
                  (int) por->hr.ec,
                  TALER_TESTING_interpreter_get_current_label (tis->is),
                  s);
      GNUNET_free (s);
      /**
       * Not failing, as test cases are _supposed_
       * to create non 200 OK situations.
       */
      TALER_TESTING_interpreter_next (tis->is);
    }
    return;
  }

  if (! tis->with_claim)
  {
    TALER_TESTING_interpreter_next (tis->is);
    return;
  }
  if (NULL ==
      (tis->och = TALER_MERCHANT_order_claim (tis->is->ctx,
                                             tis->merchant_url,
                                             tis->order_id,
                                             &tis->nonce,
                                             &tis->claim_token,
                                             &orders_claim_cb,
                                             tis)))
    TALER_TESTING_FAIL (tis->is);

  /*
  switch (por->hr.http_status)
  {
  case MHD_HTTP_OK:
    break;
  case MHD_HTTP_CONFLICT:
    break;
  case MHD_HTTP_NOT_FOUND:
    break;
  default:
    GNUNET_break (0);
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Unhandled HTTP status %u for POST /templates/$ID.\n",
                por->hr.http_status);
    break;
  }
  TALER_TESTING_interpreter_next (tis->is);*/
}


/**
 * Run the "POST /using-templates" CMD.
 *
 *
 * @param cls closure.
 * @param cmd command being run now.
 * @param is interpreter state.
 */
static void
post_using_templates_run (void *cls,
                          const struct TALER_TESTING_Command *cmd,
                          struct TALER_TESTING_Interpreter *is)
{
  struct PostUsingTemplatesState *tis = cls;
  const struct TALER_TESTING_Command *ref;
  const char **template_id;

  tis->is = is;
  ref = TALER_TESTING_interpreter_lookup_command (is,
                                                  tis->template_ref);
  if (GNUNET_OK !=
      TALER_TESTING_get_trait_template_id (ref,
                                           &template_id))
    TALER_TESTING_FAIL (is);
  if (GNUNET_OK !=
      TALER_TESTING_get_trait_template_pos_key (ref,
                                                &tis->template_pos_key))
    TALER_TESTING_FAIL (is);
  tis->iph = TALER_MERCHANT_using_templates_post (
    is->ctx,
    tis->merchant_url,
    *template_id,
    tis->summary,
    TALER_amount_is_valid (&tis->amount)
    ? &tis->amount
    : NULL,
    &post_using_templates_cb,
    tis);
  GNUNET_assert (NULL != tis->iph);
}


/**
 * Offers information from the POST /using-templates CMD state to other
 * commands.
 *
 * @param cls closure
 * @param[out] ret result (could be anything)
 * @param trait name of the trait
 * @param index index number of the object to extract.
 * @return #GNUNET_OK on success
 */
static enum GNUNET_GenericReturnValue
post_using_templates_traits (void *cls,
                             const void **ret,
                             const char *trait,
                             unsigned int index)
{
  struct PostUsingTemplatesState *pts = cls;
  struct TALER_TESTING_Trait traits[] = {
    TALER_TESTING_make_trait_order_id (&pts->order_id),
    TALER_TESTING_make_trait_contract_terms (pts->contract_terms),
    TALER_TESTING_make_trait_order_terms (pts->order_terms),
    TALER_TESTING_make_trait_h_contract_terms (&pts->h_contract_terms),
    TALER_TESTING_make_trait_merchant_sig (&pts->merchant_sig),
    TALER_TESTING_make_trait_merchant_pub (&pts->merchant_pub),
    TALER_TESTING_make_trait_claim_nonce (&pts->nonce),
    TALER_TESTING_make_trait_claim_token (&pts->claim_token),
    TALER_TESTING_make_trait_template_pos_key (pts->template_pos_key), // extract from template creation CMD
    TALER_TESTING_trait_end (),
  };

  (void) pts;
  return TALER_TESTING_get_trait (traits,
                                  ret,
                                  trait,
                                  index);
}


/**
 * Free the state of a "POST using-template" CMD, and possibly
 * cancel a pending operation thereof.
 *
 * @param cls closure.
 * @param cmd command being run.
 */
static void
post_using_templates_cleanup (void *cls,
                              const struct TALER_TESTING_Command *cmd)
{
  struct PostUsingTemplatesState *tis = cls;

  if (NULL != tis->iph)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "POST /using-templates operation did not complete\n");
    TALER_MERCHANT_using_templates_post_cancel (tis->iph);
  }
  GNUNET_free (tis);
}


struct TALER_TESTING_Command
TALER_TESTING_cmd_merchant_post_using_templates (
  const char *label,
  const char *template_ref,
  const char *merchant_url,
  const char *summary,
  const char *amount,
  unsigned int http_status)
{
  struct PostUsingTemplatesState *tis;

  tis = GNUNET_new (struct PostUsingTemplatesState);
  tis->template_ref = template_ref;
  tis->merchant_url = merchant_url;
  tis->http_status = http_status;
  tis->summary = summary;
  if (NULL != amount)
    GNUNET_assert (GNUNET_OK ==
                   TALER_string_to_amount (amount,
                                           &tis->amount));
  {
    struct TALER_TESTING_Command cmd = {
      .cls = tis,
      .label = label,
      .run = &post_using_templates_run,
      .cleanup = &post_using_templates_cleanup,
      .traits = &post_using_templates_traits
    };

    return cmd;
  }
}


/* end of testing_api_cmd_post_using_templates.c */