Add redis connection option and config hints

Author: zerodahero

README.md

@@ -90,7 +90,9 @@ Checks that the database connection can be established, via the PDO, and that th
 
 Checks that Redis connection can be established, and that the required config keys are set.
 
-(No options)
+| Option | Description |
+| --- | --- |
+| `connection` | The name of the connection in `config/database.php` |)
 
 ### Configuration
 
@@ -110,6 +112,20 @@ The accepted options for the `Configuration` preflight check is a list of config
 ]
 ```
 
+You may also pass a hint (recommended for local development only) that will be shown if the key is not set. For example:
+
+```php
+'local' => [
+    Configuration::class => [
+        'services.payment.key' => 'In dashboard as "Super Secret API Token Key Thing"',
+        'services.mail.key',
+        // ...
+    ]
+]
+```
+
+When a new dev sets up their environment and is missing that config value, they will get that nice friendly message helping them find the key.
+
 ### Write Your Own!
 
 If you have a special startup consideration you'd like to make, feel free write your own check, extending `Kirschbaum\PreflightChecks\Checks\PreflightCheck`.

src/Checks/Configuration.php

@@ -11,8 +11,35 @@ class Configuration extends PreflightCheck
      */
     public function check(Result $result): Result
     {
-        $this->requiredConfig = $this->options;
+        $this->loadRequiredConfigFromOptions();
 
         return $this->checkConfig($result);
     }
+
+    /**
+     * Parses the required config values from the options
+     */
+    protected function loadRequiredConfigFromOptions()
+    {
+        foreach ($this->options as $key => $value) {
+            if (is_numeric($key)) {
+                // Just a list of config values, no help/description
+                $this->requiredConfig[] = $value;
+
+                continue;
+            }
+
+            // config value is key
+            $this->requiredConfig[] = $key;
+
+            // Single entry is hint
+            if (is_string($value)) {
+                $this->configHints[$key] = $value;
+
+                continue;
+            }
+
+            // Not a string, do nothing/reserve for future
+        }
+    }
 }

src/Checks/PreflightCheck.php

@@ -11,6 +11,11 @@ abstract class PreflightCheck
      */
     protected array $requiredConfig = [];
 
+    /**
+     * Configuration hints
+     */
+    protected array $configHints = [];
+
     /**
      * Is this a required step?
      */
@@ -23,7 +28,7 @@ abstract class PreflightCheck
 
     public function __construct(array $options = [])
     {
-        $this->options = $options;
+        $this->loadOptions($options);
         $this->boot();
     }
 
@@ -65,6 +70,18 @@ protected function boot(): void
     {
     }
 
+    /**
+     * Parses the options
+     */
+    protected function loadOptions(array $options = [])
+    {
+        if (array_key_exists('config_hints', $options)) {
+            $this->configHints = $options['config_hints'];
+            unset($options['config_hints']);
+        }
+        $this->options = $options;
+    }
+
     /**
      * Initializes a result object.
      */
@@ -112,7 +129,10 @@ protected function checkConfig(Result $result): Result
         }
 
         if (! empty($missingKeys)) {
-            return $result->fail('Missing configuration key(s).', $missingKeys);
+            return $result->fail(
+                $this->getConfigFailMessage($missingKeys),
+                $this->getConfigFailKeyData($missingKeys),
+            );
         }
 
         return $result->pass($this->getConfigPassMessage(), $this->requiredConfig);
@@ -125,4 +145,25 @@ protected function getConfigPassMessage()
     {
         return 'Config keys are set!';
     }
+
+    /**
+     * Gets the message for failed key check.
+     */
+    protected function getConfigFailMessage(array $missingKeys = [])
+    {
+        return 'Missing configuration key(s).';
+    }
+
+    /**
+     * Gets the key data for missing keys.
+     */
+    protected function getConfigFailKeyData(array $missingKeys = [])
+    {
+        return array_map(function ($key) {
+            return array_filter([
+                'key' => $key,
+                'hint' => $this->configHints[$key] ?? null,
+            ]);
+        }, $missingKeys);
+    }
 }

src/Checks/Redis.php

@@ -7,10 +7,7 @@
 class Redis extends PreflightCheck
 {
     protected array $requiredConfig = [
-        'database.redis.default',
-        'database.redis.default.host',
-        'database.redis.default.password',
-        'database.redis.default.port',
+        // @see boot()
     ];
 
     /**
@@ -21,13 +18,13 @@ class Redis extends PreflightCheck
     public function check(Result $result): Result
     {
         try {
-            $connection = RedisFacade::connection();
+            $connection = RedisFacade::connection($this->getConnection());
         } catch (\Exception $e) {
             return $result->fail($e->getMessage(), $e);
         }
 
         if (! $connection->client()->isConnected()) {
-            return $result->fail('Could not connect to Redis');
+            return $result->fail('Could not connect to Redis ('.$this->getConnection().')');
         }
         $info = $connection->client()->info();
 
@@ -39,4 +36,32 @@ public function check(Result $result): Result
             ],
         ]);
     }
+
+    /**
+     * Gets the DB connection to check (as specified in database.config).
+     */
+    protected function getConnection(): string
+    {
+        return $this->options['connection'] ?? 'default';
+    }
+
+    /**
+     * Boots the check
+     */
+    protected function boot(): void
+    {
+        $connection = $this->getConnection();
+        $usesAuth = $this->options['auth'] ?? true;
+
+        $this->requiredConfig = array_merge(
+            $this->requiredConfig,
+            [
+                "database.redis.${connection}.host",
+                "database.redis.${connection}.port",
+            ],
+            $usesAuth ? [
+                "database.redis.${connection}.password",
+            ] : []
+        );
+    }
 }

src/Commands/PreflightCheckCommand.php

@@ -91,7 +91,7 @@ public function handle(Pipeline $pipeline)
      */
     protected function bootChecks()
     {
-        $environment = strtolower(App::environment());
+        $this->environment = $environment = strtolower(App::environment());
 
         try {
             if (! config()->has("preflight.checks.{$environment}")) {

tests/Checks/BasePreflightCheckTest.php

@@ -55,7 +55,7 @@ private function assertConfigKeyChecked(PreflightCheck $preflightCheck, string $
         config([$configKey => null]);
 
         $configResult = $this->invokeMethod($preflightCheck, 'checkConfig', [new Result('Test\Config')]);
-        $this->assertTrue(in_array($configKey, $configResult->getRawData()));
+        $this->assertTrue(in_array($configKey, array_column($configResult->getRawData(), 'key')));
 
         config([$configKey => $originalValue]);
     }

tests/Checks/ConfigurationTest.php

@@ -38,7 +38,33 @@ public function testFailsWhenConfigIsNotSet()
         $result = $preflightCheck->check(new Result('Test\Test'));
         $this->assertFailed($result);
         $data = $result->getRawData();
-        $this->assertTrue(in_array($config[0], $data));
-        $this->assertTrue(in_array($config[1], $data));
+        $foundKeys = array_column($data, 'key');
+        $this->assertTrue(in_array($config[0], $foundKeys));
+        $this->assertTrue(in_array($config[1], $foundKeys));
+    }
+
+    /**
+     * @test
+     */
+    public function testLoadsConfigHints()
+    {
+        $config = [
+            'test1' => uniqid('test1'),
+            'test2',
+        ];
+        $preflightCheck = new Configuration($config);
+
+        $result = $preflightCheck->check(new Result('Test\Test'));
+        $this->assertFailed($result);
+        $data = $result->getRawData();
+
+        // first key
+        $this->assertEquals('test1', $data[0]['key']);
+        $this->assertEquals($config['test1'], $data[0]['hint']);
+
+        // second key
+        $this->assertEquals('test2', $data[1]['key']);
+        // No hint set, so this is filtered out
+        $this->assertArrayNotHasKey('hint', $data[1]);
     }
 }

tests/Checks/PreflightCheckTest.php

@@ -157,4 +157,28 @@ public function check(Result $result): Result
         $this->assertTrue($report[1]->required());
         $this->assertFalse($report[1]->skipped());
     }
+
+    /**
+     * @test
+     */
+    public function testLoadsConfigHintsFromOptions()
+    {
+        $hints = ['banana' => 'a fruit', 'cucumber' => 'a vegetable'];
+        $check = new class(['config_hints' => $hints]) extends PreflightCheck {
+            protected array $requiredConfig = [];
+
+            public function check(Result $result): Result
+            {
+                return $result->pass();
+            }
+
+            // For testing
+            public function getConfigHints()
+            {
+                return $this->configHints;
+            }
+        };
+
+        $this->assertEquals($hints, $check->getConfigHints());
+    }
 }

tests/Checks/RedisTest.php

@@ -14,12 +14,14 @@ class RedisTest extends BasePreflightCheckTest
 
     /**
      * @test
+     * @dataProvider providesConnectionScenarios
      */
-    public function testChecksRedisIsAccessible()
+    public function testChecksRedisIsAccessible($options, $expectedConnection)
     {
         $mockConnection = Mockery::mock(Connection::class);
         RedisFacade::shouldReceive('connection')
             ->once()
+            ->with($expectedConnection)
             ->andReturn($mockConnection);
 
         $connectionName = 'TestRedis';
@@ -31,7 +33,7 @@ public function testChecksRedisIsAccessible()
         $mockConnection->shouldReceive('getName')->once()->andReturn($connectionName);
         $mockConnection->shouldReceive('client->info')->once()->andReturn($connectionInfo);
 
-        $preflightCheck = new $this->preflightCheckClass();
+        $preflightCheck = new $this->preflightCheckClass($options);
         $result = $preflightCheck->check(new Result('Test\Test'));
 
         $this->assertPassed($result);
@@ -41,6 +43,27 @@ public function testChecksRedisIsAccessible()
         $this->assertEquals($connectionInfo['os'], $resultData['info']['os']);
     }
 
+    public function providesConnectionScenarios()
+    {
+        return [
+            'No options is default' => [
+                [], 'default',
+            ],
+            'Default is default' => [
+                [
+                    'connection' => 'default',
+                ],
+                'default',
+            ],
+            'Banana is banana' => [
+                [
+                    'connection' => 'banana',
+                ],
+                'banana',
+            ],
+        ];
+    }
+
     /**
      * @test
      */
@@ -85,4 +108,17 @@ public function testChecksConfigValues()
     {
         $this->checkConfigValues(new $this->preflightCheckClass());
     }
+
+    /**
+     * @test
+     */
+    public function testDoesNotCheckPasswordForNoAuthConfig()
+    {
+        $check = new $this->preflightCheckClass(['auth' => false]);
+
+        $this->assertArrayNotHasKey(
+            'database.redis.default.password',
+            $this->getProtectedProperty($check, 'requiredConfig')
+        );
+    }
 }