src/tests/testStoreHashIndex.cc

   1 /*
   2  * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
   3  *
   4  * Squid software is distributed under GPLv2+ license and includes
   5  * contributions from numerous individuals and organizations.
   6  * Please see the COPYING and CONTRIBUTORS files for details.
   7  */
   8
   9 #include "squid.h"
  10 #include "compat/cppunit.h"
  11 #include "MemObject.h"
  12 #include "SquidConfig.h"
  13 #include "Store.h"
  14 #include "store/Disks.h"
  15 #include "StoreSearch.h"
  16 #include "TestSwapDir.h"
  17
  18 /*
  19  * test the store framework
  20  */
  21
  22 class TestStoreHashIndex : public CPPUNIT_NS::TestFixture
  23 {
  24     CPPUNIT_TEST_SUITE(TestStoreHashIndex);
  25     CPPUNIT_TEST(testStats);
  26     CPPUNIT_TEST(testMaxSize);
  27     CPPUNIT_TEST(testSearch);
  28     CPPUNIT_TEST_SUITE_END();
  29
  30 public:
  31 protected:
  32     void testStats();
  33     void testMaxSize();
  34     void testSearch();
  35 };
  36 CPPUNIT_TEST_SUITE_REGISTRATION(TestStoreHashIndex);
  37
  38 static void
  39 addSwapDir(TestSwapDirPointer aStore)
  40 {
  41     allocate_new_swapdir(Config.cacheSwap);
  42     Config.cacheSwap.swapDirs[Config.cacheSwap.n_configured] = aStore.getRaw();
  43     ++Config.cacheSwap.n_configured;
  44 }
  45
  46 void
  47 TestStoreHashIndex::testStats()
  48 {
  49     StoreEntry *logEntry = new StoreEntry;
  50     logEntry->createMemObject("dummy_storeId", nullptr, HttpRequestMethod());
  51     logEntry->store_status = STORE_PENDING;
  52     TestSwapDirPointer aStore (new TestSwapDir);
  53     TestSwapDirPointer aStore2 (new TestSwapDir);
  54     addSwapDir(aStore);
  55     addSwapDir(aStore2);
  56     CPPUNIT_ASSERT_EQUAL(false, aStore->statsCalled);
  57     CPPUNIT_ASSERT_EQUAL(false, aStore2->statsCalled);
  58     Store::Stats(logEntry);
  59     free_cachedir(&Config.cacheSwap);
  60     CPPUNIT_ASSERT_EQUAL(true, aStore->statsCalled);
  61     CPPUNIT_ASSERT_EQUAL(true, aStore2->statsCalled);
  62 }
  63
  64 void
  65 TestStoreHashIndex::testMaxSize()
  66 {
  67     StoreEntry *logEntry = new StoreEntry;
  68     logEntry->createMemObject("dummy_storeId", nullptr, HttpRequestMethod());
  69     logEntry->store_status = STORE_PENDING;
  70     TestSwapDirPointer aStore (new TestSwapDir);
  71     TestSwapDirPointer aStore2 (new TestSwapDir);
  72     addSwapDir(aStore);
  73     addSwapDir(aStore2);
  74     CPPUNIT_ASSERT_EQUAL(static_cast<uint64_t>(6), Store::Root().maxSize());
  75     free_cachedir(&Config.cacheSwap);
  76 }
  77
  78 static StoreEntry *
  79 addedEntry(Store::Disk *aStore,
  80            String name,
  81            String,
  82            String
  83           )
  84 {
  85     StoreEntry *e = new StoreEntry();
  86     e->store_status = STORE_OK;
  87     e->setMemStatus(NOT_IN_MEMORY);
  88     e->swap_status = SWAPOUT_DONE; /* bogus haha */
  89     e->swap_filen = 0; /* garh - lower level*/
  90     e->swap_dirn = -1;
  91
  92     for (int i=0; i < Config.cacheSwap.n_configured; ++i) {
  93         if (INDEXSD(i) == aStore)
  94             e->swap_dirn = i;
  95     }
  96
  97     CPPUNIT_ASSERT (e->swap_dirn != -1);
  98     e->swap_file_sz = 0; /* garh lower level */
  99     e->lastref = squid_curtime;
 100     e->timestamp = squid_curtime;
 101     e->expires = squid_curtime;
 102     e->lastModified(squid_curtime);
 103     e->refcount = 1;
 104     e->ping_status = PING_NONE;
 105     EBIT_CLR(e->flags, ENTRY_VALIDATED);
 106     e->hashInsert((const cache_key *)name.termedBuf()); /* do it after we clear KEY_PRIVATE */
 107     return e;
 108 }
 109
 110 static void commonInit()
 111 {
 112     static bool inited = false;
 113
 114     if (inited)
 115         return;
 116
 117     inited = true;
 118
 119     Mem::Init();
 120
 121     Config.Store.avgObjectSize = 1024;
 122
 123     Config.Store.objectsPerBucket = 20;
 124
 125     Config.Store.maxObjectSize = 2048;
 126
 127     Config.memShared.defaultTo(false);
 128
 129     Config.store_dir_select_algorithm = xstrdup("round-robin");
 130 }
 131
 132 /* TODO make this a cbdata class */
 133
 134 static bool cbcalled;
 135
 136 static void
 137 searchCallback(void *)
 138 {
 139     cbcalled = true;
 140 }
 141
 142 void
 143 TestStoreHashIndex::testSearch()
 144 {
 145     commonInit();
 146     TestSwapDirPointer aStore (new TestSwapDir);
 147     TestSwapDirPointer aStore2 (new TestSwapDir);
 148     addSwapDir(aStore);
 149     addSwapDir(aStore2);
 150     Store::Root().init();
 151     StoreEntry * entry1 = addedEntry(aStore.getRaw(), "name", nullptr, nullptr);
 152     StoreEntry * entry2 = addedEntry(aStore2.getRaw(), "name2", nullptr, nullptr);
 153     StoreSearchPointer search = Store::Root().search(); /* search for everything in the store */
 154
 155     /* nothing should be immediately available */
 156     CPPUNIT_ASSERT_EQUAL(false, search->error());
 157     CPPUNIT_ASSERT_EQUAL(false, search->isDone());
 158     CPPUNIT_ASSERT_EQUAL(static_cast<StoreEntry *>(nullptr), search->currentItem());
 159
 160     /* trigger a callback */
 161     cbcalled = false;
 162     search->next(searchCallback, nullptr);
 163     CPPUNIT_ASSERT_EQUAL(true, cbcalled);
 164
 165     /* we should have access to a entry now, that matches the entry we had before */
 166     CPPUNIT_ASSERT_EQUAL(false, search->error());
 167     CPPUNIT_ASSERT_EQUAL(false, search->isDone());
 168     /* note the hash order is random - the test happens to be in a nice order */
 169     CPPUNIT_ASSERT_EQUAL(entry1, search->currentItem());
 170     //CPPUNIT_ASSERT_EQUAL(false, search->next());
 171
 172     /* trigger another callback */
 173     cbcalled = false;
 174     search->next(searchCallback, nullptr);
 175     CPPUNIT_ASSERT_EQUAL(true, cbcalled);
 176
 177     /* we should have access to a entry now, that matches the entry we had before */
 178     CPPUNIT_ASSERT_EQUAL(false, search->error());
 179     CPPUNIT_ASSERT_EQUAL(false, search->isDone());
 180     CPPUNIT_ASSERT_EQUAL(entry2, search->currentItem());
 181     //CPPUNIT_ASSERT_EQUAL(false, search->next());
 182
 183     /* trigger another callback */
 184     cbcalled = false;
 185     search->next(searchCallback, nullptr);
 186     CPPUNIT_ASSERT_EQUAL(true, cbcalled);
 187
 188     /* now we should have no error, we should have finished and have no current item */
 189     CPPUNIT_ASSERT_EQUAL(false, search->error());
 190     CPPUNIT_ASSERT_EQUAL(true, search->isDone());
 191     CPPUNIT_ASSERT_EQUAL(static_cast<StoreEntry *>(nullptr), search->currentItem());
 192     //CPPUNIT_ASSERT_EQUAL(false, search->next());
 193 }
 194
 195 // This test uses main() from ./testStore.cc.
 196