FixtureController.php 14.7 KB
Newer Older
Mark committed
1 2 3 4 5 6 7 8 9 10 11
<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace yii\console\controllers;

use Yii;
use yii\console\Controller;
12
use yii\console\Exception;
Mark committed
13
use yii\helpers\Console;
Qiang Xue committed
14 15
use yii\helpers\FileHelper;
use yii\test\FixtureTrait;
Mark committed
16 17

/**
Qiang Xue committed
18
 * Manages fixture data loading and unloading.
Qiang Xue committed
19
 *
Mark committed
20
 * ~~~
Mark committed
21
 * #load fixtures from UsersFixture class with default namespace "tests\unit\fixtures"
Mark committed
22
 * yii fixture/load User
Qiang Xue committed
23
 *
Mark committed
24
 * #also a short version of this command (generate action is default)
Mark committed
25
 * yii fixture User
Qiang Xue committed
26
 *
Qiang Xue committed
27
 * #load all fixtures
28
 * yii fixture "*"
Qiang Xue committed
29
 *
30
 * #load all fixtures except User
31
 * yii fixture "*" -User
Qiang Xue committed
32
 *
Mark committed
33
 * #load fixtures with different namespace.
Mark committed
34
 * yii fixture/load User --namespace=alias\my\custom\namespace\goes\here
Mark committed
35
 * ~~~
Qiang Xue committed
36
 *
Qiang Xue committed
37
 * The `unload` sub-command can be used similarly to unload fixtures.
38
 *
Mark committed
39 40 41 42 43
 * @author Mark Jebri <mark.github@yandex.ru>
 * @since 2.0
 */
class FixtureController extends Controller
{
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
    use FixtureTrait;

    /**
     * @var string controller default action ID.
     */
    public $defaultAction = 'load';
    /**
     * @var string default namespace to search fixtures in
     */
    public $namespace = 'tests\unit\fixtures';
    /**
     * @var array global fixtures that should be applied when loading and unloading. By default it is set to `InitDbFixture`
     * that disables and enables integrity check, so your data can be safely loaded.
     */
    public $globalFixtures = [
        'yii\test\InitDb',
    ];

62

63
    /**
64
     * @inheritdoc
65
     */
Alexander Makarov committed
66
    public function options($actionID)
67
    {
Alexander Makarov committed
68
        return array_merge(parent::options($actionID), [
69
            'namespace', 'globalFixtures'
70 71 72 73
        ]);
    }

    /**
Qiang Xue committed
74 75 76 77 78 79 80 81 82
     * Loads the specified fixture data.
     * For example,
     *
     * ~~~
     * # load the fixture data specified by User and UserProfile.
     * # any existing fixture data will be removed first
     * yii fixture/load User UserProfile
     *
     * # load all available fixtures found under 'tests\unit\fixtures'
83
     * yii fixture/load "*"
Qiang Xue committed
84 85
     *
     * # load all fixtures except User and UserProfile
86
     * yii fixture/load "*" -User -UserProfile
Qiang Xue committed
87 88 89
     * ~~~
     *
     * @throws Exception if the specified fixture does not exist.
90
     */
91
    public function actionLoad()
92
    {
93
        $fixturesInput = func_get_args();
94 95 96 97 98 99 100 101 102
        if ($fixturesInput === []) {
            $this->stdout($this->getHelpSummary() . "\n");

            $helpCommand = Console::ansiFormat("yii help fixture", [Console::FG_CYAN]);
            $this->stdout("Use $helpCommand to get usage info.\n");

            return self::EXIT_CODE_NORMAL;
        }

103 104 105 106 107 108
        $filtered = $this->filterFixtures($fixturesInput);
        $except = $filtered['except'];

        if (!$this->needToApplyAll($fixturesInput[0])) {

            $fixtures = $filtered['apply'];
109 110

            $foundFixtures = $this->findFixtures($fixtures);
111 112 113 114 115
            $notFoundFixtures = array_diff($fixtures, $foundFixtures);

            if ($notFoundFixtures) {
                $this->notifyNotFound($notFoundFixtures);
            }
116 117 118

        } else {
            $foundFixtures = $this->findFixtures();
119 120
        }

121 122
        $fixturesToLoad = array_diff($foundFixtures, $except);

123
        if (!$foundFixtures) {
124
            throw new Exception(
125
                "No files were found by name: \"" . implode(', ', $fixturesInput) . "\".\n" .
126
                "Check that files with these name exists, under fixtures path: \n\"" . $this->getFixturePath() . "\"."
127 128 129
            );
        }

130 131 132
        if (!$fixturesToLoad) {
            $this->notifyNothingToLoad($foundFixtures, $except);
            return static::EXIT_CODE_NORMAL;
133 134
        }

135 136 137 138 139
        if (!$this->confirmLoad($fixturesToLoad, $except)) {
            return static::EXIT_CODE_NORMAL;
        }

        $fixtures = $this->getFixturesConfig(array_merge($this->globalFixtures, $fixturesToLoad));
140 141 142 143 144 145

        if (!$fixtures) {
            throw new Exception('No fixtures were found in namespace: "' . $this->namespace . '"' . '');
        }

        $fixturesObjects = $this->createFixtures($fixtures);
146

147
        $this->unloadFixtures($fixturesObjects);
148 149
        $this->loadFixtures($fixturesObjects);
        $this->notifyLoaded($fixtures);
150 151

        return static::EXIT_CODE_NORMAL;
152 153 154
    }

