From 967aebe454ac9ed830fa5980987bcf07e91ca125 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20Molakvo=C3=A6?= <14975046+skjnldsv@users.noreply.github.com> Date: Tue, 17 Nov 2026 16:19:22 +0100 Subject: [PATCH 1/5] fix(migration): keep data entered on 1.0.12 through the upgrade MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The contract step deleted the working weekdays people had set for themselves, so an upgrade from 1.0.12 lost them. They now stay until a new step turns each valid value into a contract period from January 1 of the current year, with a history entry that names the person's own setting as its source, and then deletes the setting for everybody. The table rename copied rows without a transaction and skipped a table whose copy already had rows, so a copy that failed half way was never finished and the next step dropped the old table anyway. Each table is now copied in one transaction, and the old table is only dropped when its copy holds at least as many rows; otherwise the upgrade stops with the old table intact. Assisted-by: ClaudeCode:claude-opus-5-5 Signed-off-by: John Molakvoæ <14975046+skjnldsv@users.noreply.github.com> --- SPECIFICATION.md | 15 +- .../Version1010Date20261023100000.php | 16 +- .../Version1013Date20261111130000.php | 17 +- .../Version1014Date20261111140000.php | 36 +- .../Version1018Date20261117180000.php | 144 ++++++++ tests/Integration/UpgradeKeepsDataTest.php | 307 ++++++++++++++++++ 6 files changed, 512 insertions(+), 23 deletions(-) create mode 100644 lib/Migration/Version1018Date20261117180000.php create mode 100644 tests/Integration/UpgradeKeepsDataTest.php diff --git a/SPECIFICATION.md b/SPECIFICATION.md index 79775d16..d376ea09 100644 --- a/SPECIFICATION.md +++ b/SPECIFICATION.md @@ -873,6 +873,14 @@ and to the admin audit log; the region code people set themselves (§7.2) goes t same history. The weekdays drive the working-days prefill (§7.1); the percentage is not used for leave yet. +Before HR kept contracts, people set their own working weekdays. The upgrade +(`Version1018…`) turns a valid setting into a period for everyone who has none yet: +`valid_from` is January 1 of the current year (server date), since the setting has +no date and the year's leave is still being counted; the percentage stays empty. The +history entry has no author and `"source": "own_setting"` in its detail. The setting +is then deleted for everybody; an invalid one is dropped. HR corrects the date where +it is wrong. + The annual allowance is **not** derived from the contract: HR sets each person's days for the year (`absence_entitlements`, §5.5). The same percentage can mean shorter days on all five weekdays, with the full allowance, or fewer weekdays with fewer days, and @@ -2151,9 +2159,14 @@ Recorded during the build so the spec matches the code: prefill reads the list. - **Contract data and a profile page** (§6.4, §15.2): HR enters start and end dates and the working pattern from a date on; the prefill reads those weekdays instead of the - ones people set for themselves, which are dropped (`Version1010…`, app 1.2.0). The + ones people set for themselves, which become a contract period on the upgrade + (`Version1018…`, §6.4) and are then deleted. The personal section on the Availability page is gone: the region code moved to the profile page. +- **Shorter table names** (`Version1013…`, `Version1014…`): three tables were renamed + for Oracle's 30-character limit. Each is copied in one transaction, and the old table + is only dropped when the new one holds at least as many rows; otherwise the upgrade + stops with the old table intact. - **HR → Employees** (§13, §15.2): the *Balances* page became a list of every employee with their region code, contract, manager and the year's days, flagging missing data, from one HR-only endpoint (`GET /api/employees`) that costs a fixed number of diff --git a/lib/Migration/Version1010Date20261023100000.php b/lib/Migration/Version1010Date20261023100000.php index b761b0dc..4bb256c8 100644 --- a/lib/Migration/Version1010Date20261023100000.php +++ b/lib/Migration/Version1010Date20261023100000.php @@ -10,8 +10,6 @@ namespace OCA\Absence\Migration; use Closure; -use OCA\Absence\AppInfo\Application; -use OCP\Config\IUserConfig; use OCP\DB\ISchemaWrapper; use OCP\DB\Types; use OCP\Migration\IOutput; @@ -20,15 +18,10 @@ /** * Contract data HR keeps per employee (§6.4): start and end date, the working * weekdays and contract percentage from a date on, and the history of changes. - * The weekdays people set for themselves for the prefill are dropped: HR owns - * them now. + * The weekdays people set for themselves stay until `Version1018…` turns them + * into contract periods, once the tables have their final names. */ class Version1010Date20261023100000 extends SimpleMigrationStep { - public function __construct( - private IUserConfig $userConfig, - ) { - } - #[\Override] public function changeSchema(IOutput $output, Closure $schemaClosure, array $options): ?ISchemaWrapper { /** @var ISchemaWrapper $schema */ @@ -71,9 +64,4 @@ public function changeSchema(IOutput $output, Closure $schemaClosure, array $opt } return $changed ? $schema : null; } - - #[\Override] - public function postSchemaChange(IOutput $output, Closure $schemaClosure, array $options): void { - $this->userConfig->deleteKey(Application::APP_ID, 'work_weekdays'); - } } diff --git a/lib/Migration/Version1013Date20261111130000.php b/lib/Migration/Version1013Date20261111130000.php index 60c7066d..31af1198 100644 --- a/lib/Migration/Version1013Date20261111130000.php +++ b/lib/Migration/Version1013Date20261111130000.php @@ -23,7 +23,9 @@ * `_seq`, a table name over 23 characters gets a sequence the server cannot * find again, so nothing could be inserted there. * - * The rows are copied here, and the next step drops the old tables. + * The rows are copied here, and the next step drops the old tables. Each table + * is copied in one transaction: a copy that fails leaves the new table empty, so + * running the upgrade again copies it from the start. */ class Version1013Date20261111130000 extends SimpleMigrationStep { /** Old name, new name and the columns to copy (every one but the id) */ @@ -100,9 +102,18 @@ public function postSchemaChange(IOutput $output, Closure $schemaClosure, array /** @var ISchemaWrapper $schema */ $schema = $schemaClosure(); foreach (self::RENAMED as [$old, $new, $columns]) { - if ($schema->hasTable($old) && $this->isEmpty($new)) { - $output->info(sprintf('Copied %d rows from %s to %s', $this->copy($old, $new, $columns), $old, $new)); + if (!$schema->hasTable($old) || !$this->isEmpty($new)) { + continue; } + $this->db->beginTransaction(); + try { + $copied = $this->copy($old, $new, $columns); + $this->db->commit(); + } catch (\Throwable $e) { + $this->db->rollBack(); + throw $e; + } + $output->info(sprintf('Copied %d rows from %s to %s', $copied, $old, $new)); } } diff --git a/lib/Migration/Version1014Date20261111140000.php b/lib/Migration/Version1014Date20261111140000.php index 0dc1f9ad..d199157e 100644 --- a/lib/Migration/Version1014Date20261111140000.php +++ b/lib/Migration/Version1014Date20261111140000.php @@ -11,25 +11,51 @@ use Closure; use OCP\DB\ISchemaWrapper; +use OCP\IDBConnection; use OCP\Migration\IOutput; use OCP\Migration\SimpleMigrationStep; /** - * Drops the three tables the previous step copied to their shorter names. + * Drops the three tables the previous step copied to their shorter names. A + * table is only dropped when its new copy holds at least as many rows; + * otherwise the upgrade stops and the old table keeps its rows. */ class Version1014Date20261111140000 extends SimpleMigrationStep { + public function __construct( + private IDBConnection $db, + ) { + } + #[\Override] public function changeSchema(IOutput $output, Closure $schemaClosure, array $options): ?ISchemaWrapper { /** @var ISchemaWrapper $schema */ $schema = $schemaClosure(); $changed = false; - foreach (Version1013Date20261111130000::RENAMED as [$old]) { - if ($schema->hasTable($old)) { - $schema->dropTable($old); - $changed = true; + foreach (Version1013Date20261111130000::RENAMED as [$old, $new]) { + if (!$schema->hasTable($old)) { + continue; + } + // A new install reads every step before writing any table: nothing to count + $oldRows = $this->db->tableExists($old) ? $this->rows($old) : 0; + $newRows = $this->db->tableExists($new) ? $this->rows($new) : 0; + if ($newRows < $oldRows) { + throw new \RuntimeException(sprintf( + 'Table %s holds %d rows but its copy %s only %d: not all rows were copied, so it is not dropped.', + $old, $oldRows, $new, $newRows, + )); } + $schema->dropTable($old); + $changed = true; } return $changed ? $schema : null; } + + private function rows(string $table): int { + $qb = $this->db->getQueryBuilder(); + $result = $qb->select($qb->func()->count('*'))->from($table)->executeQuery(); + $rows = (int)$result->fetchOne(); + $result->closeCursor(); + return $rows; + } } diff --git a/lib/Migration/Version1018Date20261117180000.php b/lib/Migration/Version1018Date20261117180000.php new file mode 100644 index 00000000..c23f7a4e --- /dev/null +++ b/lib/Migration/Version1018Date20261117180000.php @@ -0,0 +1,144 @@ + null, 'end' => null, 'periods' => []]; + + public function __construct( + private IDBConnection $db, + private IUserConfig $userConfig, + private ClockService $clock, + ) { + } + + #[\Override] + public function postSchemaChange(IOutput $output, Closure $schemaClosure, array $options): void { + $values = $this->userConfig->getValuesByUsers(Application::APP_ID, self::KEY, ValueType::STRING); + if ($values === []) { + return; + } + + $from = $this->clock->serverYear() . '-01-01'; + $converted = 0; + foreach (array_chunk($values, self::CHUNK, true) as $chunk) { + $weekdays = []; + foreach ($chunk as $uid => $value) { + $days = is_string($value) ? self::parse($value) : null; + if ($days !== null) { + $weekdays[(string)$uid] = $days; + } + } + $weekdays = array_diff_key($weekdays, array_flip($this->withPeriods(array_map(strval(...), array_keys($weekdays))))); + $converted += $this->convert($weekdays, $from); + } + $this->userConfig->deleteKey(Application::APP_ID, self::KEY); + $output->info(sprintf('Turned the own working weekdays of %d people into contract periods', $converted)); + } + + /** + * Comma separated ISO weekdays, at least one and each once, sorted. + * + * @return list|null + */ + private static function parse(string $value): ?array { + if (!preg_match('/^[1-7](,[1-7])*$/', $value)) { + return null; + } + $days = array_map(intval(...), explode(',', $value)); + if (count(array_unique($days)) !== count($days)) { + return null; + } + sort($days); + return $days; + } + + /** + * @param list $uids + * @return list the uids that already have a contract period + */ + private function withPeriods(array $uids): array { + if ($uids === []) { + return []; + } + $qb = $this->db->getQueryBuilder(); + $qb->selectDistinct('employee_uid') + ->from('absence_periods') + ->where($qb->expr()->in('employee_uid', $qb->createNamedParameter($uids, IQueryBuilder::PARAM_STR_ARRAY))); + $result = $qb->executeQuery(); + $found = array_map(strval(...), $result->fetchFirstColumn()); + $result->closeCursor(); + return $found; + } + + /** + * One period and one history entry per person, written together. + * + * @param array> $weekdays + */ + private function convert(array $weekdays, string $from): int { + if ($weekdays === []) { + return 0; + } + $now = $this->clock->now(); + $this->db->beginTransaction(); + try { + foreach ($weekdays as $uid => $days) { + $uid = (string)$uid; + $period = $this->db->getQueryBuilder(); + $period->insert('absence_periods')->values([ + 'employee_uid' => $period->createNamedParameter($uid), + 'valid_from' => $period->createNamedParameter($from), + 'weekdays' => $period->createNamedParameter(implode(',', $days)), + 'percent' => $period->createNamedParameter(null, IQueryBuilder::PARAM_NULL), + ])->executeStatement(); + + $after = self::NO_CONTRACT; + $after['periods'] = [['from' => $from, 'weekdays' => $days, 'percent' => null]]; + $history = $this->db->getQueryBuilder(); + $history->insert('absence_emp_history')->values([ + 'employee_uid' => $history->createNamedParameter($uid), + 'actor_uid' => $history->createNamedParameter(null, IQueryBuilder::PARAM_NULL), + 'field' => $history->createNamedParameter(EmployeeChange::CONTRACT), + 'detail' => $history->createNamedParameter(json_encode(['before' => self::NO_CONTRACT, 'after' => $after, 'source' => 'own_setting'], JSON_THROW_ON_ERROR)), + 'created_at' => $history->createNamedParameter($now, IQueryBuilder::PARAM_DATETIME_MUTABLE), + ])->executeStatement(); + } + $this->db->commit(); + } catch (\Throwable $e) { + $this->db->rollBack(); + throw $e; + } + return count($weekdays); + } +} diff --git a/tests/Integration/UpgradeKeepsDataTest.php b/tests/Integration/UpgradeKeepsDataTest.php new file mode 100644 index 00000000..365ce957 --- /dev/null +++ b/tests/Integration/UpgradeKeepsDataTest.php @@ -0,0 +1,307 @@ +db = Server::get(Connection::class); + $this->userConfig = Server::get(IUserConfig::class); + $this->cleanUp(); + } + + protected function tearDown(): void { + $this->cleanUp(); + parent::tearDown(); + } + + public function testOwnWeekdaysBecomeAContract(): void { + $alice = self::PREFIX . 'alice'; + $bob = self::PREFIX . 'bob'; + $numeric = '90817'; + $grace = self::PREFIX . 'grace'; + $invalid = [ + self::PREFIX . 'charlie' => '1,8', + self::PREFIX . 'dave' => '2,2,3', + self::PREFIX . 'erin' => '', + self::PREFIX . 'frank' => 'mon,tue', + ]; + $prefs = [$alice => '1,2,3,4,5', $bob => '5,1,3', $numeric => '2,4', $grace => '3,4'] + $invalid; + foreach ($prefs as $uid => $value) { + $this->userConfig->setValueString((string)$uid, ConfigService::APP_ID, self::KEY, $value); + } + $this->insert('absence_periods', ['employee_uid' => $grace, 'valid_from' => '2020-03-01', 'weekdays' => '1,2', 'percent' => null]); + + $this->runPostSchemaChange(Server::get(Version1018Date20261117180000::class)); + + $from = Server::get(ClockService::class)->serverYear() . '-01-01'; + $periods = Server::get(ContractPeriodMapper::class); + $describe = static fn (string $uid): array => array_map( + static fn ($period): array => [$period->getValidFrom(), $period->getWeekdays(), $period->getPercent()], + $periods->findForEmployee($uid), + ); + self::assertSame([[$from, '1,2,3,4,5', null]], $describe($alice)); + self::assertSame([[$from, '1,3,5', null]], $describe($bob)); + self::assertSame([[$from, '2,4', null]], $describe($numeric)); + self::assertSame([['2020-03-01', '1,2', null]], $describe($grace)); + foreach (array_keys($invalid) as $uid) { + self::assertSame([], $describe($uid), $uid); + } + + $history = Server::get(EmployeeService::class)->history($bob); + self::assertCount(1, $history); + self::assertSame(['contract', null], [$history[0]['field'], $history[0]['actor']]); + self::assertSame(['start' => null, 'end' => null, 'periods' => []], $history[0]['before']); + self::assertSame(['start' => null, 'end' => null, 'periods' => [['from' => $from, 'weekdays' => [1, 3, 5], 'percent' => null]]], $history[0]['after']); + self::assertSame('own_setting', json_decode($this->historyDetails($bob)[0], true)['source']); + self::assertCount(1, $this->historyDetails($alice)); + self::assertCount(1, $this->historyDetails($numeric)); + self::assertSame([], $this->historyDetails($grace)); + foreach (array_keys($invalid) as $uid) { + self::assertSame([], $this->historyDetails($uid), $uid); + } + self::assertSame([], $this->prefs()); + + $before = [$this->rows('absence_periods'), $this->rows('absence_emp_history')]; + $this->runPostSchemaChange(Server::get(Version1018Date20261117180000::class)); + self::assertSame($before, [$this->rows('absence_periods'), $this->rows('absence_emp_history')]); + } + + public function testTheContractStepKeepsOwnWeekdays(): void { + $this->userConfig->setValueString(self::PREFIX . 'alice', ConfigService::APP_ID, self::KEY, '1,2,3'); + + $this->runPostSchemaChange(Server::get(Version1010Date20261023100000::class)); + + self::assertSame([self::PREFIX . 'alice' => '1,2,3'], $this->prefs()); + } + + public function testACopyThatFailsLeavesTheNewTableEmpty(): void { + self::assertSame(0, $this->rows(self::NEW_EVENTS), 'The test needs an empty ' . self::NEW_EVENTS); + // `field` may be null here, so the second row cannot go into the new table + $this->createOldEvents(fieldNullable: true); + $this->insertOldEvents(['base_days', null, 'manual_adjustment']); + + $migration = Server::get(Version1013Date20261111130000::class); + $error = null; + try { + $this->runPostSchemaChange($migration); + } catch (\Throwable $e) { + $error = $e; + } + self::assertNotNull($error, 'The copy did not fail'); + self::assertSame(0, $this->rows(self::NEW_EVENTS)); + + $qb = $this->db->getQueryBuilder(); + $qb->update(self::OLD_EVENTS) + ->set('field', $qb->createNamedParameter('carry_over_days')) + ->where($qb->expr()->isNull('field')) + ->executeStatement(); + $this->runPostSchemaChange($migration); + self::assertSame(3, $this->rows(self::NEW_EVENTS)); + } + + public function testOldTableStaysWhenTheNewOneHasFewerRows(): void { + self::assertSame(0, $this->rows(self::NEW_EVENTS), 'The test needs an empty ' . self::NEW_EVENTS); + $this->createOldEvents(); + $this->insertOldEvents(['base_days', 'carry_over_days', 'manual_adjustment']); + $this->insertNewEvent(); + + $error = null; + try { + $this->runChangeSchema(Server::get(Version1014Date20261111140000::class)); + } catch (\RuntimeException $e) { + $error = $e; + } + self::assertNotNull($error, 'The old table was dropped'); + self::assertMatchesRegularExpression('/absence_entitlement_events\\D+3\\D+absence_ent_events\\D+1\\D/', $error->getMessage()); + self::assertTrue($this->db->tableExists(self::OLD_EVENTS)); + self::assertSame(3, $this->rows(self::OLD_EVENTS)); + } + + public function testOldTableIsDroppedOnceEveryRowIsCopied(): void { + self::assertSame(0, $this->rows(self::NEW_EVENTS), 'The test needs an empty ' . self::NEW_EVENTS); + $this->createOldEvents(); + $this->insertOldEvents(['base_days']); + $this->insertNewEvent(); + + $this->runChangeSchema(Server::get(Version1014Date20261111140000::class)); + + self::assertFalse($this->db->tableExists(self::OLD_EVENTS)); + } + + public function testAFreshInstallDropsTheOldTablesWithoutCounting(): void { + // A new install reads every step's schema change before writing any table + $schema = new SchemaWrapper($this->db); + $schema->createTable(self::OLD_EVENTS)->addColumn('id', Types::BIGINT, ['autoincrement' => true, 'notnull' => true]); + + $result = Server::get(Version1014Date20261111140000::class) + ->changeSchema($this->createMock(IOutput::class), static fn (): ISchemaWrapper => $schema, []); + + self::assertFalse($result?->hasTable(self::OLD_EVENTS)); + } + + private function runPostSchemaChange(\OCP\Migration\IMigrationStep $migration): void { + $migration->postSchemaChange($this->createMock(IOutput::class), fn (): ISchemaWrapper => new SchemaWrapper($this->db), []); + } + + private function runChangeSchema(\OCP\Migration\IMigrationStep $migration): void { + $schema = $migration->changeSchema($this->createMock(IOutput::class), fn (): ISchemaWrapper => new SchemaWrapper($this->db), []); + if ($schema instanceof SchemaWrapper) { + $this->db->migrateToSchema($schema->getWrappedSchema()); + $schema->performDropTableCalls(); + } + } + + /** + * The entitlement history table as 1.0.12 created it. + */ + private function createOldEvents(bool $fieldNullable = false): void { + $schema = new SchemaWrapper($this->db); + $table = $schema->createTable(self::OLD_EVENTS); + $table->addColumn('id', Types::BIGINT, ['autoincrement' => true, 'notnull' => true]); + $table->addColumn('entitlement_id', Types::BIGINT, ['notnull' => true]); + $table->addColumn('employee_uid', Types::STRING, ['notnull' => true, 'length' => 64]); + $table->addColumn('actor_uid', Types::STRING, ['notnull' => true, 'length' => 64]); + $table->addColumn('field', Types::STRING, ['notnull' => !$fieldNullable, 'length' => 32]); + $table->addColumn('old_value', Types::FLOAT, ['notnull' => true, 'default' => 0]); + $table->addColumn('new_value', Types::FLOAT, ['notnull' => true, 'default' => 0]); + $table->addColumn('note', Types::TEXT, ['notnull' => false]); + $table->addColumn('created_at', Types::DATETIME, ['notnull' => true]); + $table->setPrimaryKey(['id']); + $table->addIndex(['entitlement_id'], 'absence_entev_ent'); + $table->addIndex(['employee_uid'], 'absence_entev_emp'); + $this->db->migrateToSchema($schema->getWrappedSchema()); + } + + /** + * @param list $fields + */ + private function insertOldEvents(array $fields): void { + foreach ($fields as $i => $field) { + $this->insert(self::OLD_EVENTS, [ + 'entitlement_id' => 990001, + 'employee_uid' => self::PREFIX . 'alice', + 'actor_uid' => self::PREFIX . 'hr', + 'field' => $field, + 'old_value' => (string)$i, + 'new_value' => (string)($i + 1), + 'note' => null, + 'created_at' => '2026-08-20 10:00:00', + ]); + } + } + + private function insertNewEvent(): void { + $this->insert(self::NEW_EVENTS, [ + 'entitlement_id' => 990001, + 'employee_uid' => self::PREFIX . 'alice', + 'actor_uid' => self::PREFIX . 'hr', + 'field' => 'base_days', + 'old_value' => '0', + 'new_value' => '1', + 'note' => null, + 'created_at' => '2026-08-20 10:00:00', + ]); + } + + /** + * @param array $values + */ + private function insert(string $table, array $values): void { + $qb = $this->db->getQueryBuilder(); + $qb->insert($table); + foreach ($values as $column => $value) { + $qb->setValue($column, $value === null + ? $qb->createNamedParameter(null, IQueryBuilder::PARAM_NULL) + : $qb->createNamedParameter((string)$value)); + } + $qb->executeStatement(); + } + + private function rows(string $table): int { + $qb = $this->db->getQueryBuilder(); + $result = $qb->select($qb->func()->count('*'))->from($table)->executeQuery(); + $count = (int)$result->fetchOne(); + $result->closeCursor(); + return $count; + } + + /** + * @return list + */ + private function historyDetails(string $uid): array { + $qb = $this->db->getQueryBuilder(); + $result = $qb->select('detail') + ->from('absence_emp_history') + ->where($qb->expr()->eq('employee_uid', $qb->createNamedParameter($uid))) + ->executeQuery(); + $details = $result->fetchFirstColumn(); + $result->closeCursor(); + return $details; + } + + /** + * @return array + */ + private function prefs(): array { + $prefs = []; + foreach ($this->userConfig->getValuesByUsers(ConfigService::APP_ID, self::KEY) as $uid => $value) { + $prefs[(string)$uid] = $value; + } + return $prefs; + } + + private function cleanUp(): void { + $this->userConfig->deleteKey(ConfigService::APP_ID, self::KEY); + foreach (['absence_periods', 'absence_emp_history', self::NEW_EVENTS] as $table) { + $qb = $this->db->getQueryBuilder(); + $qb->delete($table) + ->where($qb->expr()->orX( + $qb->expr()->like('employee_uid', $qb->createNamedParameter(self::PREFIX . '%')), + $qb->expr()->eq('employee_uid', $qb->createNamedParameter('90817')), + )) + ->executeStatement(); + } + if ($this->db->tableExists(self::OLD_EVENTS)) { + $this->db->dropTable(self::OLD_EVENTS); + } + } +} From 2be57055acada5d47aa64826a77b3077511fb2a8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20Molakvo=C3=A6?= <14975046+skjnldsv@users.noreply.github.com> Date: Tue, 17 Nov 2026 16:22:32 +0100 Subject: [PATCH 2/5] test(migration): upgrade a seeded 1.0.12 install and check every row MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit HR used Absence 1.0.12 before the betas. A new workflow installs that version on SQLite, MySQL and PostgreSQL, enters invented data the way 1.0.12 stored it (requests with half days, entitlements and their history, comments on a confidential absence, an attachment file, own weekdays, regions and settings), upgrades to the pull request's code with `occ upgrade` and compares what is stored before and after. Assisted-by: ClaudeCode:claude-opus-5-5 Signed-off-by: John Molakvoæ <14975046+skjnldsv@users.noreply.github.com> --- .github/workflows/upgrade-from-1.0.12.yml | 144 +++++++++ tests/Upgrade/upgrade-check.php | 344 ++++++++++++++++++++++ 2 files changed, 488 insertions(+) create mode 100644 .github/workflows/upgrade-from-1.0.12.yml create mode 100644 tests/Upgrade/upgrade-check.php diff --git a/.github/workflows/upgrade-from-1.0.12.yml b/.github/workflows/upgrade-from-1.0.12.yml new file mode 100644 index 00000000..bd00768a --- /dev/null +++ b/.github/workflows/upgrade-from-1.0.12.yml @@ -0,0 +1,144 @@ +# SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors +# SPDX-License-Identifier: AGPL-3.0-or-later +# +# HR used Absence 1.0.12 (commit 0d84f4d) before the betas. This installs that +# version, fills it with invented data, upgrades to the code of the pull request +# with `occ upgrade` and checks that everything entered is still there. + +name: Upgrade from 1.0.12 + +on: pull_request + +permissions: + contents: read + +concurrency: + group: upgrade-from-1012-${{ github.head_ref || github.run_id }} + cancel-in-progress: true + +jobs: + changes-and-matrix: + runs-on: ubuntu-latest-low + permissions: + contents: read + pull-requests: read + + outputs: + src: ${{ steps.changes.outputs.src }} + php-min: ${{ steps.versions.outputs.php-min }} + server-min: ${{ steps.versions.outputs.branches-min }} + + steps: + - uses: dorny/paths-filter@ceb8a2b8f2d89434be7ff52d3de7ec3738c5cc9d # v4.0.3 + id: changes + continue-on-error: true + with: + filters: | + src: + - '.github/workflows/upgrade-from-1.0.12.yml' + - 'appinfo/**' + - 'lib/**' + - 'tests/Upgrade/**' + + - name: Checkout app + if: steps.changes.outputs.src != 'false' + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + + - name: Get version matrix + if: steps.changes.outputs.src != 'false' + id: versions + uses: nextcloud-libraries/nextcloud-version-matrix@71959de73c244b11ecbf4503b87c41d65b0f64ae # v1.3.4 + + upgrade: + runs-on: ubuntu-latest + + needs: changes-and-matrix + if: needs.changes-and-matrix.outputs.src != 'false' + + strategy: + fail-fast: false + matrix: + database: ['sqlite', 'mysql', 'pgsql'] + + name: Upgrade from 1.0.12 on ${{ matrix.database }} + + services: + mysql: + image: ghcr.io/nextcloud/continuous-integration-mysql-8.4:latest # zizmor: ignore[unpinned-images] + ports: + - 4444:3306/tcp + env: + MYSQL_ROOT_PASSWORD: rootpassword + options: --health-cmd="mysqladmin ping" --health-interval 5s --health-timeout 2s --health-retries 10 + postgres: + image: ghcr.io/nextcloud/continuous-integration-postgres-16:latest # zizmor: ignore[unpinned-images] + ports: + - 4445:5432/tcp + env: + POSTGRES_USER: root + POSTGRES_PASSWORD: rootpassword + POSTGRES_DB: nextcloud + options: --health-cmd pg_isready --health-interval 5s --health-timeout 2s --health-retries 5 + + steps: + - name: Checkout server + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + submodules: true + repository: nextcloud/server + ref: ${{ needs.changes-and-matrix.outputs.server-min }} + + - name: Checkout Absence 1.0.12 + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + ref: 0d84f4da14aea8564ba666d3cfd31f60123302bc + path: apps/absence + + - name: Checkout the code to upgrade to + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + path: new-absence + + - name: Set up php ${{ needs.changes-and-matrix.outputs.php-min }} + uses: shivammathur/setup-php@eb7c497e18156a6bbabfef1d3a82760b9eda3962 # 2.40.0 + with: + php-version: ${{ needs.changes-and-matrix.outputs.php-min }} + extensions: bz2, ctype, curl, dom, fileinfo, gd, iconv, intl, json, libxml, mbstring, openssl, pcntl, posix, session, simplexml, xmlreader, xmlwriter, zip, zlib, sqlite, pdo_sqlite, mysql, pdo_mysql, pgsql, pdo_pgsql + coverage: none + ini-file: development + ini-values: disable_functions= + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + + - name: Install Nextcloud with Absence 1.0.12 + env: + DATABASE: ${{ matrix.database }} + run: | + mkdir data + case "$DATABASE" in + sqlite) ./occ maintenance:install --verbose --database=sqlite --admin-user admin --admin-pass admin ;; + mysql) ./occ maintenance:install --verbose --database=mysql --database-name=nextcloud --database-host=127.0.0.1 --database-port=4444 --database-user=root --database-pass=rootpassword --admin-user admin --admin-pass admin ;; + pgsql) ./occ maintenance:install --verbose --database=pgsql --database-name=nextcloud --database-host=127.0.0.1 --database-port=4445 --database-user=root --database-pass=rootpassword --admin-user admin --admin-pass admin ;; + esac + ./occ app:enable --force absence + ./occ config:app:get absence installed_version + + - name: Enter invented data on 1.0.12 + run: | + php new-absence/tests/Upgrade/upgrade-check.php "$PWD" seed + php new-absence/tests/Upgrade/upgrade-check.php "$PWD" snapshot before.json + + - name: Upgrade to the new code + run: | + rm -rf apps/absence + mv new-absence apps/absence + ./occ upgrade + ./occ config:app:get absence installed_version + + - name: Check the data + run: php apps/absence/tests/Upgrade/upgrade-check.php "$PWD" verify before.json diff --git a/tests/Upgrade/upgrade-check.php b/tests/Upgrade/upgrade-check.php new file mode 100644 index 00000000..6acc1cd2 --- /dev/null +++ b/tests/Upgrade/upgrade-check.php @@ -0,0 +1,344 @@ + seed on 1.0.12: invented data + * php upgrade-check.php snapshot write what is stored + * php upgrade-check.php verify after `occ upgrade` + * + * It uses OCP and plain queries only, never the app's own classes, so the + * same file runs against both versions. Every person and value is invented. + */ + +use OCP\Config\IUserConfig; +use OCP\DB\QueryBuilder\IQueryBuilder; +use OCP\Files\AppData\IAppDataFactory; +use OCP\Files\NotFoundException; +use OCP\IAppConfig; +use OCP\IDBConnection; +use OCP\IGroupManager; +use OCP\IUserManager; +use OCP\Server; + +if ($argc < 3) { + fwrite(STDERR, "usage: upgrade-check.php seed|snapshot |verify \n"); + exit(2); +} +[, $serverRoot, $mode] = $argv; +$file = $argv[3] ?? null; +require rtrim($serverRoot, '/') . '/lib/base.php'; + +const APP = 'absence'; +const USERS = ['upgrade-alice', 'upgrade-bob', 'upgrade-carol', 'upgrade-dave', 'upgrade-hr']; + +/** Weekdays people set for themselves on 1.0.12, and the contract each must become */ +const WEEKDAYS = [ + 'upgrade-alice' => ['1,2,3,4,5', '1,2,3,4,5'], + 'upgrade-bob' => ['1,2,3,4', '1,2,3,4'], + 'upgrade-carol' => ['5,1,3', '1,3,5'], + 'upgrade-dave' => ['every day', null], +]; + +$db = Server::get(IDBConnection::class); + +if ($mode === 'seed') { + seed($db); +} elseif ($mode === 'snapshot' && $file !== null) { + file_put_contents($file, json_encode(snapshot($db), JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR)); +} elseif ($mode === 'verify' && $file !== null) { + exit(verify($db, json_decode((string)file_get_contents($file), true, flags: JSON_THROW_ON_ERROR))); +} else { + exit(2); +} + +function seed(IDBConnection $db): void { + $users = Server::get(IUserManager::class); + foreach (USERS as $uid) { + $users->get($uid) ?? $users->createUser($uid, bin2hex(random_bytes(16)) . 'Aa1!'); + } + $groups = Server::get(IGroupManager::class); + // The HR group of 1.0.12's default; the setting itself is never stored + ($groups->get('hr') ?? $groups->createGroup('hr'))->addUser($users->get('upgrade-hr')); + foreach (['upgrade-alice', 'upgrade-bob', 'upgrade-carol'] as $uid) { + $users->get($uid)->setManagerUids(['upgrade-dave']); + } + + $config = Server::get(IUserConfig::class); + foreach (WEEKDAYS as $uid => [$stored]) { + $config->setValueString($uid, APP, 'work_weekdays', $stored); + } + $config->setValueString('upgrade-alice', APP, 'holiday_country', 'DE'); + $config->setValueString('upgrade-alice', APP, 'holiday_region', 'BY'); + $config->setValueString('upgrade-bob', APP, 'holiday_country', 'FR'); + + $appConfig = Server::get(IAppConfig::class); + $appConfig->setValueFloat(APP, 'default_entitlement', 28.0); + $appConfig->setValueInt(APP, 'max_concurrent_absences', 3); + $appConfig->setValueString(APP, 'carryover_expiry', '03-31', lazy: true); + + $types = typeIds($db); + insert($db, 'absence_leave_types', [ + 'key' => 'training', 'label' => 'Training', 'color' => '#4271a6', 'icon' => '📚', + 'counts_against_balance' => [false, IQueryBuilder::PARAM_BOOL], 'requires_approval' => [true, IQueryBuilder::PARAM_BOOL], + 'requires_note' => [true, IQueryBuilder::PARAM_BOOL], 'requires_replacement' => [false, IQueryBuilder::PARAM_BOOL], + 'employee_requestable' => [true, IQueryBuilder::PARAM_BOOL], 'enabled' => [true, IQueryBuilder::PARAM_BOOL], + 'hr_only' => [false, IQueryBuilder::PARAM_BOOL], 'sort_order' => 20, + ]); + $update = $db->getQueryBuilder(); + $update->update('absence_leave_types')->set('enabled', $update->createNamedParameter(false, IQueryBuilder::PARAM_BOOL)) + ->where($update->expr()->eq('key', $update->createNamedParameter('special')))->executeStatement(); + + $requests = [ + ['upgrade-alice', 'annual', '2026-02-16', '2026-02-20', '5', 'APPROVED', 'Ski week', 'upgrade-bob', 'upgrade-dave', false], + ['upgrade-alice', 'annual', '2026-08-03', '2026-08-04', '1.5', 'APPROVED', null, 'upgrade-bob', 'upgrade-dave', false], + ['upgrade-bob', 'sick', '2026-03-02', '2026-03-03', '2', 'APPROVED', null, null, 'upgrade-hr', true], + ['upgrade-carol', 'maternity', '2026-04-01', '2026-06-30', '60', 'APPROVED', 'Invented confidential note', null, 'upgrade-hr', false], + ['upgrade-bob', 'annual', '2026-12-21', '2026-12-23', '3', 'PENDING', null, 'upgrade-alice', null, false], + ['upgrade-carol', 'annual', '2025-12-29', '2026-01-02', '4', 'APPROVED', null, 'upgrade-alice', 'upgrade-dave', false], + ['upgrade-alice', 'unpaid', '2026-05-04', '2026-05-04', '0.5', 'CANCELLED', 'Invented reason', null, null, false], + ]; + $ids = []; + foreach ($requests as [$uid, $type, $from, $to, $days, $status, $reason, $replacement, $decidedBy, $disability]) { + $ids[] = insert($db, 'absence_requests', [ + 'employee_uid' => $uid, 'manager_uid' => 'upgrade-dave', 'type_id' => [$types[$type], IQueryBuilder::PARAM_INT], + 'start_date' => [new DateTime($from), IQueryBuilder::PARAM_DATE], 'end_date' => [new DateTime($to), IQueryBuilder::PARAM_DATE], + 'working_days' => $days, 'status' => $status, 'reason' => $reason, 'replacement_uid' => $replacement, + 'decided_by' => $decidedBy, 'decided_at' => [$decidedBy === null ? null : new DateTime('2026-01-10 09:00:00'), $decidedBy === null ? IQueryBuilder::PARAM_NULL : IQueryBuilder::PARAM_DATETIME_MUTABLE], + 'escalated' => [false, IQueryBuilder::PARAM_BOOL], 'disability' => [$disability, IQueryBuilder::PARAM_BOOL], + 'created_at' => [new DateTime('2026-01-05 08:00:00'), IQueryBuilder::PARAM_DATETIME_MUTABLE], + 'updated_at' => [new DateTime('2026-01-10 09:00:00'), IQueryBuilder::PARAM_DATETIME_MUTABLE], + ]); + } + + foreach ([ + [$ids[0], 'upgrade-dave', 'Enjoy the snow.'], + [$ids[3], 'upgrade-hr', 'Invented HR-only remark.'], + [$ids[4], 'upgrade-bob', 'Back on the 28th.'], + ] as [$request, $author, $body]) { + insert($db, 'absence_comments', ['request_id' => [$request, IQueryBuilder::PARAM_INT], 'author_uid' => $author, 'body' => $body, + 'created_at' => [new DateTime('2026-01-06 10:00:00'), IQueryBuilder::PARAM_DATETIME_MUTABLE]]); + } + foreach ([[$ids[0], 'upgrade-alice', 'created'], [$ids[0], 'upgrade-dave', 'approved'], [$ids[3], 'upgrade-hr', 'created']] as [$request, $actor, $event]) { + insert($db, 'absence_request_events', ['request_id' => [$request, IQueryBuilder::PARAM_INT], 'actor_uid' => $actor, 'event_type' => $event, + 'detail' => null, 'created_at' => [new DateTime('2026-01-05 08:00:00'), IQueryBuilder::PARAM_DATETIME_MUTABLE]]); + } + + $entitlements = [ + ['upgrade-alice', 2026, '28', '5', '-1.5', 'Invented correction'], + ['upgrade-bob', 2026, '27.5', '0', '0', null], + ['upgrade-carol', 2025, '28', '0', '0', null], + ['upgrade-carol', 2026, '30', '3', '0', null], + ]; + foreach ($entitlements as [$uid, $year, $base, $carry, $adjustment, $note]) { + $id = insert($db, 'absence_entitlements', [ + 'employee_uid' => $uid, 'year' => [$year, IQueryBuilder::PARAM_INT], 'type_id' => [$types['annual'], IQueryBuilder::PARAM_INT], + 'base_days' => $base, 'carry_over_days' => $carry, 'manual_adjustment' => $adjustment, 'adjustment_note' => $note, + 'created_at' => [new DateTime('2026-01-02 08:00:00'), IQueryBuilder::PARAM_DATETIME_MUTABLE], + 'updated_at' => [new DateTime('2026-01-02 08:00:00'), IQueryBuilder::PARAM_DATETIME_MUTABLE], + ]); + insert($db, 'absence_entitlement_events', [ + 'entitlement_id' => [$id, IQueryBuilder::PARAM_INT], 'employee_uid' => $uid, 'actor_uid' => 'upgrade-hr', + 'field' => 'base_days', 'old_value' => '0', 'new_value' => $base, 'note' => $note, + 'created_at' => [new DateTime('2026-01-02 08:00:00'), IQueryBuilder::PARAM_DATETIME_MUTABLE], + ]); + } + + $content = "%PDF-1.4\ninvented attachment for the upgrade check\n"; + $attachment = insert($db, 'absence_attachments', [ + 'request_id' => [$ids[2], IQueryBuilder::PARAM_INT], 'uploader_uid' => 'upgrade-hr', 'name' => 'invented-note.pdf', + 'mime' => 'application/pdf', 'size' => [strlen($content), IQueryBuilder::PARAM_INT], + 'created_at' => [new DateTime('2026-03-04 08:00:00'), IQueryBuilder::PARAM_DATETIME_MUTABLE], + ]); + attachmentFolder()->newFile((string)$attachment, $content); + echo "seeded\n"; +} + +/** @param array $values a value, or [value, parameter type] */ +function insert(IDBConnection $db, string $table, array $values): int { + $qb = $db->getQueryBuilder(); + $qb->insert($table); + foreach ($values as $column => $value) { + [$value, $type] = is_array($value) ? $value : [$value, $value === null ? IQueryBuilder::PARAM_NULL : IQueryBuilder::PARAM_STR]; + $qb->setValue($column, $qb->createNamedParameter($value, $type)); + } + $qb->executeStatement(); + return $qb->getLastInsertId(); +} + +/** @return array leave type key => id */ +function typeIds(IDBConnection $db): array { + $result = $db->getQueryBuilder()->select('id', 'key')->from('absence_leave_types')->executeQuery(); + $ids = []; + while ($row = $result->fetch()) { + $ids[$row['key']] = (int)$row['id']; + } + $result->closeCursor(); + return $ids; +} + +function attachmentFolder(): \OCP\Files\SimpleFS\ISimpleFolder { + $appData = Server::get(IAppDataFactory::class)->get(APP); + try { + return $appData->getFolder('attachments'); + } catch (NotFoundException) { + return $appData->newFolder('attachments'); + } +} + +/** @return list> */ +function rows(IDBConnection $db, string $table, array $columns, string $order = 'id'): array { + $qb = $db->getQueryBuilder(); + $result = $qb->select(...$columns)->from($table)->orderBy($order)->executeQuery(); + $rows = $result->fetchAll(); + $result->closeCursor(); + return $rows; +} + +function flag(mixed $value): bool { + return in_array($value, [true, 1, '1', 't', 'true'], true); +} + +function day(mixed $value): string { + return substr((string)$value, 0, 10); +} + +function number(mixed $value): string { + return rtrim(rtrim(sprintf('%.2F', (float)$value), '0'), '.'); +} + +function tableExists(IDBConnection $db, string $table): bool { + return $db->tableExists($table); +} + +/** + * What HR entered, in a form that reads the same before and after the upgrade: + * dates as `YYYY-MM-DD`, numbers without trailing zeros, types by key. + * + * @return array + */ +function snapshot(IDBConnection $db): array { + $types = array_flip(typeIds($db)); + $requests = array_map(static fn (array $r): array => [ + 'id' => (int)$r['id'], 'employee' => $r['employee_uid'], 'manager' => $r['manager_uid'], 'type' => $types[(int)$r['type_id']] ?? null, + 'from' => day($r['start_date']), 'to' => day($r['end_date']), 'days' => number($r['working_days']), 'status' => $r['status'], + 'reason' => $r['reason'], 'replacement' => $r['replacement_uid'], 'decidedBy' => $r['decided_by'], 'disability' => flag($r['disability']), + ], rows($db, 'absence_requests', ['id', 'employee_uid', 'manager_uid', 'type_id', 'start_date', 'end_date', 'working_days', 'status', 'reason', 'replacement_uid', 'decided_by', 'disability'])); + + $entitlements = array_map(static fn (array $r): array => [ + 'id' => (int)$r['id'], 'employee' => $r['employee_uid'], 'year' => (int)$r['year'], 'type' => $types[(int)$r['type_id']] ?? null, + 'base' => number($r['base_days']), 'carryOver' => number($r['carry_over_days']), 'adjustment' => number($r['manual_adjustment']), 'note' => $r['adjustment_note'], + ], rows($db, 'absence_entitlements', ['id', 'employee_uid', 'year', 'type_id', 'base_days', 'carry_over_days', 'manual_adjustment', 'adjustment_note'])); + + $eventsTable = tableExists($db, 'absence_ent_events') ? 'absence_ent_events' : 'absence_entitlement_events'; + $entitlementEvents = array_map(static fn (array $r): array => [ + 'entitlement' => (int)$r['entitlement_id'], 'employee' => $r['employee_uid'], 'actor' => $r['actor_uid'], 'field' => $r['field'], + 'old' => number($r['old_value']), 'new' => number($r['new_value']), 'note' => $r['note'], 'at' => substr((string)$r['created_at'], 0, 19), + ], rows($db, $eventsTable, ['entitlement_id', 'employee_uid', 'actor_uid', 'field', 'old_value', 'new_value', 'note', 'created_at'], 'entitlement_id')); + + $comments = array_map(static fn (array $r): array => ['request' => (int)$r['request_id'], 'author' => $r['author_uid'], 'body' => $r['body']], + rows($db, 'absence_comments', ['request_id', 'author_uid', 'body'])); + $history = array_map(static fn (array $r): array => ['request' => (int)$r['request_id'], 'actor' => $r['actor_uid'], 'event' => $r['event_type']], + rows($db, 'absence_request_events', ['request_id', 'actor_uid', 'event_type'])); + + $folder = attachmentFolder(); + $attachments = array_map(static function (array $r) use ($folder): array { + try { + $hash = sha1($folder->getFile((string)$r['id'])->getContent()); + } catch (NotFoundException) { + $hash = null; + } + return ['request' => (int)$r['request_id'], 'name' => $r['name'], 'mime' => $r['mime'], 'size' => (int)$r['size'], 'sha1' => $hash]; + }, rows($db, 'absence_attachments', ['id', 'request_id', 'name', 'mime', 'size'])); + + $leaveTypes = array_map(static fn (array $r): array => [ + 'key' => $r['key'], 'label' => $r['label'], 'hrOnly' => flag($r['hr_only']), 'enabled' => flag($r['enabled']), + 'countsAgainstBalance' => flag($r['counts_against_balance']), 'requiresNote' => flag($r['requires_note']), + ], rows($db, 'absence_leave_types', ['key', 'label', 'hr_only', 'enabled', 'counts_against_balance', 'requires_note'], 'key')); + + $userConfig = Server::get(IUserConfig::class); + $personal = []; + foreach (USERS as $uid) { + $personal[$uid] = [ + 'country' => $userConfig->getValueString($uid, APP, 'holiday_country'), + 'region' => $userConfig->getValueString($uid, APP, 'holiday_region'), + ]; + } + + $appConfig = Server::get(IAppConfig::class); + return [ + 'requests' => $requests, + 'entitlements' => $entitlements, + 'entitlementEvents' => $entitlementEvents, + 'comments' => $comments, + 'requestHistory' => $history, + 'attachments' => $attachments, + 'leaveTypes' => $leaveTypes, + 'personal' => $personal, + 'settings' => [ + 'default_entitlement' => number($appConfig->getValueFloat(APP, 'default_entitlement', 28.0)), + 'max_concurrent_absences' => $appConfig->getValueInt(APP, 'max_concurrent_absences', 2), + 'carryover_expiry' => $appConfig->getValueString(APP, 'carryover_expiry', '', lazy: true), + ], + ]; +} + +/** @param array $before */ +function verify(IDBConnection $db, array $before): int { + $after = snapshot($db); + $failures = 0; + $check = static function (bool $ok, string $what) use (&$failures): void { + echo ($ok ? 'ok ' : 'FAIL ') . $what . "\n"; + $failures += $ok ? 0 : 1; + }; + + foreach ($before as $section => $data) { + $same = $data === $after[$section]; + $check($same, "$section kept as entered"); + if (!$same) { + echo ' before: ' . json_encode($data) . "\n after: " . json_encode($after[$section]) . "\n"; + } + } + + $check(!tableExists($db, 'absence_entitlement_events'), 'old entitlement history table is gone after its rows were copied'); + + $userConfig = Server::get(IUserConfig::class); + foreach (WEEKDAYS as $uid => [, $expected]) { + $periods = array_values(array_filter( + rows($db, 'absence_periods', ['employee_uid', 'weekdays', 'percent']), + static fn (array $r): bool => $r['employee_uid'] === $uid, + )); + $check( + $expected === null ? $periods === [] : (count($periods) === 1 && $periods[0]['weekdays'] === $expected), + $expected === null ? "$uid: an invalid weekdays setting makes no contract" : "$uid: own weekdays became a contract ($expected)", + ); + $check($userConfig->getValueString($uid, APP, 'work_weekdays') === '', "$uid: the old weekdays setting is cleaned up"); + } + + $appConfig = Server::get(IAppConfig::class); + $check($appConfig->getValueString(APP, 'hr_group') === 'hr', 'the HR group 1.0.12 used by default is kept'); + + $confidential = []; + foreach (rows($db, 'absence_comments', ['request_id', 'confidential']) as $row) { + $confidential[(int)$row['request_id']][] = flag($row['confidential']); + } + $maternity = array_values(array_filter($after['requests'], static fn (array $r): bool => $r['type'] === 'maternity'))[0]['id']; + $check(($confidential[$maternity] ?? []) === [true], 'comments of a confidential absence are marked confidential'); + $check(array_sum(array_map(static fn (array $flags): int => count(array_filter($flags)), $confidential)) === 1, 'no other comment is marked confidential'); + + $installed = $appConfig->getValueString(APP, 'installed_version'); + // Nextcloud blocks loading XML from files, so the text is read first + $code = (string)simplexml_load_string((string)file_get_contents(__DIR__ . '/../../appinfo/info.xml'))->version; + $check($installed === $code, "installed version is the code's ($installed)"); + + echo $failures === 0 ? "upgrade check passed\n" : "$failures check(s) failed\n"; + return $failures === 0 ? 0 : 1; +} From a41b9d30ba62282f2c5a9620ea7912198c4ea3f5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20Molakvo=C3=A6?= <14975046+skjnldsv@users.noreply.github.com> Date: Tue, 17 Nov 2026 17:53:37 +0100 Subject: [PATCH 3/5] test(migration): cover beta.1, reinstalling and what the app shows MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The upgrade jobs failed before reaching the app: on a stable server branch `occ upgrade` stops while the always-enabled viewer app has no files, and the server checkout does not bring it. The workflow adds it. The check now also starts from 1.0.0-beta.1, moves to the new code by removing and enabling the app as well as with `occ upgrade`, and bumps the version when the code still carries the one of the last release, since Nextcloud runs no migration without a new version. It compares what is stored for any instance instead of a fixed list of people, asks the app for the balances before and after, and checks that every migration of the code ran. Assisted-by: ClaudeCode:claude-fable-5-2 Signed-off-by: John Molakvoæ <14975046+skjnldsv@users.noreply.github.com> --- ...12.yml => upgrade-from-older-versions.yml} | 63 +++- tests/Upgrade/upgrade-check.php | 269 +++++++++++++----- 2 files changed, 247 insertions(+), 85 deletions(-) rename .github/workflows/{upgrade-from-1.0.12.yml => upgrade-from-older-versions.yml} (67%) diff --git a/.github/workflows/upgrade-from-1.0.12.yml b/.github/workflows/upgrade-from-older-versions.yml similarity index 67% rename from .github/workflows/upgrade-from-1.0.12.yml rename to .github/workflows/upgrade-from-older-versions.yml index bd00768a..1ab49386 100644 --- a/.github/workflows/upgrade-from-1.0.12.yml +++ b/.github/workflows/upgrade-from-older-versions.yml @@ -1,11 +1,13 @@ # SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors # SPDX-License-Identifier: AGPL-3.0-or-later # -# HR used Absence 1.0.12 (commit 0d84f4d) before the betas. This installs that -# version, fills it with invented data, upgrades to the code of the pull request -# with `occ upgrade` and checks that everything entered is still there. +# Installs an older Absence, fills it with invented data, moves to the code of +# the pull request and checks that everything entered is still there. +# +# From: 1.0.12 (commit 0d84f4d), which HR used before the betas, and 1.0.0-beta.1. +# How: `occ upgrade` over the replaced folder, or app removed and enabled again. -name: Upgrade from 1.0.12 +name: Upgrade from older versions on: pull_request @@ -13,7 +15,7 @@ permissions: contents: read concurrency: - group: upgrade-from-1012-${{ github.head_ref || github.run_id }} + group: upgrade-from-older-${{ github.head_ref || github.run_id }} cancel-in-progress: true jobs: @@ -35,7 +37,7 @@ jobs: with: filters: | src: - - '.github/workflows/upgrade-from-1.0.12.yml' + - '.github/workflows/upgrade-from-older-versions.yml' - 'appinfo/**' - 'lib/**' - 'tests/Upgrade/**' @@ -61,8 +63,15 @@ jobs: fail-fast: false matrix: database: ['sqlite', 'mysql', 'pgsql'] + from: ['1.0.12', '1.0.0-beta.1'] + how: ['upgrade', 'reinstall'] + include: + - from: '1.0.12' + ref: 0d84f4da14aea8564ba666d3cfd31f60123302bc + - from: '1.0.0-beta.1' + ref: v1.0.0-beta.1 - name: Upgrade from 1.0.12 on ${{ matrix.database }} + name: ${{ matrix.from }} ${{ matrix.how }} on ${{ matrix.database }} services: mysql: @@ -91,11 +100,20 @@ jobs: repository: nextcloud/server ref: ${{ needs.changes-and-matrix.outputs.server-min }} - - name: Checkout Absence 1.0.12 + - name: Add the viewer app where the server does not ship it + env: + SERVER_BRANCH: ${{ needs.changes-and-matrix.outputs.server-min }} + run: | + # `occ upgrade` refuses to run while an always-enabled app has no files + if [ ! -d apps/viewer ]; then + git clone --depth 1 --branch "$SERVER_BRANCH" https://github.com/nextcloud/viewer.git apps/viewer + fi + + - name: Checkout Absence ${{ matrix.from }} uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: persist-credentials: false - ref: 0d84f4da14aea8564ba666d3cfd31f60123302bc + ref: ${{ matrix.ref }} path: apps/absence - name: Checkout the code to upgrade to @@ -115,7 +133,7 @@ jobs: env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - - name: Install Nextcloud with Absence 1.0.12 + - name: Install Nextcloud with Absence ${{ matrix.from }} env: DATABASE: ${{ matrix.database }} run: | @@ -128,16 +146,31 @@ jobs: ./occ app:enable --force absence ./occ config:app:get absence installed_version - - name: Enter invented data on 1.0.12 + - name: Enter invented data on ${{ matrix.from }} run: | php new-absence/tests/Upgrade/upgrade-check.php "$PWD" seed php new-absence/tests/Upgrade/upgrade-check.php "$PWD" snapshot before.json - - name: Upgrade to the new code + - name: Move to the new code + env: + HOW: ${{ matrix.how }} run: | - rm -rf apps/absence - mv new-absence apps/absence - ./occ upgrade + installed=$(./occ config:app:get absence installed_version) + new=$(sed -n 's:.*\(.*\).*:\1:p' new-absence/appinfo/info.xml) + if [ "$installed" = "$new" ]; then + # Unreleased code keeps the version of the last release, and Nextcloud only + # runs migrations for a new version: bump it here like the release will. + sed -i "s:$new:$new.1:" new-absence/appinfo/info.xml + fi + if [ "$HOW" = reinstall ]; then + ./occ app:remove absence + mv new-absence apps/absence + ./occ app:enable --force absence + else + rm -rf apps/absence + mv new-absence apps/absence + ./occ upgrade + fi ./occ config:app:get absence installed_version - name: Check the data diff --git a/tests/Upgrade/upgrade-check.php b/tests/Upgrade/upgrade-check.php index 6acc1cd2..5170b1f1 100644 --- a/tests/Upgrade/upgrade-check.php +++ b/tests/Upgrade/upgrade-check.php @@ -8,18 +8,28 @@ */ /** - * Upgrade check from Absence 1.0.12 (commit 0d84f4d), the version HR used - * before the betas, to the checked-out code. + * Checks that an upgrade of Absence keeps what people entered. * - * php upgrade-check.php seed on 1.0.12: invented data + * php upgrade-check.php seed invented data, on the old version * php upgrade-check.php snapshot write what is stored * php upgrade-check.php verify after `occ upgrade` * - * It uses OCP and plain queries only, never the app's own classes, so the - * same file runs against both versions. Every person and value is invented. + * `snapshot` and `verify` read whatever the instance holds, so they also serve + * to rehearse the upgrade on a copy of a real database. A snapshot of real + * data is personal data: keep it out of the repository. + * + * `seed` writes the rows the way the old version stored them: 1.0.12 (commit + * 0d84f4d), the version HR used before the betas, or 1.0.0-beta.1. Every + * person and value in it is invented. + * + * Only OCP and plain queries are used to read and write, so the same file runs + * against every version. The balances are asked from the app itself, to + * compare what it shows before and after. */ +use OCP\App\IAppManager; use OCP\Config\IUserConfig; +use OCP\Config\ValueType; use OCP\DB\QueryBuilder\IQueryBuilder; use OCP\Files\AppData\IAppDataFactory; use OCP\Files\NotFoundException; @@ -40,12 +50,12 @@ const APP = 'absence'; const USERS = ['upgrade-alice', 'upgrade-bob', 'upgrade-carol', 'upgrade-dave', 'upgrade-hr']; -/** Weekdays people set for themselves on 1.0.12, and the contract each must become */ +/** Weekdays people set for themselves on 1.0.12: sorted, short, unsorted and not weekdays at all */ const WEEKDAYS = [ - 'upgrade-alice' => ['1,2,3,4,5', '1,2,3,4,5'], - 'upgrade-bob' => ['1,2,3,4', '1,2,3,4'], - 'upgrade-carol' => ['5,1,3', '1,3,5'], - 'upgrade-dave' => ['every day', null], + 'upgrade-alice' => '1,2,3,4,5', + 'upgrade-bob' => '1,2,3,4', + 'upgrade-carol' => '5,1,3', + 'upgrade-dave' => 'every day', ]; $db = Server::get(IDBConnection::class); @@ -53,7 +63,7 @@ if ($mode === 'seed') { seed($db); } elseif ($mode === 'snapshot' && $file !== null) { - file_put_contents($file, json_encode(snapshot($db), JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR)); + file_put_contents($file, json_encode(before($db), JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR)); } elseif ($mode === 'verify' && $file !== null) { exit(verify($db, json_decode((string)file_get_contents($file), true, flags: JSON_THROW_ON_ERROR))); } else { @@ -61,20 +71,29 @@ } function seed(IDBConnection $db): void { + // 1.0.12 keeps the entitlement history under its long name and has no contracts yet + $before1013 = !$db->tableExists('absence_ent_events'); + $users = Server::get(IUserManager::class); foreach (USERS as $uid) { $users->get($uid) ?? $users->createUser($uid, bin2hex(random_bytes(16)) . 'Aa1!'); } $groups = Server::get(IGroupManager::class); - // The HR group of 1.0.12's default; the setting itself is never stored + // The HR group of the old default; the setting itself is never stored ($groups->get('hr') ?? $groups->createGroup('hr'))->addUser($users->get('upgrade-hr')); foreach (['upgrade-alice', 'upgrade-bob', 'upgrade-carol'] as $uid) { $users->get($uid)->setManagerUids(['upgrade-dave']); } $config = Server::get(IUserConfig::class); - foreach (WEEKDAYS as $uid => [$stored]) { - $config->setValueString($uid, APP, 'work_weekdays', $stored); + if ($before1013) { + foreach (WEEKDAYS as $uid => $stored) { + $config->setValueString($uid, APP, 'work_weekdays', $stored); + } + } else { + // The betas keep contracts: HR entered one for somebody + insert($db, 'absence_employments', ['employee_uid' => 'upgrade-alice', 'start_date' => '2022-04-01', 'end_date' => null]); + insert($db, 'absence_periods', ['employee_uid' => 'upgrade-alice', 'valid_from' => '2022-04-01', 'weekdays' => '1,2,3,4', 'percent' => [80, IQueryBuilder::PARAM_INT]]); } $config->setValueString('upgrade-alice', APP, 'holiday_country', 'DE'); $config->setValueString('upgrade-alice', APP, 'holiday_region', 'BY'); @@ -91,12 +110,13 @@ function seed(IDBConnection $db): void { 'counts_against_balance' => [false, IQueryBuilder::PARAM_BOOL], 'requires_approval' => [true, IQueryBuilder::PARAM_BOOL], 'requires_note' => [true, IQueryBuilder::PARAM_BOOL], 'requires_replacement' => [false, IQueryBuilder::PARAM_BOOL], 'employee_requestable' => [true, IQueryBuilder::PARAM_BOOL], 'enabled' => [true, IQueryBuilder::PARAM_BOOL], - 'hr_only' => [false, IQueryBuilder::PARAM_BOOL], 'sort_order' => 20, + 'hr_only' => [false, IQueryBuilder::PARAM_BOOL], 'sort_order' => [20, IQueryBuilder::PARAM_INT], ]); $update = $db->getQueryBuilder(); $update->update('absence_leave_types')->set('enabled', $update->createNamedParameter(false, IQueryBuilder::PARAM_BOOL)) ->where($update->expr()->eq('key', $update->createNamedParameter('special')))->executeStatement(); + // A half day, a confidential absence, pending leave, leave across New Year and a cancelled request $requests = [ ['upgrade-alice', 'annual', '2026-02-16', '2026-02-20', '5', 'APPROVED', 'Ski week', 'upgrade-bob', 'upgrade-dave', false], ['upgrade-alice', 'annual', '2026-08-03', '2026-08-04', '1.5', 'APPROVED', null, 'upgrade-bob', 'upgrade-dave', false], @@ -110,7 +130,8 @@ function seed(IDBConnection $db): void { foreach ($requests as [$uid, $type, $from, $to, $days, $status, $reason, $replacement, $decidedBy, $disability]) { $ids[] = insert($db, 'absence_requests', [ 'employee_uid' => $uid, 'manager_uid' => 'upgrade-dave', 'type_id' => [$types[$type], IQueryBuilder::PARAM_INT], - 'start_date' => [new DateTime($from), IQueryBuilder::PARAM_DATE], 'end_date' => [new DateTime($to), IQueryBuilder::PARAM_DATE], + // As text: every database takes it for a date column and for the text column of the betas + 'start_date' => $from, 'end_date' => $to, 'working_days' => $days, 'status' => $status, 'reason' => $reason, 'replacement_uid' => $replacement, 'decided_by' => $decidedBy, 'decided_at' => [$decidedBy === null ? null : new DateTime('2026-01-10 09:00:00'), $decidedBy === null ? IQueryBuilder::PARAM_NULL : IQueryBuilder::PARAM_DATETIME_MUTABLE], 'escalated' => [false, IQueryBuilder::PARAM_BOOL], 'disability' => [$disability, IQueryBuilder::PARAM_BOOL], @@ -132,6 +153,7 @@ function seed(IDBConnection $db): void { 'detail' => null, 'created_at' => [new DateTime('2026-01-05 08:00:00'), IQueryBuilder::PARAM_DATETIME_MUTABLE]]); } + // A half-day allowance, a carry-over and an adjustment with its note $entitlements = [ ['upgrade-alice', 2026, '28', '5', '-1.5', 'Invented correction'], ['upgrade-bob', 2026, '27.5', '0', '0', null], @@ -145,7 +167,7 @@ function seed(IDBConnection $db): void { 'created_at' => [new DateTime('2026-01-02 08:00:00'), IQueryBuilder::PARAM_DATETIME_MUTABLE], 'updated_at' => [new DateTime('2026-01-02 08:00:00'), IQueryBuilder::PARAM_DATETIME_MUTABLE], ]); - insert($db, 'absence_entitlement_events', [ + insert($db, $before1013 ? 'absence_entitlement_events' : 'absence_ent_events', [ 'entitlement_id' => [$id, IQueryBuilder::PARAM_INT], 'employee_uid' => $uid, 'actor_uid' => 'upgrade-hr', 'field' => 'base_days', 'old_value' => '0', 'new_value' => $base, 'note' => $note, 'created_at' => [new DateTime('2026-01-02 08:00:00'), IQueryBuilder::PARAM_DATETIME_MUTABLE], @@ -159,7 +181,7 @@ function seed(IDBConnection $db): void { 'created_at' => [new DateTime('2026-03-04 08:00:00'), IQueryBuilder::PARAM_DATETIME_MUTABLE], ]); attachmentFolder()->newFile((string)$attachment, $content); - echo "seeded\n"; + echo 'seeded the data of ' . ($before1013 ? '1.0.12' : 'a beta') . "\n"; } /** @param array $values a value, or [value, parameter type] */ @@ -207,21 +229,77 @@ function flag(mixed $value): bool { return in_array($value, [true, 1, '1', 't', 'true'], true); } -function day(mixed $value): string { - return substr((string)$value, 0, 10); +function day(mixed $value): ?string { + return $value === null ? null : substr((string)$value, 0, 10); } function number(mixed $value): string { return rtrim(rtrim(sprintf('%.2F', (float)$value), '0'), '.'); } -function tableExists(IDBConnection $db, string $table): bool { - return $db->tableExists($table); +/** The weekdays of a personal setting in order, or null when it does not list weekdays */ +function weekdays(string $stored): ?string { + if (preg_match('/^[1-7](,[1-7])*$/', $stored) !== 1) { + return null; + } + $days = explode(',', $stored); + if (count(array_unique($days)) !== count($days)) { + return null; + } + sort($days); + return implode(',', $days); +} + +/** @return array uid => value, for everybody who stored one */ +function personal(string $key): array { + $values = []; + foreach (Server::get(IUserConfig::class)->getValuesByUsers(APP, $key, ValueType::STRING) as $uid => $value) { + $values[(string)$uid] = (string)$value; + } + ksort($values); + return $values; } /** - * What HR entered, in a form that reads the same before and after the upgrade: - * dates as `YYYY-MM-DD`, numbers without trailing zeros, types by key. + * What the app itself shows as balance, for every person and year with an + * entitlement or a request. + * + * @param list> $requests + * @param list> $entitlements + * @return array>> "uid year" => type => figures + */ +function balances(array $requests, array $entitlements): array { + Server::get(IAppManager::class)->loadApp(APP); + /** @psalm-suppress UndefinedClass the app is not part of this script */ + $service = Server::get(\OCA\Absence\Service\BalanceService::class); + $wanted = []; + foreach ($requests as $request) { + $wanted[$request['employee'] . ' ' . substr((string)$request['from'], 0, 4)] = true; + } + foreach ($entitlements as $entitlement) { + $wanted[$entitlement['employee'] . ' ' . $entitlement['year']] = true; + } + ksort($wanted); + $balances = []; + foreach (array_keys($wanted) as $key) { + [$uid, $year] = explode(' ', $key); + foreach ($service->getBalance($uid, (int)$year)['balances'] as $row) { + if ((int)$row['year'] !== (int)$year) { + continue; + } + $balances[$key][$row['typeKey']] = [ + 'entitlement' => number($row['entitlement']), 'used' => number($row['used']), + 'pending' => number($row['pending']), 'available' => number($row['available']), + ]; + } + ksort($balances[$key]); + } + return $balances; +} + +/** + * What people entered, in a form that reads the same before and after the + * upgrade: dates as `YYYY-MM-DD`, numbers without trailing zeros, types by key. * * @return array */ @@ -238,14 +316,24 @@ function snapshot(IDBConnection $db): array { 'base' => number($r['base_days']), 'carryOver' => number($r['carry_over_days']), 'adjustment' => number($r['manual_adjustment']), 'note' => $r['adjustment_note'], ], rows($db, 'absence_entitlements', ['id', 'employee_uid', 'year', 'type_id', 'base_days', 'carry_over_days', 'manual_adjustment', 'adjustment_note'])); - $eventsTable = tableExists($db, 'absence_ent_events') ? 'absence_ent_events' : 'absence_entitlement_events'; + $eventsTable = $db->tableExists('absence_ent_events') ? 'absence_ent_events' : 'absence_entitlement_events'; $entitlementEvents = array_map(static fn (array $r): array => [ 'entitlement' => (int)$r['entitlement_id'], 'employee' => $r['employee_uid'], 'actor' => $r['actor_uid'], 'field' => $r['field'], 'old' => number($r['old_value']), 'new' => number($r['new_value']), 'note' => $r['note'], 'at' => substr((string)$r['created_at'], 0, 19), - ], rows($db, $eventsTable, ['entitlement_id', 'employee_uid', 'actor_uid', 'field', 'old_value', 'new_value', 'note', 'created_at'], 'entitlement_id')); + ], rows($db, $eventsTable, ['entitlement_id', 'employee_uid', 'actor_uid', 'field', 'old_value', 'new_value', 'note', 'created_at'])); - $comments = array_map(static fn (array $r): array => ['request' => (int)$r['request_id'], 'author' => $r['author_uid'], 'body' => $r['body']], - rows($db, 'absence_comments', ['request_id', 'author_uid', 'body'])); + $hrOnly = []; + foreach (rows($db, 'absence_leave_types', ['id', 'hr_only']) as $type) { + $hrOnly[(int)$type['id']] = flag($type['hr_only']); + } + $confidentialRequests = []; + foreach (rows($db, 'absence_requests', ['id', 'type_id']) as $request) { + $confidentialRequests[(int)$request['id']] = $hrOnly[(int)$request['type_id']] ?? false; + } + $comments = array_map(static fn (array $r): array => [ + 'request' => (int)$r['request_id'], 'author' => $r['author_uid'], 'body' => $r['body'], + 'onConfidentialAbsence' => $confidentialRequests[(int)$r['request_id']] ?? false, + ], rows($db, 'absence_comments', ['request_id', 'author_uid', 'body'])); $history = array_map(static fn (array $r): array => ['request' => (int)$r['request_id'], 'actor' => $r['actor_uid'], 'event' => $r['event_type']], rows($db, 'absence_request_events', ['request_id', 'actor_uid', 'event_type'])); @@ -264,17 +352,8 @@ function snapshot(IDBConnection $db): array { 'countsAgainstBalance' => flag($r['counts_against_balance']), 'requiresNote' => flag($r['requires_note']), ], rows($db, 'absence_leave_types', ['key', 'label', 'hr_only', 'enabled', 'counts_against_balance', 'requires_note'], 'key')); - $userConfig = Server::get(IUserConfig::class); - $personal = []; - foreach (USERS as $uid) { - $personal[$uid] = [ - 'country' => $userConfig->getValueString($uid, APP, 'holiday_country'), - 'region' => $userConfig->getValueString($uid, APP, 'holiday_region'), - ]; - } - $appConfig = Server::get(IAppConfig::class); - return [ + $snapshot = [ 'requests' => $requests, 'entitlements' => $entitlements, 'entitlementEvents' => $entitlementEvents, @@ -282,62 +361,112 @@ function snapshot(IDBConnection $db): array { 'requestHistory' => $history, 'attachments' => $attachments, 'leaveTypes' => $leaveTypes, - 'personal' => $personal, + 'balances' => balances($requests, $entitlements), + 'regions' => ['country' => personal('holiday_country'), 'region' => personal('holiday_region')], 'settings' => [ 'default_entitlement' => number($appConfig->getValueFloat(APP, 'default_entitlement', 28.0)), 'max_concurrent_absences' => $appConfig->getValueInt(APP, 'max_concurrent_absences', 2), 'carryover_expiry' => $appConfig->getValueString(APP, 'carryover_expiry', '', lazy: true), ], ]; + // Contracts exist from the betas on + if ($db->tableExists('absence_employments')) { + $snapshot['employments'] = array_map(static fn (array $r): array => ['employee' => $r['employee_uid'], 'start' => day($r['start_date']), 'end' => day($r['end_date'])], + rows($db, 'absence_employments', ['employee_uid', 'start_date', 'end_date'], 'employee_uid')); + } + return $snapshot; +} + +/** + * The parts of a snapshot that are compared one to one, and what is only + * needed to work out what the upgrade has to do. + * + * @return array{kept: array, weekdays: array, contracts: list>, hrGroup: ?string, hrGroupExists: bool} + */ +function before(IDBConnection $db): array { + $appConfig = Server::get(IAppConfig::class); + $periods = $db->tableExists('absence_periods') ? 'absence_periods' : ($db->tableExists('absence_contract_periods') ? 'absence_contract_periods' : null); + return [ + 'kept' => snapshot($db), + 'weekdays' => personal('work_weekdays'), + 'contracts' => $periods === null ? [] : contracts($db, $periods), + 'hrGroup' => $appConfig->hasKey(APP, 'hr_group') ? $appConfig->getValueString(APP, 'hr_group') : null, + 'hrGroupExists' => Server::get(IGroupManager::class)->groupExists('hr'), + ]; +} + +/** @return list */ +function contracts(IDBConnection $db, string $table): array { + return array_map(static fn (array $r): array => [ + 'employee' => $r['employee_uid'], 'from' => day($r['valid_from']), 'weekdays' => $r['weekdays'], 'percent' => $r['percent'] === null ? null : (int)$r['percent'], + ], rows($db, $table, ['employee_uid', 'valid_from', 'weekdays', 'percent'])); } /** @param array $before */ function verify(IDBConnection $db, array $before): int { $after = snapshot($db); $failures = 0; - $check = static function (bool $ok, string $what) use (&$failures): void { + $check = static function (bool $ok, string $what, mixed $expected = null, mixed $got = null) use (&$failures): void { echo ($ok ? 'ok ' : 'FAIL ') . $what . "\n"; - $failures += $ok ? 0 : 1; + if (!$ok) { + echo ' expected: ' . json_encode($expected) . "\n got: " . json_encode($got) . "\n"; + $failures++; + } }; - foreach ($before as $section => $data) { - $same = $data === $after[$section]; - $check($same, "$section kept as entered"); - if (!$same) { - echo ' before: ' . json_encode($data) . "\n after: " . json_encode($after[$section]) . "\n"; - } + foreach ($before['kept'] as $section => $data) { + $check($data === ($after[$section] ?? null), "$section: the same before and after", $data, $after[$section] ?? null); } - $check(!tableExists($db, 'absence_entitlement_events'), 'old entitlement history table is gone after its rows were copied'); - - $userConfig = Server::get(IUserConfig::class); - foreach (WEEKDAYS as $uid => [, $expected]) { - $periods = array_values(array_filter( - rows($db, 'absence_periods', ['employee_uid', 'weekdays', 'percent']), - static fn (array $r): bool => $r['employee_uid'] === $uid, - )); - $check( - $expected === null ? $periods === [] : (count($periods) === 1 && $periods[0]['weekdays'] === $expected), - $expected === null ? "$uid: an invalid weekdays setting makes no contract" : "$uid: own weekdays became a contract ($expected)", - ); - $check($userConfig->getValueString($uid, APP, 'work_weekdays') === '', "$uid: the old weekdays setting is cleaned up"); + foreach (['absence_entitlement_events', 'absence_contract_periods', 'absence_employee_history'] as $old) { + $check(!$db->tableExists($old), "$old: gone, its rows are under the new name"); } + // A contract HR entered stays; somebody without one gets their own weekdays as contract + $contracts = contracts($db, 'absence_periods'); + $expected = $before['contracts']; + $withContract = array_column($before['contracts'], 'employee'); + foreach ($before['weekdays'] as $uid => $stored) { + $days = weekdays($stored); + if ($days !== null && !in_array($uid, $withContract, true)) { + $expected[] = ['employee' => $uid, 'weekdays' => $days, 'percent' => null]; + } + } + $comparable = static function (array $rows): array { + $rows = array_map(static fn (array $r): string => $r['employee'] . ' ' . $r['weekdays'] . ' ' . json_encode($r['percent']) . (isset($r['from']) ? ' ' . $r['from'] : ''), $rows); + sort($rows); + return $rows; + }; + // The date of a converted setting is the upgrade's choice, so it is left out of the comparison + $known = array_column($before['contracts'], 'employee'); + $got = array_map(static fn (array $r): array => in_array($r['employee'], $known, true) ? $r : ['employee' => $r['employee'], 'weekdays' => $r['weekdays'], 'percent' => $r['percent']], $contracts); + $check($comparable($expected) === $comparable($got), 'contracts: the ones HR entered, plus one for each own weekdays setting', $comparable($expected), $comparable($got)); + $check(personal('work_weekdays') === [], 'own weekdays settings: all taken over or dropped', [], personal('work_weekdays')); + $appConfig = Server::get(IAppConfig::class); - $check($appConfig->getValueString(APP, 'hr_group') === 'hr', 'the HR group 1.0.12 used by default is kept'); + $hrGroup = $before['hrGroup'] ?? ($before['hrGroupExists'] ? 'hr' : ''); + $check($appConfig->getValueString(APP, 'hr_group') === $hrGroup, "HR group: still \"$hrGroup\"", $hrGroup, $appConfig->getValueString(APP, 'hr_group')); - $confidential = []; - foreach (rows($db, 'absence_comments', ['request_id', 'confidential']) as $row) { - $confidential[(int)$row['request_id']][] = flag($row['confidential']); + $wrong = []; + foreach (rows($db, 'absence_comments', ['id', 'request_id', 'confidential']) as $i => $row) { + if (flag($row['confidential']) !== $after['comments'][$i]['onConfidentialAbsence']) { + $wrong[] = (int)$row['id']; + } } - $maternity = array_values(array_filter($after['requests'], static fn (array $r): bool => $r['type'] === 'maternity'))[0]['id']; - $check(($confidential[$maternity] ?? []) === [true], 'comments of a confidential absence are marked confidential'); - $check(array_sum(array_map(static fn (array $flags): int => count(array_filter($flags)), $confidential)) === 1, 'no other comment is marked confidential'); + $check($wrong === [], 'comments: marked confidential exactly on confidential absences', [], $wrong); + + // Without a new version number Nextcloud runs no migration at all + $apps = Server::get(IAppManager::class); + $steps = array_map(static fn (string $file): string => substr(basename($file, '.php'), strlen('Version')), glob($apps->getAppPath(APP) . '/lib/Migration/Version*.php') ?: []); + $qb = $db->getQueryBuilder(); + $result = $qb->select('version')->from('migrations')->where($qb->expr()->eq('app', $qb->createNamedParameter(APP)))->executeQuery(); + $ran = $result->fetchFirstColumn(); + $result->closeCursor(); + $check(array_values(array_diff($steps, $ran)) === [], 'migrations: every step of the code ran', [], array_values(array_diff($steps, $ran))); $installed = $appConfig->getValueString(APP, 'installed_version'); - // Nextcloud blocks loading XML from files, so the text is read first - $code = (string)simplexml_load_string((string)file_get_contents(__DIR__ . '/../../appinfo/info.xml'))->version; - $check($installed === $code, "installed version is the code's ($installed)"); + $code = $apps->getAppVersion(APP, false); + $check($installed === $code, "installed version: the code's ($code)", $code, $installed); echo $failures === 0 ? "upgrade check passed\n" : "$failures check(s) failed\n"; return $failures === 0 ? 0 : 1; From 36bf425e241f3abd47be9812af6620c214c5378c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20Molakvo=C3=A6?= <14975046+skjnldsv@users.noreply.github.com> Date: Tue, 17 Nov 2026 18:07:25 +0100 Subject: [PATCH 4/5] fix(migration): read the own weekdays from the table, and test Oracle MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Oracle stores an empty value as NULL, and the server's typed read of a setting for all users fails on it. One person with an empty weekdays setting would have stopped the upgrade there. The migration now reads the settings with its own query. The upgrade check runs on Oracle too. Assisted-by: ClaudeCode:claude-fable-5-2 Signed-off-by: John Molakvoæ <14975046+skjnldsv@users.noreply.github.com> --- .../workflows/upgrade-from-older-versions.yml | 17 ++++++++++-- .../Version1018Date20261117180000.php | 26 ++++++++++++++++--- tests/Integration/UpgradeKeepsDataTest.php | 13 ++++++++-- tests/Upgrade/upgrade-check.php | 23 +++++++++++----- 4 files changed, 66 insertions(+), 13 deletions(-) diff --git a/.github/workflows/upgrade-from-older-versions.yml b/.github/workflows/upgrade-from-older-versions.yml index 1ab49386..80ddef53 100644 --- a/.github/workflows/upgrade-from-older-versions.yml +++ b/.github/workflows/upgrade-from-older-versions.yml @@ -62,7 +62,7 @@ jobs: strategy: fail-fast: false matrix: - database: ['sqlite', 'mysql', 'pgsql'] + database: ['sqlite', 'mysql', 'pgsql', 'oci'] from: ['1.0.12', '1.0.0-beta.1'] how: ['upgrade', 'reinstall'] include: @@ -126,13 +126,25 @@ jobs: uses: shivammathur/setup-php@eb7c497e18156a6bbabfef1d3a82760b9eda3962 # 2.40.0 with: php-version: ${{ needs.changes-and-matrix.outputs.php-min }} - extensions: bz2, ctype, curl, dom, fileinfo, gd, iconv, intl, json, libxml, mbstring, openssl, pcntl, posix, session, simplexml, xmlreader, xmlwriter, zip, zlib, sqlite, pdo_sqlite, mysql, pdo_mysql, pgsql, pdo_pgsql + extensions: bz2, ctype, curl, dom, fileinfo, gd, iconv, intl, json, libxml, mbstring, openssl, pcntl, posix, session, simplexml, xmlreader, xmlwriter, zip, zlib, sqlite, pdo_sqlite, mysql, pdo_mysql, pgsql, pdo_pgsql${{ matrix.database == 'oci' && ', oci8' || '' }} coverage: none ini-file: development ini-values: disable_functions= env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + - name: Start Oracle + if: matrix.database == 'oci' + run: | + # Not a service: only these jobs need it, and it is slow to start + docker run -d --name oracle -p 1521:1521 -e ORACLE_PASSWORD=oracle ghcr.io/gvenzl/oracle-free:23 # zizmor: ignore[unpinned-images] + for _ in $(seq 1 60); do + docker exec oracle healthcheck.sh && exit 0 + sleep 5 + done + docker logs oracle | tail -20 + exit 1 + - name: Install Nextcloud with Absence ${{ matrix.from }} env: DATABASE: ${{ matrix.database }} @@ -142,6 +154,7 @@ jobs: sqlite) ./occ maintenance:install --verbose --database=sqlite --admin-user admin --admin-pass admin ;; mysql) ./occ maintenance:install --verbose --database=mysql --database-name=nextcloud --database-host=127.0.0.1 --database-port=4444 --database-user=root --database-pass=rootpassword --admin-user admin --admin-pass admin ;; pgsql) ./occ maintenance:install --verbose --database=pgsql --database-name=nextcloud --database-host=127.0.0.1 --database-port=4445 --database-user=root --database-pass=rootpassword --admin-user admin --admin-pass admin ;; + oci) ./occ maintenance:install --verbose --database=oci --database-name=FREE --database-host=127.0.0.1 --database-port=1521 --database-user=system --database-pass=oracle --admin-user admin --admin-pass admin ;; esac ./occ app:enable --force absence ./occ config:app:get absence installed_version diff --git a/lib/Migration/Version1018Date20261117180000.php b/lib/Migration/Version1018Date20261117180000.php index c23f7a4e..8747d705 100644 --- a/lib/Migration/Version1018Date20261117180000.php +++ b/lib/Migration/Version1018Date20261117180000.php @@ -14,7 +14,6 @@ use OCA\Absence\Db\EmployeeChange; use OCA\Absence\Service\ClockService; use OCP\Config\IUserConfig; -use OCP\Config\ValueType; use OCP\DB\QueryBuilder\IQueryBuilder; use OCP\IDBConnection; use OCP\Migration\IOutput; @@ -44,7 +43,7 @@ public function __construct( #[\Override] public function postSchemaChange(IOutput $output, Closure $schemaClosure, array $options): void { - $values = $this->userConfig->getValuesByUsers(Application::APP_ID, self::KEY, ValueType::STRING); + $values = $this->ownWeekdays(); if ($values === []) { return; } @@ -54,7 +53,7 @@ public function postSchemaChange(IOutput $output, Closure $schemaClosure, array foreach (array_chunk($values, self::CHUNK, true) as $chunk) { $weekdays = []; foreach ($chunk as $uid => $value) { - $days = is_string($value) ? self::parse($value) : null; + $days = self::parse($value); if ($days !== null) { $weekdays[(string)$uid] = $days; } @@ -66,6 +65,27 @@ public function postSchemaChange(IOutput $output, Closure $schemaClosure, array $output->info(sprintf('Turned the own working weekdays of %d people into contract periods', $converted)); } + /** + * Read from the table: the typed read of the server fails on an empty value, + * which Oracle stores as NULL. + * + * @return array uid => stored value + */ + private function ownWeekdays(): array { + $qb = $this->db->getQueryBuilder(); + $qb->select('userid', 'configvalue') + ->from('preferences') + ->where($qb->expr()->eq('appid', $qb->createNamedParameter(Application::APP_ID))) + ->andWhere($qb->expr()->eq('configkey', $qb->createNamedParameter(self::KEY))); + $result = $qb->executeQuery(); + $values = []; + while ($row = $result->fetch()) { + $values[$row['userid']] = (string)($row['configvalue'] ?? ''); + } + $result->closeCursor(); + return $values; + } + /** * Comma separated ISO weekdays, at least one and each once, sorted. * diff --git a/tests/Integration/UpgradeKeepsDataTest.php b/tests/Integration/UpgradeKeepsDataTest.php index 365ce957..dcafe24f 100644 --- a/tests/Integration/UpgradeKeepsDataTest.php +++ b/tests/Integration/UpgradeKeepsDataTest.php @@ -282,10 +282,19 @@ private function historyDetails(string $uid): array { * @return array */ private function prefs(): array { + // From the table: the server's typed read fails on Oracle, where the + // empty value of one of these people is stored as NULL. + $qb = $this->db->getQueryBuilder(); + $qb->select('userid', 'configvalue') + ->from('preferences') + ->where($qb->expr()->eq('appid', $qb->createNamedParameter(ConfigService::APP_ID))) + ->andWhere($qb->expr()->eq('configkey', $qb->createNamedParameter(self::KEY))); + $result = $qb->executeQuery(); $prefs = []; - foreach ($this->userConfig->getValuesByUsers(ConfigService::APP_ID, self::KEY) as $uid => $value) { - $prefs[(string)$uid] = $value; + while ($row = $result->fetch()) { + $prefs[(string)$row['userid']] = (string)($row['configvalue'] ?? ''); } + $result->closeCursor(); return $prefs; } diff --git a/tests/Upgrade/upgrade-check.php b/tests/Upgrade/upgrade-check.php index 5170b1f1..900cb8de 100644 --- a/tests/Upgrade/upgrade-check.php +++ b/tests/Upgrade/upgrade-check.php @@ -29,7 +29,6 @@ use OCP\App\IAppManager; use OCP\Config\IUserConfig; -use OCP\Config\ValueType; use OCP\DB\QueryBuilder\IQueryBuilder; use OCP\Files\AppData\IAppDataFactory; use OCP\Files\NotFoundException; @@ -130,8 +129,9 @@ function seed(IDBConnection $db): void { foreach ($requests as [$uid, $type, $from, $to, $days, $status, $reason, $replacement, $decidedBy, $disability]) { $ids[] = insert($db, 'absence_requests', [ 'employee_uid' => $uid, 'manager_uid' => 'upgrade-dave', 'type_id' => [$types[$type], IQueryBuilder::PARAM_INT], - // As text: every database takes it for a date column and for the text column of the betas - 'start_date' => $from, 'end_date' => $to, + // 1.0.12 keeps days in date columns, the betas as text + 'start_date' => $before1013 ? [new DateTime($from), IQueryBuilder::PARAM_DATE] : $from, + 'end_date' => $before1013 ? [new DateTime($to), IQueryBuilder::PARAM_DATE] : $to, 'working_days' => $days, 'status' => $status, 'reason' => $reason, 'replacement_uid' => $replacement, 'decided_by' => $decidedBy, 'decided_at' => [$decidedBy === null ? null : new DateTime('2026-01-10 09:00:00'), $decidedBy === null ? IQueryBuilder::PARAM_NULL : IQueryBuilder::PARAM_DATETIME_MUTABLE], 'escalated' => [false, IQueryBuilder::PARAM_BOOL], 'disability' => [$disability, IQueryBuilder::PARAM_BOOL], @@ -250,12 +250,23 @@ function weekdays(string $stored): ?string { return implode(',', $days); } -/** @return array uid => value, for everybody who stored one */ +/** + * Read from the table: the typed read of the server fails on an empty value, + * which Oracle stores as NULL. + * + * @return array uid => value, for everybody who stored one + */ function personal(string $key): array { + $qb = Server::get(IDBConnection::class)->getQueryBuilder(); + $qb->select('userid', 'configvalue')->from('preferences') + ->where($qb->expr()->eq('appid', $qb->createNamedParameter(APP))) + ->andWhere($qb->expr()->eq('configkey', $qb->createNamedParameter($key))); + $result = $qb->executeQuery(); $values = []; - foreach (Server::get(IUserConfig::class)->getValuesByUsers(APP, $key, ValueType::STRING) as $uid => $value) { - $values[(string)$uid] = (string)$value; + while ($row = $result->fetch()) { + $values[(string)$row['userid']] = (string)($row['configvalue'] ?? ''); } + $result->closeCursor(); ksort($values); return $values; } From a2a7df57d93cdb41500e3f2b0a6b6c537a664fdd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20Molakvo=C3=A6?= <14975046+skjnldsv@users.noreply.github.com> Date: Tue, 17 Nov 2026 18:21:08 +0100 Subject: [PATCH 5/5] fix(migration): turn day columns into text on Oracle when they hold values MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Oracle refuses to change the type of a column that has values, so an upgrade from 1.0.12 stopped at this step with ORA-01439. On Oracle the days are now written as text to a new column that replaces the old one, and the indexes Oracle drops with the old column are added again. Assisted-by: ClaudeCode:claude-fable-5-2 Signed-off-by: John Molakvoæ <14975046+skjnldsv@users.noreply.github.com> --- .../Version1012Date20261111120000.php | 75 +++++++++++++++++-- 1 file changed, 67 insertions(+), 8 deletions(-) diff --git a/lib/Migration/Version1012Date20261111120000.php b/lib/Migration/Version1012Date20261111120000.php index b8eacef0..6b38cd25 100644 --- a/lib/Migration/Version1012Date20261111120000.php +++ b/lib/Migration/Version1012Date20261111120000.php @@ -13,6 +13,7 @@ use Doctrine\DBAL\Types\Type; use OCP\DB\ISchemaWrapper; use OCP\DB\Types; +use OCP\IDBConnection; use OCP\Migration\IOutput; use OCP\Migration\SimpleMigrationStep; @@ -20,6 +21,10 @@ * Days are kept as `YYYY-MM-DD` text, like the out-of-office days of the server * (`dav_absence`). A DATE column comes back with a time part on Oracle, and the * app reads, compares and sends these values as text everywhere. + * + * Other databases convert the values with the column. Oracle only changes the + * type of a column without values, so there the days are first written as text + * to a new column that then takes the place of the old one. */ class Version1012Date20261111120000 extends SimpleMigrationStep { private const DAYS = [ @@ -29,6 +34,49 @@ class Version1012Date20261111120000 extends SimpleMigrationStep { 'absence_contract_periods' => ['valid_from'], ]; + /** The indexes over a day column: Oracle drops them with the column it replaces */ + private const INDEXES = [ + 'absence_requests' => ['absence_req_range_idx' => [['start_date', 'end_date'], false]], + 'absence_holidays' => ['absence_hol_date_idx' => [['date'], false]], + 'absence_contract_periods' => ['absence_period_uid_from_uniq' => [['employee_uid', 'valid_from'], true]], + ]; + + public function __construct( + private IDBConnection $db, + ) { + } + + #[\Override] + public function preSchemaChange(IOutput $output, Closure $schemaClosure, array $options): void { + if ($this->db->getDatabaseProvider() !== IDBConnection::PLATFORM_ORACLE) { + return; + } + /** @var ISchemaWrapper $schema */ + $schema = $schemaClosure(); + $qb = $this->db->getQueryBuilder(); + foreach (self::DAYS as $name => $columns) { + if (!$schema->hasTable($name)) { + continue; + } + $table = $schema->getTable($name); + $quotedTable = $qb->getTableName($name); + foreach ($columns as $columnName) { + if (!$table->hasColumn($columnName) || self::isText($table->getColumn($columnName))) { + continue; + } + $column = $qb->getColumnName($columnName); + $text = $qb->getColumnName($columnName . '_txt'); + $this->db->executeStatement("ALTER TABLE $quotedTable ADD ($text VARCHAR2(10))"); + $this->db->executeStatement("UPDATE $quotedTable SET $text = TO_CHAR($column, 'YYYY-MM-DD')"); + $this->db->executeStatement("ALTER TABLE $quotedTable DROP COLUMN $column"); + $this->db->executeStatement("ALTER TABLE $quotedTable RENAME COLUMN $text TO $column"); + if ($table->getColumn($columnName)->getNotnull()) { + $this->db->executeStatement("ALTER TABLE $quotedTable MODIFY ($column NOT NULL)"); + } + } + } + } + #[\Override] public function changeSchema(IOutput $output, Closure $schemaClosure, array $options): ?ISchemaWrapper { /** @var ISchemaWrapper $schema */ @@ -45,20 +93,31 @@ public function changeSchema(IOutput $output, Closure $schemaClosure, array $opt continue; } $column = $table->getColumn($columnName); - // Nextcloud 35 and later hand out their own column, with an enum - // as type; Nextcloud 34 hands out the Doctrine one. - $type = $column->getType(); - $wrapped = $type instanceof \BackedEnum; - /** @psalm-suppress UndefinedClass Doctrine is not part of the OCP stubs */ - $isText = ($wrapped ? $type->value : Type::lookupName($type)) === Types::STRING; - if (!$isText) { + if (!self::isText($column)) { /** @psalm-suppress UndefinedClass Doctrine is not part of the OCP stubs */ - $column->setType($wrapped ? Types::STRING : Type::getType(Types::STRING)); + $column->setType($column->getType() instanceof \BackedEnum ? Types::STRING : Type::getType(Types::STRING)); $column->setLength(10); $changed = true; } } + foreach (self::INDEXES[$name] ?? [] as $index => [$indexed, $unique]) { + if (!$table->hasIndex($index)) { + $unique ? $table->addUniqueIndex($indexed, $index) : $table->addIndex($indexed, $index); + $changed = true; + } + } } return $changed ? $schema : null; } + + /** + * Nextcloud 35 and later hand out their own column, with an enum as type; + * Nextcloud 34 hands out the Doctrine one. + */ + private static function isText(object $column): bool { + /** @psalm-suppress MixedMethodCall the column class depends on the server version */ + $type = $column->getType(); + /** @psalm-suppress UndefinedClass Doctrine is not part of the OCP stubs */ + return ($type instanceof \BackedEnum ? $type->value : Type::lookupName($type)) === Types::STRING; + } }