OpenNIT

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

<?php

declare(strict_types=1);

use OpenNIT\Content\UpdateManager;

/**
 * Deckt die Auswahl des Update-Kanals ab: welche Kanäle eine Instanz anbietet,
 * wie ein gespeicherter Name aufgelöst wird und dass ein optionaler Kanal ohne
 * Freischaltung in der Umgebung nirgends erreichbar ist.
 */
return static function (): void {

    $wurzel = dirname(__DIR__);

    /** Setzt die Freischaltung für die Dauer eines Falls und räumt danach auf. */
    $mitSchalter = static function (?string $wert, callable $fall): void {
        $name   = 'OPENNIT_UPDATE_CHANNELS_EXTRA';
        $vorher = $_ENV[$name] ?? null;

        if ($wert === null) {
            unset($_ENV[$name], $_SERVER[$name]);
        } else {
            $_ENV[$name] = $wert;
        }

        try {
            $fall();
        } finally {
            unset($_ENV[$name], $_SERVER[$name]);
            if ($vorher !== null) {
                $_ENV[$name] = $vorher;
            }
        }
    };

    // ----------------------------------------------------------------
    // Standardzustand: nur die beiden bekannten Kanäle
    // ----------------------------------------------------------------

    test('Ohne Freischaltung stehen genau Stable und Development zur Wahl', function () use ($mitSchalter) {
        $mitSchalter(null, function () {
            assertSame(['stable', 'development'], array_keys(UpdateManager::availableChannels()));
        });
    });

    test('Ein nicht freigeschalteter Kanalname fällt auf Stable zurück', function () use ($mitSchalter) {
        // Auch ein von Hand in die runtime.php geschriebener Name darf die
        // Instanz nicht auf einen gesperrten Proxy zeigen lassen.
        $mitSchalter(null, function () {
            assertSame('stable', UpdateManager::resolveChannel('experimental'));
            assertSame('stable', UpdateManager::resolveChannel('gibt-es-nicht'));
            assertSame('stable', UpdateManager::resolveChannel(null));
            assertSame('development', UpdateManager::resolveChannel('development'));
        });
    });

    // ----------------------------------------------------------------
    // Freigeschalteter Zustand
    // ----------------------------------------------------------------

    test('Mit Freischaltung kommt der optionale Kanal hinzu', function () use ($mitSchalter) {
        $mitSchalter('1', function () {
            $kanaele = UpdateManager::availableChannels();

            assertTrue(array_key_exists('experimental', $kanaele));
            assertSame('experimental', UpdateManager::resolveChannel('experimental'));
            // Die bekannten Kanäle bleiben unverändert erreichbar.
            assertSame(UpdateManager::CHANNELS['stable'], $kanaele['stable']);
            assertSame(UpdateManager::CHANNELS['development'], $kanaele['development']);
        });
    });

    test('Der Schalter versteht die üblichen Schreibweisen', function () use ($mitSchalter) {
        foreach (['1', 'true', 'on', 'yes'] as $an) {
            $mitSchalter($an, function () use ($an) {
                assertSame('experimental', UpdateManager::resolveChannel('experimental'), "Wert: {$an}");
            });
        }
        foreach (['0', 'false', 'off', '', 'vielleicht'] as $aus) {
            $mitSchalter($aus, function () use ($aus) {
                assertSame('stable', UpdateManager::resolveChannel('experimental'), "Wert: {$aus}");
            });
        }
    });

    // ----------------------------------------------------------------
    // Verdrahtung: alle Stellen nutzen dieselbe Auflösung
    // ----------------------------------------------------------------

    test('Der Updater prüft die Auswahl gegen die verfügbaren Kanäle', function () use ($wurzel) {
        // Die gespeicherte Auswahl darf nicht gegen die feste Liste geprüft
        // werden – sonst wäre der optionale Kanal auch ohne Freischaltung
        // speicherbar oder mit Freischaltung nicht speicherbar.
        $src = (string)file_get_contents($wurzel . '/src/Controllers/Admin/UpdateController.php');

        assertFalse(str_contains($src, 'UpdateManager::CHANNELS'), 'Feste Kanalliste im Controller');
        assertTrue(str_contains($src, 'UpdateManager::resolveChannel'), 'Auflösung im Controller');
        assertTrue(str_contains($src, 'UpdateManager::availableChannels()'), 'Kanalliste im Controller');
    });

    test('Die Kanal-Kachel erscheint nur bei freigeschaltetem Kanal', function () use ($wurzel) {
        $tpl = (string)file_get_contents($wurzel . '/templates/admin/update/index.php');

        // Jeder Auftritt des optionalen Kanals im Formular liegt hinter der Prüfung.
        $bloecke = preg_split('/<\?php if \(in_array\(\'experimental\', \$updateChannels, true\)\): \?>/', $tpl);
        assertSame(3, count($bloecke), 'Erwartet: Kachel und Warnung je hinter einer Prüfung');
        assertFalse(str_contains($bloecke[0], 'experimental'), 'Optionaler Kanal ausserhalb der Pruefung');
    });

    test('Die Kanal-Kachel benennt jeden Kanal beim Namen', function () use ($wurzel) {
        // Eine Zweiweg-Unterscheidung wuerde jeden Kanal ausser Development als
        // "Stable" und "empfohlen" ausweisen – gerade beim risikoreichsten also
        // das Gegenteil dessen, was gilt.
        $tpl = (string)file_get_contents($wurzel . '/templates/admin/update/index.php');

        $von   = strpos($tpl, '$kanalKachel = [');
        assertTrue($von !== false, 'Keine Zuordnung je Kanal');
        $block = substr($tpl, (int)$von, 600);

        foreach (['stable', 'development', 'experimental'] as $kanal) {
            assertTrue(str_contains($block, "'{$kanal}'"), "Kanal fehlt in der Zuordnung: {$kanal}");
        }
        // Unbekannte Namen folgen der Auflösung im Controller.
        assertTrue(str_contains($block, "][\$updateChannel] ?? ['Stable'"), 'Kein Ausweichwert');

        // Die Kachel liest nur noch aus der Zuordnung.
        $kachel = substr($tpl, (int)strpos($tpl, 'status-tile-label">Update-Kanal'), 400);
        assertFalse(str_contains($kachel, "=== 'development'"), 'Zweiweg-Unterscheidung in der Kachel');
    });

    test('Der optionale Kanal ist in der Auslieferung nicht beschrieben', function () use ($wurzel) {
        // Er soll nur finden, wer ihn kennt – also kein Eintrag in den
        // Vorlagen, dem Handbuch oder dem Changelog.
        foreach (['/.env.example', '/CHANGELOG.md', '/README.md'] as $datei) {
            $pfad = $wurzel . $datei;
            if (!is_file($pfad)) {
                continue;
            }
            $inhalt = (string)file_get_contents($pfad);
            assertFalse(stripos($inhalt, 'OPENNIT_UPDATE_CHANNELS_EXTRA') !== false, "Schalter in {$datei}");
            assertFalse(stripos($inhalt, 'opennit-experimental') !== false, "Kanal in {$datei}");
        }
    });
};