    /**
Qiang Xue committed
155 156 157 158 159 160 161 162
     * Unloads the specified fixtures.
     * For example,
     *
     * ~~~
     * # unload the fixture data specified by User and UserProfile.
     * yii fixture/unload User UserProfile
     *
     * # unload all fixtures found under 'tests\unit\fixtures'
163
     * yii fixture/unload "*"
Qiang Xue committed
164 165
     *
     * # unload all fixtures except User and UserProfile
166
     * yii fixture/unload "*" -User -UserProfile
Qiang Xue committed
167 168 169
     * ~~~
     *
     * @throws Exception if the specified fixture does not exist.
170
     */
171
    public function actionUnload()
172
    {
173 174 175 176 177 178 179 180
        $fixturesInput = func_get_args();
        $filtered = $this->filterFixtures($fixturesInput);
        $except = $filtered['except'];

        if (!$this->needToApplyAll($fixturesInput[0])) {

            $fixtures = $filtered['apply'];

181
            $foundFixtures = $this->findFixtures($fixtures);
182 183 184 185 186
            $notFoundFixtures = array_diff($fixtures, $foundFixtures);

            if ($notFoundFixtures) {
                $this->notifyNotFound($notFoundFixtures);
            }
187

188 189
        } else {
            $foundFixtures = $this->findFixtures();
190 191
        }

192 193
        $fixturesToUnload = array_diff($foundFixtures, $except);

194
        if (!$foundFixtures) {
195
            throw new Exception(
196 197
                "No files were found by name: \"" . implode(', ', $fixturesInput) . "\".\n" .
                "Check that files with these name exists, under fixtures path: \n\"" . $this->getFixturePath() . "\"."
198 199 200
            );
        }

201 202 203 204 205 206 207
        if (!$fixturesToUnload) {
            $this->notifyNothingToUnload($foundFixtures, $except);
            return static::EXIT_CODE_NORMAL;
        }

        if (!$this->confirmUnload($fixturesToUnload, $except)) {
            return static::EXIT_CODE_NORMAL;
208 209
        }

210
        $fixtures = $this->getFixturesConfig(array_merge($this->globalFixtures, $fixturesToUnload));
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230

        if (!$fixtures) {
            throw new Exception('No fixtures were found in namespace: ' . $this->namespace . '".');
        }

        $this->unloadFixtures($this->createFixtures($fixtures));
        $this->notifyUnloaded($fixtures);
    }

