Hermit/tests/test_models.c

#ifndef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE
#endif

#include "cst_agent.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define CST_TEST_SOCKETS
#include "cst_test_util.h"

#include <pthread.h>

#define CHECK(c)                                                               \
  do {                                                                         \
    if (!(c)) {                                                                \
      fprintf(stderr, "%s:%d: CHECK(%s) failed\n", __FILE__, __LINE__, #c);   \
      exit(1);                                                                 \
    }                                                                          \
  } while (0)

/* One canned HTTP response per accepted connection. */
static const char *g_responses[8];
static int g_nresp;
static test_sock_t g_listen = TEST_BAD_SOCK;
static char g_request[4096];

static void *serve(void *arg) {
  (void)arg;
  for (int i = 0; i < g_nresp; i++) {
    test_sock_t c = accept(g_listen, NULL, NULL);
    if (c == TEST_BAD_SOCK)
      return NULL;
    long n = recv(c, g_request, sizeof(g_request) - 1, 0);
    g_request[n > 0 ? n : 0] = 0;
    const char *r = g_responses[i];
    long off = 0, len = (long)strlen(r);
    while (off < len) {
      long w = send(c, r + off, (int)(len - off), 0);
      if (w <= 0)
        break;
      off += w;
    }
    test_sock_close(c);
  }
  return NULL;
}

static int start_server(void) {
  test_sock_init();
  g_listen = socket(AF_INET, SOCK_STREAM, 0);
  CHECK(g_listen != TEST_BAD_SOCK);
#ifndef _WIN32
  int one = 1;
  setsockopt(g_listen, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
#endif
  struct sockaddr_in a;
  memset(&a, 0, sizeof(a));
  a.sin_family = AF_INET;
  a.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
  CHECK(bind(g_listen, (struct sockaddr *)&a, sizeof(a)) == 0);
  CHECK(listen(g_listen, 8) == 0);
  socklen_t al = sizeof(a);
  CHECK(getsockname(g_listen, (struct sockaddr *)&a, &al) == 0);
  return ntohs(a.sin_port);
}

#define RESP(status, body)                                                     \
  "HTTP/1.1 " status "\r\nContent-Type: application/json\r\n"                  \
  "Connection: close\r\n\r\n" body

int main(void) {
  g_responses[0] = RESP("200 OK", "{\"object\":\"list\",\"data\":["
                                  "{\"id\":\"deepseek-flash\"},"
                                  "{\"id\":\"deepseek-v4-pro\"},"
                                  "{\"id\":\"deepseek-flash\"}]}");
  g_responses[1] = RESP("401 Unauthorized", "{\"error\":\"bad key\"}");
  g_responses[2] = RESP("200 OK", "<html>not json</html>");
  g_responses[3] = RESP("200 OK", "{\"models\":[{\"name\":\"m1\"},"
                                  "{\"name\":\"m2\"}]}");
  g_responses[4] = RESP("500 Internal Server Error", "{}");
  g_nresp = 5;
  int port = start_server();
  pthread_t th;
  CHECK(pthread_create(&th, NULL, serve, NULL) == 0);

  char base[64];
  snprintf(base, sizeof(base), "http://127.0.0.1:%d/v1/", port);
  char ids[8][128], err[256];

  /* data[].id, duplicates folded, trailing slash on the base */
  int n = cst_llm_list_models(base, "sk-test", ids, 8, err, sizeof(err));
  CHECK(n == 2);
  CHECK(strcmp(ids[0], "deepseek-flash") == 0);
  CHECK(strcmp(ids[1], "deepseek-v4-pro") == 0);
  CHECK(strncmp(g_request, "GET /v1/models ", 15) == 0);
  CHECK(strstr(g_request, "Authorization: Bearer sk-test") != NULL);

  n = cst_llm_list_models(base, "sk-bad", ids, 8, err, sizeof(err));
  CHECK(n == CST_MODELS_AUTH);
  CHECK(strstr(err, "401") != NULL);

  n = cst_llm_list_models(base, "sk-test", ids, 8, err, sizeof(err));
  CHECK(n == -1);
  CHECK(err[0]);

  n = cst_llm_list_models(base, "sk-test", ids, 8, err, sizeof(err));
  CHECK(n == 2 && strcmp(ids[1], "m2") == 0);

  n = cst_llm_list_models(base, "sk-test", ids, 8, err, sizeof(err));
  CHECK(n == -1 && strstr(err, "500") != NULL);

  pthread_join(th, NULL);
  test_sock_close(g_listen);

  /* nothing listening: network error, not an auth failure */
  n = cst_llm_list_models(base, "sk-test", ids, 8, err, sizeof(err));
  CHECK(n == -1);

  puts("test_models: ok");
  return 0;
}