sync

testing_api_cmd_object_fetch.c (6575B)

---

 /*
   This file is part of SYNC
   Copyright (C) 2026 Taler Systems SA
 
   SYNC 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.
 
   SYNC 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 SYNC; see the file COPYING.  If not, see
   <http://www.gnu.org/licenses/>
 */
 /**
  * @file testing/testing_api_cmd_object_fetch.c
  * @brief command to fetch an object from the sync backend service.
  * @author Iván Ávalos
  */
 #include "platform.h"
 #include "sync/sync_service.h"
 #include "sync/sync_testing_lib.h"
 #include <sync/sync_util.h>
 #include <taler/taler_util.h>
 #include <taler/taler_signatures.h>
 #include <taler/taler_testing_lib.h>
 #include <gnunet/gnunet_curl_lib.h>
 
 
 /**
  * State for an "object fetch" CMD.
  */
 struct ObjectFetchState
 {
 
   /**
    * URL of the sync backend.
    */
   const char *sync_url;
 
   /**
    * Reference to a command that provides account keys.
    */
   const char *account_reference;
 
   /**
    * Eddsa public key.
    */
   struct SYNC_AccountPublicKeyP sync_pub;
 
   /**
    * UID of the object to fetch.
    */
   struct SYNC_ObjectUID uid;
 
   /**
    * Expected object data.
    */
   const void *expected_data;
 
   /**
    * Number of bytes in @e expected_data.
    */
   size_t expected_data_size;
 
   /**
    * Expected HTTP status code.
    */
   unsigned int http_status;
 
   /**
    * The interpreter state.
    */
   struct TALER_TESTING_Interpreter *is;
 
   /**
    * Handle for the library object fetch operation.
    */
   struct SYNC_ObjectFetchOperation *fop;
 
 };
 
 
 /**
  * Function called when we're done processing the
  * object fetch.
  *
  * @param cls the `struct ObjectFetchState`
  * @param http_status HTTP status code
  * @param ec error code
  * @param uid UID of the fetched object
  * @param data_size number of bytes in @a data
  * @param data object data
  */
 static void
 object_fetch_finished (void *cls,
                        unsigned int http_status,
                        enum TALER_ErrorCode ec,
                        const struct SYNC_ObjectUID *uid,
                        size_t data_size,
                        const void *data)
 {
   struct ObjectFetchState *ofs = cls;
 
   ofs->fop = NULL;
   if (http_status != ofs->http_status)
   {
     TALER_TESTING_unexpected_status (ofs->is,
                                      http_status,
                                      ofs->http_status);
     return;
   }
   if (MHD_HTTP_OK == http_status)
   {
     if (data_size != ofs->expected_data_size)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   "Object fetch data size mismatch: expected %zu, got %zu\n",
                   ofs->expected_data_size,
                   data_size);
       GNUNET_break_op (0);
       TALER_TESTING_interpreter_fail (ofs->is);
       return;
     }
     if (0 != memcmp (data,
                      ofs->expected_data,
                      ofs->expected_data_size))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   "Object fetch data content mismatch\n");
       GNUNET_break_op (0);
       TALER_TESTING_interpreter_fail (ofs->is);
       return;
     }
     if (NULL != uid)
     {
       if (0 != GNUNET_memcmp (uid,
                               &ofs->uid))
       {
         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                     "Object fetch UID mismatch\n");
         GNUNET_break_op (0);
         TALER_TESTING_interpreter_fail (ofs->is);
         return;
       }
     }
   }
   TALER_TESTING_interpreter_next (ofs->is);
 }
 
 
 /**
  * Run an "object fetch" CMD.
  *
  * @param cls closure.
  * @param cmd command currently being run.
  * @param is interpreter state.
  */
 static void
 object_fetch_run (void *cls,
                   const struct TALER_TESTING_Command *cmd,
                   struct TALER_TESTING_Interpreter *is)
 {
   struct ObjectFetchState *ofs = cls;
 
   (void) cmd;
   ofs->is = is;
 
   {
     const struct TALER_TESTING_Command *ref;
     const struct SYNC_AccountPublicKeyP *pub;
 
     ref = TALER_TESTING_interpreter_lookup_command (is,
                                                     ofs->account_reference);
     if (NULL == ref)
     {
       GNUNET_break (0);
       goto fail;
     }
     if (GNUNET_OK !=
         TALER_TESTING_get_trait_sync_account_pub (ref,
                                                   &pub))
     {
       GNUNET_break (0);
       goto fail;
     }
     ofs->sync_pub = *pub;
   }
 
   ofs->fop = SYNC_object_fetch (
     TALER_TESTING_interpreter_get_context (is),
     ofs->sync_url,
     &ofs->sync_pub,
     &ofs->uid,
     &object_fetch_finished,
     ofs);
   if (NULL == ofs->fop)
     goto fail;
 
   return;
 
 fail:
   GNUNET_break (0);
   TALER_TESTING_interpreter_fail (is);
 }
 
 
 /**
  * Free the state of an "object fetch" CMD, and possibly
  * cancel it if it did not complete.
  *
  * @param cls closure.
  * @param cmd command being freed.
  */
 static void
 object_fetch_cleanup (void *cls,
                       const struct TALER_TESTING_Command *cmd)
 {
   struct ObjectFetchState *ofs = cls;
 
   if (NULL != ofs->fop)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 "Command '%s' did not complete (object fetch)\n",
                 cmd->label);
     SYNC_object_fetch_cancel (ofs->fop);
     ofs->fop = NULL;
   }
   GNUNET_free (ofs);
 }
 
 
 struct TALER_TESTING_Command
 SYNC_TESTING_cmd_object_fetch (const char *label,
                                const char *sync_url,
                                const char *account_reference,
                                const struct SYNC_ObjectUID *uid,
                                unsigned int http_status,
                                const void *expected_data,
                                size_t expected_data_size)
 {
   struct ObjectFetchState *ofs;
 
   ofs = GNUNET_new (struct ObjectFetchState);
   ofs->sync_url = sync_url;
   ofs->account_reference = account_reference;
   if (NULL != uid)
     ofs->uid = *uid;
   ofs->http_status = http_status;
   ofs->expected_data = expected_data;
   ofs->expected_data_size = expected_data_size;
   {
     struct TALER_TESTING_Command cmd = {
       .cls = ofs,
       .label = label,
       .run = &object_fetch_run,
       .cleanup = &object_fetch_cleanup,
       .traits = NULL
     };
 
     return cmd;
   }
 }
 
 
 /* end of testing_api_cmd_object_fetch.c */