    /**
     * Notifies user that fixtures were successfully loaded.
     * @param array $fixtures
     */
    private function notifyLoaded($fixtures)
    {
        $this->stdout("Fixtures were successfully loaded from namespace:\n", Console::FG_YELLOW);
        $this->stdout("\t\"" . Yii::getAlias($this->namespace) . "\"\n\n", Console::FG_GREEN);
        $this->outputList($fixtures);
    }

231 232
    /**
     * Notifies user that there are no fixtures to load according input conditions
233 234
     * @param array $foundFixtures array of found fixtures
     * @param array $except array of names of fixtures that should not be loaded
235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
     */
    public function notifyNothingToLoad($foundFixtures, $except)
    {
        $this->stdout("Fixtures to load could not be found according given conditions:\n\n", Console::FG_RED);
        $this->stdout("Fixtures namespace is: \n", Console::FG_YELLOW);
        $this->stdout("\t" . $this->namespace . "\n", Console::FG_GREEN);

        if (count($foundFixtures)) {
            $this->stdout("\nFixtures founded under the namespace:\n\n", Console::FG_YELLOW);
            $this->outputList($foundFixtures);
        }

        if (count($except)) {
            $this->stdout("\nFixtures that will NOT be loaded: \n\n", Console::FG_YELLOW);
            $this->outputList($except);
        }
    }

    /**
     * Notifies user that there are no fixtures to unload according input conditions
255 256
     * @param array $foundFixtures array of found fixtures
     * @param array $except array of names of fixtures that should not be loaded
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
     */
    public function notifyNothingToUnload($foundFixtures, $except)
    {
        $this->stdout("Fixtures to unload could not be found according given conditions:\n\n", Console::FG_RED);
        $this->stdout("Fixtures namespace is: \n", Console::FG_YELLOW);
        $this->stdout("\t" . $this->namespace . "\n", Console::FG_GREEN);

        if (count($foundFixtures)) {
            $this->stdout("\nFixtures founded under the namespace:\n\n", Console::FG_YELLOW);
            $this->outputList($foundFixtures);
        }

        if (count($except)) {
            $this->stdout("\nFixtures that will NOT be unloaded: \n\n", Console::FG_YELLOW);
            $this->outputList($except);
        }
    }

275 276 277 278 279 280
    /**
     * Notifies user that fixtures were successfully unloaded.
     * @param array $fixtures
     */
    private function notifyUnloaded($fixtures)
    {
281 282
        $this->stdout("\nFixtures were successfully unloaded from namespace: ", Console::FG_YELLOW);
        $this->stdout(Yii::getAlias($this->namespace) . "\"\n\n", Console::FG_GREEN);
283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
        $this->outputList($fixtures);
    }

    /**
     * Notifies user that fixtures were not found under fixtures path.
     * @param array $fixtures
     */
    private function notifyNotFound($fixtures)
    {
        $this->stdout("Some fixtures were not found under path:\n", Console::BG_RED);
        $this->stdout("\t" . $this->getFixturePath() . "\n\n", Console::FG_GREEN);
        $this->stdout("Check that they have correct namespace \"{$this->namespace}\" \n", Console::BG_RED);
        $this->outputList($fixtures);
        $this->stdout("\n");
    }

    /**
     * Prompts user with confirmation if fixtures should be loaded.
301 302
     * @param array $fixtures
     * @param array $except
303 304 305 306 307 308 309 310
     * @return boolean
     */
    private function confirmLoad($fixtures, $except)
    {
        $this->stdout("Fixtures namespace is: \n", Console::FG_YELLOW);
        $this->stdout("\t" . $this->namespace . "\n\n", Console::FG_GREEN);

        if (count($this->globalFixtures)) {
311
            $this->stdout("Global fixtures will be used:\n\n", Console::FG_YELLOW);
312 313 314
            $this->outputList($this->globalFixtures);
        }

315 316 317 318
        if (count($fixtures)) {
            $this->stdout("\nFixtures below will be loaded:\n\n", Console::FG_YELLOW);
            $this->outputList($fixtures);
        }
319 320 321 322 323 324 325 326 327 328 329

        if (count($except)) {
            $this->stdout("\nFixtures that will NOT be loaded: \n\n", Console::FG_YELLOW);
            $this->outputList($except);
        }

        return $this->confirm("\nLoad above fixtures?");
    }

