<?php
/**
* SeekQuarry/Yioop --
* Open Source Pure PHP Search Engine, Crawler, and Indexer
*
* Copyright (C) 2009 - 2026 Chris Pollett chris@pollett.org
*
* LICENSE:
*
* This program 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 of the License, or
* (at your option) any later version.
*
* This program 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 this program. If not, see
* <https://www.gnu.org/licenses/>.
*
* END LICENSE
*
* @author Chris Pollett chris@pollett.org
* @license https://www.gnu.org/licenses/ GPL3
* @link https://www.seekquarry.com/
* @copyright 2009 - 2026
* @filesource
*/
namespace seekquarry\yioop\tests;
use seekquarry\yioop\configs as C;
use seekquarry\yioop\library\mail\MailRecordCache;
use seekquarry\yioop\library\UnitTest;
/**
* Tests the cross-user mail-security record cache: storing and
* returning a record, keeping different record types for the same
* name apart through the composite key, honoring expiry, clamping the
* DNS time to live to the configured range, caching a miss separately
* from an unknown name, and persisting to a file so the records are
* shared across requests and users.
*
* Each case points the cache at a throwaway file under the system
* temporary directory, set in setUp and removed in tearDown, so the
* test never reads or writes the real CACHE_DIR.
*
* @author Chris Pollett
*/
class MailRecordCacheTest extends UnitTest
{
/**
* Throwaway file the cache persists to during a case; created
* via setInstanceFile in setUp, removed in tearDown.
* @var string
*/
public $temp_file;
/**
* Points the shared cache at a unique throwaway file so nothing
* touches the real CACHE_DIR.
*/
public function setUp()
{
$this->temp_file = sys_get_temp_dir() . "/mail_record_test_" .
getmypid() . "_" . uniqid() . ".json";
MailRecordCache::setInstanceFile($this->temp_file);
}
/**
* Removes the throwaway file and clears the shared instance so
* nothing leaks into later tests or the real environment.
*/
public function tearDown()
{
if (file_exists($this->temp_file)) {
unlink($this->temp_file);
}
MailRecordCache::setInstanceFile(null);
}
/**
* A type and name never stored returns null, telling the caller
* to do a fresh DNS lookup; a stored record is returned on the
* next get.
*/
public function storeAndGetTestCase()
{
$cache = MailRecordCache::getInstance();
$this->assertTrue(
$cache->get(MailRecordCache::TYPE_DKIM,
'sel._domainkey.unknown.example') === null,
"an unknown record returns null");
$cache->put(MailRecordCache::TYPE_DKIM,
'sel._domainkey.known.example', 'KEYBODY', 60);
$this->assertEqual('KEYBODY',
$cache->get(MailRecordCache::TYPE_DKIM,
'sel._domainkey.known.example'),
"a stored record is returned");
}
/**
* The same lookup name under two record types is kept apart by
* the composite key, so a DKIM entry and a DMARC entry for one
* domain do not overwrite or shadow each other.
*/
public function compositeKeySeparatesTypesTestCase()
{
$cache = MailRecordCache::getInstance();
$cache->put(MailRecordCache::TYPE_DKIM, 'example.com',
'DKIMVALUE', 60);
$cache->put(MailRecordCache::TYPE_DMARC, 'example.com',
'v=DMARC1; p=reject', 60);
$this->assertEqual('DKIMVALUE',
$cache->get(MailRecordCache::TYPE_DKIM, 'example.com'),
"the DKIM record for the name is returned");
$this->assertEqual('v=DMARC1; p=reject',
$cache->get(MailRecordCache::TYPE_DMARC, 'example.com'),
"the DMARC record for the same name is separate");
}
/**
* A lookup that found nothing is cached as the empty string,
* which is distinct from the null returned for a record that was
* never stored, so a missing record is not re-queried on every
* view.
*/
public function negativeLookupCachedTestCase()
{
$cache = MailRecordCache::getInstance();
$cache->put(MailRecordCache::TYPE_DMARC,
'_dmarc.nopolicy.example', '', 0);
$this->assertTrue(
$cache->get(MailRecordCache::TYPE_DMARC,
'_dmarc.nopolicy.example') === '',
"a cached miss returns '' not null");
}
/**
* The DNS record's time to live is honored but clamped: a tiny
* value is raised to the configured minimum and a huge value is
* lowered to the configured maximum, read back from the stored
* expiry.
*/
public function timeToLiveClampedTestCase()
{
$cache = MailRecordCache::getInstance();
$now = time();
$cache->put(MailRecordCache::TYPE_DKIM, 'low.example', 'K',
1);
$cache->put(MailRecordCache::TYPE_DKIM, 'high.example', 'K',
999999999);
$stored = json_decode(file_get_contents($this->temp_file),
true);
$low_key = MailRecordCache::TYPE_DKIM . "\x00" . 'low.example';
$high_key = MailRecordCache::TYPE_DKIM . "\x00" .
'high.example';
$low_life = $stored[$low_key][1] - $now;
$high_life = $stored[$high_key][1] - $now;
$this->assertTrue(
$low_life >= C\MAIL_RECORD_CACHE_MIN - 2 &&
$low_life <= C\MAIL_RECORD_CACHE_MIN + 2,
"a short DNS ttl is clamped up to the minimum");
$this->assertTrue(
$high_life >= C\MAIL_RECORD_CACHE_MAX - 2 &&
$high_life <= C\MAIL_RECORD_CACHE_MAX + 2,
"a long DNS ttl is clamped down to the maximum");
}
/**
* An entry whose expiry is in the past is not returned, so a
* changed or stale record is eventually re-fetched from DNS.
*/
public function expiredEntryIgnoredTestCase()
{
$key = MailRecordCache::TYPE_DKIM . "\x00" . 'old.example';
$expired = [$key => ['STALE', time() - 10]];
file_put_contents($this->temp_file, json_encode($expired));
MailRecordCache::setInstanceFile($this->temp_file);
$cache = MailRecordCache::getInstance();
$this->assertTrue(
$cache->get(MailRecordCache::TYPE_DKIM, 'old.example')
=== null,
"an expired entry is treated as a miss");
}
/**
* A record stored by one instance is read back by a fresh
* instance loaded from the same file, which is how the cache is
* shared across separate requests and users.
*/
public function persistsAcrossInstancesTestCase()
{
$cache = MailRecordCache::getInstance();
$cache->put(MailRecordCache::TYPE_DKIM, 'shared.example',
'SHAREDKEY', 60);
MailRecordCache::setInstanceFile($this->temp_file);
$fresh = MailRecordCache::getInstance();
$this->assertEqual('SHAREDKEY',
$fresh->get(MailRecordCache::TYPE_DKIM, 'shared.example'),
"a fresh instance loads the record from the file");
}
}
(c) 2026 Seekquarry - Open Source Search Engine Software