tests/virfilecachetest.c

   1 /*
   2  * Copyright (C) 2017 Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library.  If not, see
  16  * <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 #include <config.h>
  21
  22 #include "testutils.h"
  23
  24 #include "virfile.h"
  25 #include "virfilecache.h"
  26
  27
  28 #define VIR_FROM_THIS VIR_FROM_NONE
  29
  30
  31 struct _testFileCacheObj {
  32     virObject parent;
  33     char *data;
  34 };
  35 typedef struct _testFileCacheObj testFileCacheObj;
  36 typedef testFileCacheObj *testFileCacheObjPtr;
  37
  38
  39 static virClassPtr testFileCacheObjClass;
  40
  41
  42 static void
  43 testFileCacheObjDispose(void *opaque)
  44 {
  45     testFileCacheObjPtr obj = opaque;
  46     VIR_FREE(obj->data);
  47 }
  48
  49
  50 static int
  51 testFileCacheObjOnceInit(void)
  52 {
  53     if (!VIR_CLASS_NEW(testFileCacheObj, virClassForObject()))
  54         return -1;
  55
  56     return 0;
  57 }
  58
  59
  60 VIR_ONCE_GLOBAL_INIT(testFileCacheObj);
  61
  62
  63 static testFileCacheObjPtr
  64 testFileCacheObjNew(const char *data)
  65 {
  66     testFileCacheObjPtr obj;
  67
  68     if (testFileCacheObjInitialize() < 0)
  69         return NULL;
  70
  71     if (!(obj = virObjectNew(testFileCacheObjClass)))
  72         return NULL;
  73
  74     if (VIR_STRDUP(obj->data, data) < 0)
  75         goto error;
  76
  77     return obj;
  78
  79  error:
  80     virObjectUnref(obj);
  81     return NULL;
  82 }
  83
  84
  85 struct _testFileCachePriv {
  86     bool dataSaved;
  87     const char *newData;
  88     const char *expectData;
  89 };
  90 typedef struct _testFileCachePriv testFileCachePriv;
  91 typedef testFileCachePriv *testFileCachePrivPtr;
  92
  93
  94 static bool
  95 testFileCacheIsValid(void *data,
  96                      void *priv)
  97 {
  98     testFileCachePrivPtr testPriv = priv;
  99     testFileCacheObjPtr obj = data;
 100
 101     return STREQ(testPriv->expectData, obj->data);
 102 }
 103
 104
 105 static void *
 106 testFileCacheNewData(const char *name ATTRIBUTE_UNUSED,
 107                      void *priv)
 108 {
 109     testFileCachePrivPtr testPriv = priv;
 110
 111     return testFileCacheObjNew(testPriv->newData);
 112 }
 113
 114
 115 static void *
 116 testFileCacheLoadFile(const char *filename,
 117                       const char *name ATTRIBUTE_UNUSED,
 118                       void *priv ATTRIBUTE_UNUSED)
 119 {
 120     testFileCacheObjPtr obj;
 121     char *data;
 122
 123     if (virFileReadAll(filename, 20, &data) < 0)
 124         return NULL;
 125
 126     obj = testFileCacheObjNew(data);
 127
 128     VIR_FREE(data);
 129     return obj;
 130 }
 131
 132
 133 static int
 134 testFileCacheSaveFile(void *data ATTRIBUTE_UNUSED,
 135                       const char *filename ATTRIBUTE_UNUSED,
 136                       void *priv)
 137 {
 138     testFileCachePrivPtr testPriv = priv;
 139
 140     testPriv->dataSaved = true;
 141
 142     return 0;
 143 }
 144
 145
 146 virFileCacheHandlers testFileCacheHandlers = {
 147     .isValid = testFileCacheIsValid,
 148     .newData = testFileCacheNewData,
 149     .loadFile = testFileCacheLoadFile,
 150     .saveFile = testFileCacheSaveFile
 151 };
 152
 153
 154 struct _testFileCacheData {
 155     virFileCachePtr cache;
 156     const char *name;
 157     const char *newData;
 158     const char *expectData;
 159     bool expectSave;
 160 };
 161 typedef struct _testFileCacheData testFileCacheData;
 162 typedef testFileCacheData *testFileCacheDataPtr;
 163
 164
 165 static int
 166 testFileCache(const void *opaque)
 167 {
 168     int ret = -1;
 169     const testFileCacheData *data = opaque;
 170     testFileCacheObjPtr obj = NULL;
 171     testFileCachePrivPtr testPriv = virFileCacheGetPriv(data->cache);
 172
 173     testPriv->dataSaved = false;
 174     testPriv->newData = data->newData;
 175     testPriv->expectData = data->expectData;
 176
 177     if (!(obj = virFileCacheLookup(data->cache, data->name))) {
 178         fprintf(stderr, "Getting cached data failed.\n");
 179         goto cleanup;
 180     }
 181
 182     if (!obj->data || STRNEQ(data->expectData, obj->data)) {
 183         fprintf(stderr, "Expect data '%s', loaded data '%s'.\n",
 184                 data->expectData, NULLSTR(obj->data));
 185         goto cleanup;
 186     }
 187
 188     if (data->expectSave != testPriv->dataSaved) {
 189         fprintf(stderr, "Expect data to be saved '%s', data saved '%s'.\n",
 190                 data->expectSave ? "yes" : "no",
 191                 testPriv->dataSaved ? "yes" : "no");
 192         goto cleanup;
 193     }
 194
 195     ret = 0;
 196
 197  cleanup:
 198     virObjectUnref(obj);
 199     return ret;
 200 }
 201
 202
 203 static int
 204 mymain(void)
 205 {
 206     int ret = 0;
 207     testFileCachePriv testPriv = {0};
 208     virFileCachePtr cache = NULL;
 209
 210     if (!(cache = virFileCacheNew(abs_srcdir "/virfilecachedata",
 211                                   "cache", &testFileCacheHandlers)))
 212         return EXIT_FAILURE;
 213
 214     virFileCacheSetPriv(cache, &testPriv);
 215
 216 #define TEST_RUN(name, newData, expectData, expectSave) \
 217     do { \
 218         testFileCacheData data = { \
 219             cache, name, newData, expectData, expectSave \
 220         }; \
 221         if (virTestRun(name, testFileCache, &data) < 0) \
 222             ret = -1; \
 223     } while (0)
 224
 225     /* The cache file name is created using:
 226      * '$ echo -n $TEST_NAME | sha256sum' */
 227     TEST_RUN("cacheValid", NULL, "aaa\n", false);
 228     TEST_RUN("cacheInvalid", "bbb\n", "bbb\n", true);
 229     TEST_RUN("cacheMissing", "ccc\n", "ccc\n", true);
 230
 231     virObjectUnref(cache);
 232
 233     return ret != 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 234 }
 235
 236 VIR_TEST_MAIN_PRELOAD(mymain, abs_builddir "/.libs/virfilecachemock.so")