<?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\UnitTest;
use seekquarry\yioop\models\MailAccountModel;
use seekquarry\yioop\models\ProfileModel;
use seekquarry\yioop\models\datasources\Sqlite3Manager;
/**
* Tests for MailAccountModel CRUD + user-scoping + the
* leave-password-alone behavior of updateAccount. Each test runs
* against a fresh pair of throwaway sqlite files (one public, one
* private) so the access-control boundary can be exercised with
* multiple distinct USER_IDs.
*
* @author Chris Pollett
*/
class MailAccountModelTest extends UnitTest
{
/**
* Filesystem path for the throwaway public DB
* @var string
*/
public $public_db_path;
/**
* Filesystem path for the throwaway private DB
* @var string
*/
public $private_db_path;
/**
* Model under test
* @var MailAccountModel
*/
public $model;
/**
* Sets up empty public + private DBs and hands them to a fresh
* model instance. Clears any cached master key.
*/
public function setUp()
{
$tag = getmypid() . "_" . random_int(1000, 9999);
$this->public_db_path = C\WORK_DIRECTORY . "/temp/" .
"mail_account_test_public_$tag.db";
$this->private_db_path = C\WORK_DIRECTORY . "/temp/" .
"mail_account_test_private_$tag.db";
$public_db = new Sqlite3Manager();
$public_db->connect("", "", "", $this->public_db_path);
/* Build MAIL_ACCOUNT from ProfileModel's definition, the same one the
live database uses, so this test tracks any schema change rather
than a hand-copied CREATE TABLE that could drift. MAIL_SECRET below
is not a ProfileModel table, so it stays defined here. */
$dbinfo = ["DBMS" => "Sqlite3", "DB_HOST" => ""];
$profile = new ProfileModel(C\DB_NAME, false);
$profile->initializeSql($public_db, $dbinfo);
$public_db->execute($profile->create_statements['MAIL_ACCOUNT']);
$private_db = new Sqlite3Manager();
$private_db->connect("", "", "", $this->private_db_path);
$private_db->execute("CREATE TABLE MAIL_SECRET (" .
"KEY_ID INTEGER PRIMARY KEY, KEY_VALUE VARCHAR(" .
C\MAIL_SECRET_KEY_LEN . "))");
$this->model = new MailAccountModel(C\DB_NAME, false);
$this->model->db = $public_db;
$this->model->private_db = $private_db;
}
/**
* Disconnects + removes the throwaway DBs.
*/
public function tearDown()
{
if ($this->model) {
if ($this->model->db) {
$this->model->db->disconnect();
unset(Sqlite3Manager::$active_connections[
$this->model->db->connect_string]);
}
if ($this->model->private_db) {
$this->model->private_db->disconnect();
unset(Sqlite3Manager::$active_connections[
$this->model->private_db->connect_string]);
}
}
/* Evicting this test's own handles above (keyed by file path)
keeps a reused scratch-file name in a later test from being
handed this test's still-open connection. A plain disconnect
does not evict; shared handles are deliberately left alone. */
foreach ([$this->public_db_path,
$this->private_db_path] as $p) {
if ($p && file_exists($p)) {
unlink($p);
}
}
}
/**
* addAccount inserts a row and returns the new id; the row is
* then retrievable by both the password-free and the
* with-password readers, with the password round-tripping
* cleanly through encryption.
*/
public function addAndReadTestCase()
{
$fields = $this->sampleFields();
$id = $this->model->addAccount(42, $fields);
$this->assertTrue($id > 0, "addAccount returns positive id");
$row = $this->model->getAccount($id, 42);
$this->assertTrue(is_array($row),
"getAccount returns the row");
$this->assertEqual("Personal Gmail", $row['DISPLAY_NAME'],
"DISPLAY_NAME persisted");
$this->assertEqual("imap.gmail.com", $row['HOST'],
"HOST persisted");
$this->assertTrue(!isset($row['PASSWORD']),
"getAccount does not surface PASSWORD");
$with_pw = $this->model->getAccountWithPassword($id, 42);
$this->assertEqual("hunter2", $with_pw['PASSWORD'],
"Password round-trips through encrypt/decrypt");
$this->assertTrue(!isset($with_pw['PASSWORD_NONCE']),
"Nonce stripped from getAccountWithPassword result");
}
/**
* Adding an account with a password makes the model mint and store
* a master key in MAIL_SECRET (KEY_ID = 1, a 32-byte value) the
* first time it needs to encrypt, with the table starting empty.
*/
public function masterKeyPersistenceTestCase()
{
$before = $this->model->private_db->execute(
"SELECT * FROM MAIL_SECRET WHERE KEY_ID = 1");
$row_before = $before ?
$this->model->private_db->fetchArray($before) : false;
$this->assertTrue($row_before === false,
"MAIL_SECRET starts empty");
$this->model->addAccount(42, $this->sampleFields());
$after = $this->model->private_db->execute(
"SELECT * FROM MAIL_SECRET WHERE KEY_ID = 1");
$row_after = $this->model->private_db->fetchArray($after);
$this->assertTrue(is_array($row_after),
"Encrypting an account persists a key row");
$decoded = base64_decode($row_after['KEY_VALUE'], true);
$this->assertEqual(SODIUM_CRYPTO_SECRETBOX_KEYBYTES,
strlen($decoded), "Stored key is the right size");
}
/**
* getAccount must return false when the account_id belongs to a
* different user, even if the id itself exists.
*/
public function userScopingTestCase()
{
$a_id = $this->model->addAccount(1, $this->sampleFields());
$b_id = $this->model->addAccount(2, $this->sampleFields());
$this->assertTrue($this->model->getAccount($a_id, 1) !== false,
"Owner reads own account");
$this->assertEqual(false, $this->model->getAccount($a_id, 2),
"Other user cannot read account A");
$this->assertEqual(false, $this->model->getAccount($b_id, 1),
"User 1 cannot read account B");
}
/**
* getAccountsForUser returns rows in insertion order and does
* not leak rows belonging to other users.
*/
public function listAccountsScopedTestCase()
{
$fields_a = $this->sampleFields();
$fields_a['DISPLAY_NAME'] = "First";
$fields_b = $this->sampleFields();
$fields_b['DISPLAY_NAME'] = "Second";
$fields_c = $this->sampleFields();
$fields_c['DISPLAY_NAME'] = "Other user's";
$this->model->addAccount(1, $fields_a);
sleep(0); // keep CREATED_AT predictable across both rows
$this->model->addAccount(1, $fields_b);
$this->model->addAccount(2, $fields_c);
$rows = $this->model->getAccountsForUser(1);
$this->assertEqual(2, count($rows),
"User 1 sees only their two accounts");
$names = array_map(fn($r) => $r['DISPLAY_NAME'], $rows);
$this->assertTrue(in_array("First", $names),
"User 1's first account is in the list");
$this->assertTrue(in_array("Second", $names),
"User 1's second account is in the list");
$this->assertTrue(!in_array("Other user's", $names),
"User 2's account is NOT in user 1's list");
}
/**
* updateAccount with $leave_password = true preserves the
* stored ciphertext while updating other fields. The password
* round-trips the original value, not the empty string the
* caller passed.
*/
public function updatePreservesPasswordTestCase()
{
$id = $this->model->addAccount(1, $this->sampleFields());
$update = $this->sampleFields();
$update['DISPLAY_NAME'] = "Renamed";
$update['PASSWORD'] = "";
$ok = $this->model->updateAccount($id, 1, $update, true);
$this->assertTrue($ok, "updateAccount returns true on success");
$row = $this->model->getAccount($id, 1);
$this->assertEqual("Renamed", $row['DISPLAY_NAME'],
"DISPLAY_NAME was updated");
$with_pw = $this->model->getAccountWithPassword($id, 1);
$this->assertEqual("hunter2", $with_pw['PASSWORD'],
"Original password still readable after leave_password update");
}
/**
* updateAccount with $leave_password = false re-encrypts and
* stores the new password supplied in $fields.
*/
public function updateReplacesPasswordTestCase()
{
$id = $this->model->addAccount(1, $this->sampleFields());
$update = $this->sampleFields();
$update['PASSWORD'] = "new-password-789";
$this->model->updateAccount($id, 1, $update, false);
$with_pw = $this->model->getAccountWithPassword($id, 1);
$this->assertEqual("new-password-789", $with_pw['PASSWORD'],
"New password is now stored");
}
/**
* updateAccount called with the wrong owner does nothing (returns
* false because the existence check fails first).
*/
public function updateRejectsCrossUserTestCase()
{
$id = $this->model->addAccount(1, $this->sampleFields());
$update = $this->sampleFields();
$update['DISPLAY_NAME'] = "Hijacked";
$ok = $this->model->updateAccount($id, 2, $update, true);
$this->assertEqual(false, $ok,
"updateAccount returns false for non-owner");
$row = $this->model->getAccount($id, 1);
$this->assertEqual("Personal Gmail", $row['DISPLAY_NAME'],
"Row was not touched");
}
/**
* deleteAccount removes a row the user owns; getAccount returns
* false afterward. Cross-user delete is a no-op.
*/
public function deleteAccountTestCase()
{
$id = $this->model->addAccount(1, $this->sampleFields());
$other_id = $this->model->addAccount(2, $this->sampleFields());
$this->model->deleteAccount($id, 1);
$this->assertEqual(false, $this->model->getAccount($id, 1),
"Deleted row no longer exists");
$this->model->deleteAccount($other_id, 1);
$this->assertTrue(
$this->model->getAccount($other_id, 2) !== false,
"Cross-user delete did not touch the row");
}
/**
* The SMTP password round-trips through its own encrypt/decrypt
* pair independently of the IMAP password, the ALLOW_SELF_SIGNED
* flag persists, and updateAccount with $leave_smtp_password
* true keeps the stored SMTP ciphertext while still updating the
* IMAP password when $leave_password is false.
*/
public function smtpFieldsRoundTripTestCase()
{
$id = $this->model->addAccount(7, $this->sampleFields());
$row = $this->model->getAccount($id, 7);
$this->assertEqual(1, (int) $row['ALLOW_SELF_SIGNED'],
"ALLOW_SELF_SIGNED flag persisted");
$this->assertEqual("smtp.example.com", $row['SMTP_HOST'],
"SMTP_HOST persisted");
$with_smtp = $this->model->getAccountWithSmtpPassword($id, 7);
$this->assertEqual("smtp-secret-1", $with_smtp['SMTP_PASSWORD'],
"SMTP password round-trips through encrypt/decrypt");
$this->assertTrue(!isset($with_smtp['SMTP_PASSWORD_NONCE']),
"SMTP nonce stripped from getAccountWithSmtpPassword result");
$update = $this->sampleFields();
$update['PASSWORD'] = "imap-changed";
$update['SMTP_PASSWORD'] = "";
$this->model->updateAccount($id, 7, $update, false, true);
$imap = $this->model->getAccountWithPassword($id, 7);
$this->assertEqual("imap-changed", $imap['PASSWORD'],
"IMAP password updated when leave_password false");
$smtp = $this->model->getAccountWithSmtpPassword($id, 7);
$this->assertEqual("smtp-secret-1", $smtp['SMTP_PASSWORD'],
"SMTP password preserved when leave_smtp_password true");
}
/**
* getAccount() reports whether each section has a stored
* credential via the derived HAS_PASSWORD / HAS_SMTP_PASSWORD
* columns, without surfacing ciphertext. An account created with
* a non-empty IMAP password but an empty SMTP password has
* HAS_PASSWORD = 1 and HAS_SMTP_PASSWORD = 0; the empty SMTP
* password is stored as genuinely empty columns, so
* getAccountWithSmtpPassword yields the empty string. Emptying
* the IMAP password through updateAccount then flips
* HAS_PASSWORD to 0 as well.
*/
public function hasPasswordFlagsTestCase()
{
$fields = $this->sampleFields();
$fields['SMTP_PASSWORD'] = "";
$id = $this->model->addAccount(5, $fields);
$row = $this->model->getAccount($id, 5);
$this->assertEqual(1, (int) $row['HAS_PASSWORD'],
"HAS_PASSWORD is 1 when an IMAP password was stored");
$this->assertEqual(0, (int) $row['HAS_SMTP_PASSWORD'],
"HAS_SMTP_PASSWORD is 0 when the SMTP password was empty");
$this->assertTrue(!isset($row['PASSWORD_CIPHERTEXT']),
"getAccount still does not surface ciphertext columns");
$with_smtp = $this->model->getAccountWithSmtpPassword($id, 5);
$this->assertEqual("", $with_smtp['SMTP_PASSWORD'],
"An empty SMTP password round-trips as the empty string");
$update = $this->sampleFields();
$update['PASSWORD'] = "";
$this->model->updateAccount($id, 5, $update, false, true);
$row2 = $this->model->getAccount($id, 5);
$this->assertEqual(0, (int) $row2['HAS_PASSWORD'],
"Emptying the IMAP password flips HAS_PASSWORD to 0");
$imap = $this->model->getAccountWithPassword($id, 5);
$this->assertEqual("", $imap['PASSWORD'],
"A cleared IMAP password reads back as the empty string");
}
/**
* Helper: returns a fresh sample fields array for addAccount.
*
* @return array
*/
/**
* updateAccountOrder writes each account's position so a later
* getAccountsForUser returns them in the chosen order; ids of
* another user are ignored, and accounts default to creation
* order until reordered.
*/
public function updateAccountOrderTestCase()
{
$fields = $this->sampleFields();
$fields['DISPLAY_NAME'] = 'First';
$first = $this->model->addAccount(7, $fields);
$fields['DISPLAY_NAME'] = 'Second';
$second = $this->model->addAccount(7, $fields);
$fields['DISPLAY_NAME'] = 'Third';
$third = $this->model->addAccount(7, $fields);
/* default order is creation order */
$accounts = $this->model->getAccountsForUser(7);
$this->assertEqual(['First', 'Second', 'Third'],
array_column($accounts, 'DISPLAY_NAME'),
'defaults to creation order before reorder');
/* reorder to Third, First, Second */
$this->model->updateAccountOrder(7,
[$third, $first, $second]);
$accounts = $this->model->getAccountsForUser(7);
$this->assertEqual(['Third', 'First', 'Second'],
array_column($accounts, 'DISPLAY_NAME'),
'getAccountsForUser reflects the new order');
/* an id from another user is ignored, not applied */
$other = $this->model->addAccount(8, $fields);
$this->model->updateAccountOrder(7, [$other, $first]);
$other_rows = $this->model->getAccountsForUser(8);
$this->assertEqual(1, count($other_rows),
"other user's account untouched by cross-user order");
}
/**
* Returns a representative set of account fields for tests.
* @return array field map suitable for addAccount
*/
protected function sampleFields()
{
return [
"DISPLAY_NAME" => "Personal Gmail",
"HOST" => "imap.gmail.com",
"PORT" => 993,
"USERNAME" => "alice@example.com",
"PASSWORD" => "hunter2",
"TLS_MODE" => "imaps",
"DEFAULT_FOLDER" => "INBOX",
"ALLOW_SELF_SIGNED" => 1,
"SMTP_HOST" => "smtp.example.com",
"SMTP_PORT" => 587,
"SMTP_USERNAME" => "alice@example.com",
"SMTP_PASSWORD" => "smtp-secret-1",
"SMTP_TLS_MODE" => "starttls",
];
}
}
(c) 2026 Seekquarry - Open Source Search Engine Software