    /**
     * Prompts user with confirmation for fixtures that should be unloaded.
330 331
     * @param array $fixtures
     * @param array $except
332 333 334 335 336 337 338 339
     * @return boolean
     */
    private function confirmUnload($fixtures, $except)
    {
        $this->stdout("Fixtures namespace is: \n", Console::FG_YELLOW);
        $this->stdout("\t" . $this->namespace . "\n\n", Console::FG_GREEN);

        if (count($this->globalFixtures)) {
340
            $this->stdout("Global fixtures will be used:\n\n", Console::FG_YELLOW);
341 342 343
            $this->outputList($this->globalFixtures);
        }

344 345 346 347
        if (count($fixtures)) {
            $this->stdout("\nFixtures below will be unloaded:\n\n", Console::FG_YELLOW);
            $this->outputList($fixtures);
        }
348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369

        if (count($except)) {
            $this->stdout("\nFixtures that will NOT be unloaded:\n\n", Console::FG_YELLOW);
            $this->outputList($except);
        }

        return $this->confirm("\nUnload fixtures?");
    }

    /**
     * Outputs data to the console as a list.
     * @param array $data
     */
    private function outputList($data)
    {
        foreach ($data as $index => $item) {
            $this->stdout("\t" . ($index + 1) . ". {$item}\n", Console::FG_GREEN);
        }
    }

    /**
     * Checks if needed to apply all fixtures.
370
     * @param string $fixture
371 372 373 374
     * @return bool
     */
    public function needToApplyAll($fixture)
    {
Qiang Xue committed
375
        return $fixture == '*';
376 377 378
    }

    /**
379 380 381
     * Finds fixtures to be loaded, for example "User", if no fixtures were specified then all of them 
     * will be searching by suffix "Fixture.php".
     * @param array $fixtures fixtures to be loaded
382 383
     * @return array Array of found fixtures. These may differ from input parameter as not all fixtures may exists.
     */
384
    private function findFixtures(array $fixtures = [])
385 386 387 388
    {
        $fixturesPath = $this->getFixturePath();

        $filesToSearch = ['*Fixture.php'];
389 390 391 392
        $findAll = ($fixtures == []);

        if (!$findAll) {

393
            $filesToSearch = [];
394

395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
            foreach ($fixtures as $fileName) {
                $filesToSearch[] = $fileName . 'Fixture.php';
            }
        }

        $files = FileHelper::findFiles($fixturesPath, ['only' => $filesToSearch]);
        $foundFixtures = [];

        foreach ($files as $fixture) {
            $foundFixtures[] = basename($fixture, 'Fixture.php');
        }

        return $foundFixtures;
    }

    /**
     * Returns valid fixtures config that can be used to load them.
412
     * @param array $fixtures fixtures to configure
413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
     * @return array
     */
    private function getFixturesConfig($fixtures)
    {
        $config = [];

        foreach ($fixtures as $fixture) {

            $isNamespaced = (strpos($fixture, '\\') !== false);
            $fullClassName = $isNamespaced ? $fixture . 'Fixture' : $this->namespace . '\\' . $fixture . 'Fixture';

            if (class_exists($fullClassName)) {
                $config[] = $fullClassName;
            }
        }

        return $config;
    }

432
    /**
Qiang Xue committed
433
     * Filters fixtures by splitting them in two categories: one that should be applied and not.
434
     * If fixture is prefixed with "-", for example "-User", that means that fixture should not be loaded,
munawer committed
435
     * if it is not prefixed it is considered as one to be loaded. Returns array:
436 437 438 439
     * 
     * ~~~
     * [
     *     'apply' => [
440
     *         'User',
441 442 443
     *         ...
     *     ],
     *     'except' => [
444
     *         'Custom',
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
     *         ...
     *     ],
     * ]
     * ~~~
     * @param array $fixtures
     * @return array fixtures array with 'apply' and 'except' elements.
     */
    private function filterFixtures($fixtures)
    {
        $filtered = [
            'apply' => [],
            'except' => [],
        ];

        foreach ($fixtures as $fixture) {
            if (mb_strpos($fixture, '-') !== false) {
                $filtered['except'][] = str_replace('-', '', $fixture);
            } else {
                $filtered['apply'][] = $fixture;                
            }
        }

        return $filtered;
    }

470 471 472 473 474 475 476 477
    /**
     * Returns fixture path that determined on fixtures namespace.
     * @return string fixture path
     */
    private function getFixturePath()
    {
        return Yii::getAlias('@' . str_replace('\\', '/', $this->namespace));
    }
478

Mark committed
479
}