FileGeneratorTest::testCreateTransformer() - Code Metrics - Inspection of "Progress generator. Need to finish module generato..." - deviouspk/larapi - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 590453...ad5a85 )

by Arthur

created 2019-03-16 20:00 UTC

FileGeneratorTest::testCreateTransformer() A

↳ Parent: FileGeneratorTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	23
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	17
nc	1
nop	0
dl	0
loc	23
rs	9.7
c	0
b	0
f	0

<?php

namespace Foundation\Tests;

use Foundation\Abstracts\Tests\TestCase;
use Foundation\Core\Larapi;
use Foundation\Generator\Events\CommandGeneratedEvent;
use Foundation\Generator\Events\ComposerGeneratedEvent;
use Foundation\Generator\Events\ControllerGeneratedEvent;
use Foundation\Generator\Events\FactoryGeneratedEvent;
use Foundation\Generator\Events\JobGeneratedEvent;
use Foundation\Generator\Events\ListenerGeneratedEvent;
use Foundation\Generator\Events\MiddlewareGeneratedEvent;
use Foundation\Generator\Events\MigrationGeneratedEvent;
use Foundation\Generator\Events\ModelGeneratedEvent;
use Foundation\Generator\Events\NotificationGeneratedEvent;
use Foundation\Generator\Events\PolicyGeneratedEvent;
use Foundation\Generator\Events\ProviderGeneratedEvent;
use Foundation\Generator\Events\RequestGeneratedEvent;
use Foundation\Generator\Events\RouteGeneratedEvent;
use Foundation\Generator\Events\RuleGeneratedEvent;
use Foundation\Generator\Events\SeederGeneratedEvent;
use Foundation\Generator\Events\TestGeneratedEvent;
use Foundation\Generator\Events\TransformerGeneratedEvent;
use Foundation\Generator\Managers\GeneratorManager;
use Foundation\Traits\DispatchedEvents;
use Foundation\Traits\DisableRefreshDatabase;
use \Illuminate\Support\Facades\Event;
use Illuminate\Support\Str;

/**
 * Created by PhpStorm.
 * User: arthur
 * Date: 10.03.19
 * Time: 18:35
 */
class FileGeneratorTest extends TestCase
{
    use DisableRefreshDatabase, DispatchedEvents;

    public function setUp(): void
    {
        parent::setUp();

        /* Do not remove this line. It prevents the listener that generates the files from executing */
        Event::fake();
    }

    protected function getModuleGenerator(string $moduleName) :GeneratorManager{
       return GeneratorManager::module($moduleName,true);
    }

    public function testCreateSqlMigration()
    {
        $moduleName = 'User';
        $this->getModuleGenerator($moduleName)->createMigration("CreateUserTable", 'users', false);

        $module = Larapi::getModule($moduleName);
        $expectedDirectoryPath = $module->getMigrations()->getPath();
        $expectedStubName = "migration.stub";
        $expectedStubOptions = [
            'CLASS' => 'CreateUserTable',
            'NAMESPACE' => $module->getMigrations()->getNamespace(),
            'TABLE' => 'users',
            'MODULE' => 'User'
        ];

        $event = $this->getFirstDispatchedEvent(MigrationGeneratedEvent::class);

        $this->assertNotNull($event);
        $this->assertStringContainsString($expectedDirectoryPath, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateMongoMigration()
    {
        $this->getModuleGenerator('User')->createMigration("CreateUserCollection", 'users', true);
        $event = $this->getFirstDispatchedEvent(MigrationGeneratedEvent::class);
        $this->assertNotNull($event);
        $this->assertEquals("migration-mongo.stub", $event->getStub()->getName());
    }

    public function testCreateFactory()
    {
        $moduleName = "User";
        $this->getModuleGenerator($moduleName)->createFactory( "User");

        $expectedFileName = Larapi::getModule($moduleName)->getFactories()->getPath() . '/UserFactory.php';
        $expectedStubName = "factory.stub";
        $expectedStubOptions = [
            'CLASS' => 'UserFactory',
            'MODEL' => 'User',
            'MODEL_NAMESPACE' => 'Modules\User\Entities\User',
            'MODULE' => 'User'
        ];

        $event = $this->getFirstDispatchedEvent(FactoryGeneratedEvent::class);

        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateController()
    {
        $moduleName = "User";
        $this->getModuleGenerator($moduleName)->createController( "UserController");

        $expectedFileName = Larapi::getModule($moduleName)->getControllers()->getPath() . '/UserController.php';
        $expectedStubName = "controller.stub";
        $expectedStubOptions = [
            'CLASS' => 'UserController',
            'NAMESPACE' => 'Modules\User\Http\Controllers',
            'MODULE' => 'User'
        ];

        $event = $this->getFirstDispatchedEvent(ControllerGeneratedEvent::class);

        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateListener()
    {
        $moduleName = "User";
        $this->getModuleGenerator($moduleName)->createListener("SendWelcomeMail", "UserRegisteredEvent");

        $expectedFileName = Larapi::getModule($moduleName)->getListeners()->getPath() . '/SendWelcomeMail.php';
        $expectedStubName = "listener.stub";
        $expectedStubOptions = [
            'CLASS' => 'SendWelcomeMail',
            'NAMESPACE' => 'Modules\User\Listeners',
            'EVENTNAME' => 'Modules\User\Events\UserRegisteredEvent',
            'SHORTEVENTNAME' => 'UserRegisteredEvent',
            'MODULE' => 'User'
        ];

        $event = $this->getFirstDispatchedEvent(ListenerGeneratedEvent::class);

        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateQueuedListener()
    {
        $moduleName = "User";
        $this->getModuleGenerator($moduleName)->createListener("SendWelcomeMail", "UserRegisteredEvent", true);
        $event = $this->getFirstDispatchedEvent(ListenerGeneratedEvent::class);

        $this->assertNotNull($event);
        $this->assertEquals("listener-queued.stub", $event->getStub()->getName());
    }

    public function testCreateJob()
    {
        $moduleName = "User";
        $fileName = "RandomUserJob";
        $this->getModuleGenerator($moduleName)->createJob($fileName, false);

        $expectedFileName = Larapi::getModule($moduleName)->getJobs()->getPath() . "/$fileName.php";
        $expectedStubName = "job-queued.stub";
        $expectedStubOptions = [
            'NAMESPACE' => 'Modules\User\Jobs',
            'CLASS' => 'RandomUserJob',
            'MODULE' => 'User'
        ];

        $event = $this->getFirstDispatchedEvent(JobGeneratedEvent::class);

        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateSynchronousJob()
    {
        $moduleName = "User";
        $this->getModuleGenerator($moduleName)->createJob( "AJob", true);
        $event = $this->getFirstDispatchedEvent(JobGeneratedEvent::class);

        $this->assertNotNull($event);
        $this->assertEquals("job.stub", $event->getStub()->getName());
    }

    public function testCreateCommand()
    {
        $moduleName = "User";
        $fileName = "RandomCommand";
        $commandName = "user:dosomethingrandom";

        $this->getModuleGenerator($moduleName)->createCommand($fileName, $commandName);

        $expectedFileName = Larapi::getModule($moduleName)->getCommands()->getPath() . "/$fileName.php";
        $expectedStubName = "command.stub";
        $expectedStubOptions = [
            'NAMESPACE' => 'Modules\User\Console',
            'CLASS' => 'RandomCommand',
            'COMMAND_NAME' => $commandName,
            'MODULE' => 'User'
        ];

        /* @var CommandGeneratedEvent $event */
        $event = $this->getFirstDispatchedEvent(CommandGeneratedEvent::class);

        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());

        $this->assertEquals($commandName,$event->getConsoleCommand());
        //$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateMiddleware()
    {
        $moduleName = "User";
        $fileName = "RandomMiddleware";

        $this->getModuleGenerator($moduleName)->createMiddleware($fileName);

        $expectedFileName = Larapi::getModule($moduleName)->getMiddleWare()->getPath() . "/$fileName.php";
        $expectedStubName = "middleware.stub";
        $expectedStubOptions = [
            'CLASS' => 'RandomMiddleware',
            'NAMESPACE' => 'Modules\User\Http\Middleware',
            'MODULE' => 'User'
        ];

        $event = $this->getFirstDispatchedEvent(MiddlewareGeneratedEvent::class);

        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateProvider()
    {
        $moduleName = "User";
        $fileName = "RandomServiceProvider";

        $this->getModuleGenerator($moduleName)->createServiceProvider($fileName);

        $expectedFileName = Larapi::getModule($moduleName)->getServiceProviders()->getPath() . "/$fileName.php";
        $expectedStubName = "provider.stub";
        $expectedStubOptions = [
            'NAMESPACE' => 'Modules\User\Providers',
            'CLASS' => 'RandomServiceProvider',
            'MODULE' => 'User'
        ];

        $event = $this->getFirstDispatchedEvent(ProviderGeneratedEvent::class);

        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateNotification()
    {
        $moduleName = "User";
        $fileName = "RandomNotification";

        $this->getModuleGenerator($moduleName)->createNotification($fileName);

        $expectedFileName = Larapi::getModule($moduleName)->getNotifications()->getPath() . "/$fileName.php";
        $expectedStubName = "notification.stub";
        $expectedStubOptions = [
            'NAMESPACE' => 'Modules\User\Notifications',
            'CLASS' => 'RandomNotification',
            'MODULE' => 'User'
        ];

        $event = $this->getFirstDispatchedEvent(NotificationGeneratedEvent::class);

        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateModel()
    {
        $moduleName = "User";
        $fileName = "Address";

        $this->getModuleGenerator($moduleName)->createModel($fileName, false, true);

        $expectedFileName = Larapi::getModule($moduleName)->getModels()->getPath() . "/$moduleName$fileName.php";
        $expectedStubName = "model.stub";
        $expectedStubOptions = [
            'NAMESPACE' => 'Modules\User\Entities',
            'CLASS' => 'UserAddress',
            'MODULE' => 'User'
        ];

        $modelEvent = $this->getFirstDispatchedEvent(ModelGeneratedEvent::class);
        $this->assertNotNull($modelEvent);
        $this->assertEquals($expectedFileName, $modelEvent->getFilePath());
        $this->assertEquals($expectedStubName, $modelEvent->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $modelEvent->getStub()->getOptions());

        $expectedStubName = "migration.stub";
        $expectedStubOptions = [
            'CLASS' => 'CreateUserAddressTable',
            'NAMESPACE' => 'Modules\User\Database\Migrations',
            'TABLE' => 'user_addresses',
            'MODULE' => 'User'
        ];

        $migrationEvent = $this->getFirstDispatchedEvent(MigrationGeneratedEvent::class);
        $this->assertNotNull($migrationEvent);
        $this->assertEquals($expectedStubName, $migrationEvent->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $migrationEvent->getStub()->getOptions());
    }

    public function testCreatePolicy()
    {
        $moduleName = "User";
        $fileName = "UserOwnershipPolicy";

        $this->getModuleGenerator($moduleName)->createPolicy($fileName);

        $expectedFileName = Larapi::getModule($moduleName)->getPolicies()->getPath() . "/$fileName.php";
        $expectedStubName = "policy.stub";
        $expectedStubOptions = [
            'NAMESPACE' => 'Modules\User\Policies',
            'CLASS' => 'UserOwnershipPolicy',
            'MODULE' => 'User'
        ];

        $event = $this->getFirstDispatchedEvent(PolicyGeneratedEvent::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateTransformer()
    {
        $moduleName = "User";
        $model = "User";
        $fileName = "BlablaTransformer";

        $this->getModuleGenerator($moduleName)->createTransformer($fileName, $model);

        $expectedFileName = Larapi::getModule($moduleName)->getTransformers()->getPath() . "/$fileName.php";
        $expectedStubName = "transformer.stub";
        $expectedStubOptions = [
            'NAMESPACE' => 'Modules\User\Transformers',
            'CLASS' => 'BlablaTransformer',
            'MODEL' => 'User',
            'MODEL_NAMESPACE' => 'Modules\User\Entities\User',
            'MODULE' => 'User'
        ];

        $event = $this->getFirstDispatchedEvent(TransformerGeneratedEvent::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateUnitTest()
    {
        $moduleName = "User";
        $fileName = "AUserUnitTest";

        $this->getModuleGenerator($moduleName)->createTest($fileName, 'unit');

        $expectedFileName = Larapi::getModule($moduleName)->getTests()->getPath() . "/$fileName.php";
        $expectedStubName = "unit-test.stub";
        $expectedStubOptions = [
            'NAMESPACE' => 'Modules\User\Tests',
            'CLASS' => $fileName,
            'MODULE' => $moduleName,
            'TYPE' => 'unit'
        ];

        $event = $this->getFirstDispatchedEvent(TestGeneratedEvent::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateRequest()
    {
        $moduleName = "User";
        $fileName = "ARequest";

        $this->getModuleGenerator($moduleName)->createRequest($fileName);

        $expectedFileName = Larapi::getModule($moduleName)->getRequests()->getPath() . "/$fileName.php";
        $expectedStubName = "request.stub";
        $expectedStubOptions = [
            'NAMESPACE' => 'Modules\User\Http\Requests',
            'CLASS' => $fileName,
            'MODULE' => $moduleName
        ];

        $event = $this->getFirstDispatchedEvent(RequestGeneratedEvent::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateRule()
    {
        $moduleName = "User";
        $fileName = "BlalkaRule";

        $this->getModuleGenerator($moduleName)->createRule($fileName);

        $expectedFileName = Larapi::getModule($moduleName)->getRules()->getPath() . "/$fileName.php";
        $expectedStubName = "rule.stub";
        $expectedStubOptions = [
            'NAMESPACE' => 'Modules\User\Rules',
            'CLASS' => 'BlalkaRule',
            'MODULE' => 'User'
        ];

        $event = $this->getFirstDispatchedEvent(RuleGeneratedEvent::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateSeeder()
    {
        $moduleName = "User";
        $fileName = "BlablaSeeder";

        $this->getModuleGenerator($moduleName)->createSeeder($fileName);

        $expectedFileName = Larapi::getModule($moduleName)->getSeeders()->getPath() . "/$fileName.php";
        $expectedStubName = "seeder.stub";
        $expectedStubOptions = [
            'NAMESPACE' => 'Modules\User\Database\Seeders',
            'CLASS' => 'BlablaSeeder',
            'MODULE' => 'User'
        ];

        $event = $this->getFirstDispatchedEvent(SeederGeneratedEvent::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateRoute()
    {
        $moduleName = "Demo";
        $routename = strtolower(Str::plural($moduleName)) . '.v1';

        $this->getModuleGenerator($moduleName)->createRoute();

        $expectedFileName = Larapi::getModule($moduleName)->getRoutes()->getPath() . "/$routename.php";
        $expectedStubName = "route.stub";
        $expectedStubOptions = [
            'MODULE_NAME' => 'Demo',
            'CAPS_MODULE_NAME' => 'DEMO',
            'VERSION' => 'v1',
            'MODULE' => 'Demo'
        ];

        $event = $this->getFirstDispatchedEvent(RouteGeneratedEvent::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

    public function testCreateComposer()
    {
        $moduleName = "Demo";

        $this->getModuleGenerator($moduleName)->createComposer();

        $expectedFileName = Larapi::getModule($moduleName)->getPath() . "/composer.json";
        $expectedStubName = "composer.stub";
        $expectedStubOptions = [
            'LOWER_MODULE_NAME' => 'demo',
            'AUTHOR_NAME' => 'arthur devious',
            'AUTHOR_MAIL' => '[email protected]',
            'MODULE' => 'Demo'
        ];

        $event = $this->getFirstDispatchedEvent(ComposerGeneratedEvent::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStub()->getName());
        $this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
    }

}


1			<?php
2
3			namespace Foundation\Tests;
4
5			use Foundation\Abstracts\Tests\TestCase;
6			use Foundation\Core\Larapi;
7			use Foundation\Generator\Events\CommandGeneratedEvent;
8			use Foundation\Generator\Events\ComposerGeneratedEvent;
9			use Foundation\Generator\Events\ControllerGeneratedEvent;
10			use Foundation\Generator\Events\FactoryGeneratedEvent;
11			use Foundation\Generator\Events\JobGeneratedEvent;
12			use Foundation\Generator\Events\ListenerGeneratedEvent;
13			use Foundation\Generator\Events\MiddlewareGeneratedEvent;
14			use Foundation\Generator\Events\MigrationGeneratedEvent;
15			use Foundation\Generator\Events\ModelGeneratedEvent;
16			use Foundation\Generator\Events\NotificationGeneratedEvent;
17			use Foundation\Generator\Events\PolicyGeneratedEvent;
18			use Foundation\Generator\Events\ProviderGeneratedEvent;
19			use Foundation\Generator\Events\RequestGeneratedEvent;
20			use Foundation\Generator\Events\RouteGeneratedEvent;
21			use Foundation\Generator\Events\RuleGeneratedEvent;
22			use Foundation\Generator\Events\SeederGeneratedEvent;
23			use Foundation\Generator\Events\TestGeneratedEvent;
24			use Foundation\Generator\Events\TransformerGeneratedEvent;
25			use Foundation\Generator\Managers\GeneratorManager;
26			use Foundation\Traits\DispatchedEvents;
27			use Foundation\Traits\DisableRefreshDatabase;
28			use \Illuminate\Support\Facades\Event;
29			use Illuminate\Support\Str;
30
31			/**
32			* Created by PhpStorm.
33			* User: arthur
34			* Date: 10.03.19
35			* Time: 18:35
36			*/
37			class FileGeneratorTest extends TestCase
38			{
39			use DisableRefreshDatabase, DispatchedEvents;
40
41			public function setUp(): void
42			{
43			parent::setUp();
44
45			/* Do not remove this line. It prevents the listener that generates the files from executing */
46			Event::fake();
47			}
48
49			protected function getModuleGenerator(string $moduleName) :GeneratorManager{
50			return GeneratorManager::module($moduleName,true);
51			}
52
53			public function testCreateSqlMigration()
54			{
55			$moduleName = 'User';
56			$this->getModuleGenerator($moduleName)->createMigration("CreateUserTable", 'users', false);
57
58			$module = Larapi::getModule($moduleName);
59			$expectedDirectoryPath = $module->getMigrations()->getPath();
60			$expectedStubName = "migration.stub";
61			$expectedStubOptions = [
62			'CLASS' => 'CreateUserTable',
63			'NAMESPACE' => $module->getMigrations()->getNamespace(),
64			'TABLE' => 'users',
65			'MODULE' => 'User'
66			];
67
68			$event = $this->getFirstDispatchedEvent(MigrationGeneratedEvent::class);
69
70			$this->assertNotNull($event);
71			$this->assertStringContainsString($expectedDirectoryPath, $event->getFilePath());
72			$this->assertEquals($expectedStubName, $event->getStub()->getName());
73			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
74			}
75
76			public function testCreateMongoMigration()
77			{
78			$this->getModuleGenerator('User')->createMigration("CreateUserCollection", 'users', true);
79			$event = $this->getFirstDispatchedEvent(MigrationGeneratedEvent::class);
80			$this->assertNotNull($event);
81			$this->assertEquals("migration-mongo.stub", $event->getStub()->getName());
82			}
83
84			public function testCreateFactory()
85			{
86			$moduleName = "User";
87			$this->getModuleGenerator($moduleName)->createFactory( "User");
88
89			$expectedFileName = Larapi::getModule($moduleName)->getFactories()->getPath() . '/UserFactory.php';
90			$expectedStubName = "factory.stub";
91			$expectedStubOptions = [
92			'CLASS' => 'UserFactory',
93			'MODEL' => 'User',
94			'MODEL_NAMESPACE' => 'Modules\User\Entities\User',
95			'MODULE' => 'User'
96			];
97
98			$event = $this->getFirstDispatchedEvent(FactoryGeneratedEvent::class);
99
100			$this->assertNotNull($event);
101			$this->assertEquals($expectedFileName, $event->getFilePath());
102			$this->assertEquals($expectedStubName, $event->getStub()->getName());
103			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
104			}
105
106			public function testCreateController()
107			{
108			$moduleName = "User";
109			$this->getModuleGenerator($moduleName)->createController( "UserController");
110
111			$expectedFileName = Larapi::getModule($moduleName)->getControllers()->getPath() . '/UserController.php';
112			$expectedStubName = "controller.stub";
113			$expectedStubOptions = [
114			'CLASS' => 'UserController',
115			'NAMESPACE' => 'Modules\User\Http\Controllers',
116			'MODULE' => 'User'
117			];
118
119			$event = $this->getFirstDispatchedEvent(ControllerGeneratedEvent::class);
120
121			$this->assertNotNull($event);
122			$this->assertEquals($expectedFileName, $event->getFilePath());
123			$this->assertEquals($expectedStubName, $event->getStub()->getName());
124			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
125			}
126
127			public function testCreateListener()
128			{
129			$moduleName = "User";
130			$this->getModuleGenerator($moduleName)->createListener("SendWelcomeMail", "UserRegisteredEvent");
131
132			$expectedFileName = Larapi::getModule($moduleName)->getListeners()->getPath() . '/SendWelcomeMail.php';
133			$expectedStubName = "listener.stub";
134			$expectedStubOptions = [
135			'CLASS' => 'SendWelcomeMail',
136			'NAMESPACE' => 'Modules\User\Listeners',
137			'EVENTNAME' => 'Modules\User\Events\UserRegisteredEvent',
138			'SHORTEVENTNAME' => 'UserRegisteredEvent',
139			'MODULE' => 'User'
140			];
141
142			$event = $this->getFirstDispatchedEvent(ListenerGeneratedEvent::class);
143
144			$this->assertNotNull($event);
145			$this->assertEquals($expectedFileName, $event->getFilePath());
146			$this->assertEquals($expectedStubName, $event->getStub()->getName());
147			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
148			}
149
150			public function testCreateQueuedListener()
151			{
152			$moduleName = "User";
153			$this->getModuleGenerator($moduleName)->createListener("SendWelcomeMail", "UserRegisteredEvent", true);
154			$event = $this->getFirstDispatchedEvent(ListenerGeneratedEvent::class);
155
156			$this->assertNotNull($event);
157			$this->assertEquals("listener-queued.stub", $event->getStub()->getName());
158			}
159
160			public function testCreateJob()
161			{
162			$moduleName = "User";
163			$fileName = "RandomUserJob";
164			$this->getModuleGenerator($moduleName)->createJob($fileName, false);
165
166			$expectedFileName = Larapi::getModule($moduleName)->getJobs()->getPath() . "/$fileName.php";
167			$expectedStubName = "job-queued.stub";
168			$expectedStubOptions = [
169			'NAMESPACE' => 'Modules\User\Jobs',
170			'CLASS' => 'RandomUserJob',
171			'MODULE' => 'User'
172			];
173
174			$event = $this->getFirstDispatchedEvent(JobGeneratedEvent::class);
175
176			$this->assertNotNull($event);
177			$this->assertEquals($expectedFileName, $event->getFilePath());
178			$this->assertEquals($expectedStubName, $event->getStub()->getName());
179			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
180			}
181
182			public function testCreateSynchronousJob()
183			{
184			$moduleName = "User";
185			$this->getModuleGenerator($moduleName)->createJob( "AJob", true);
186			$event = $this->getFirstDispatchedEvent(JobGeneratedEvent::class);
187
188			$this->assertNotNull($event);
189			$this->assertEquals("job.stub", $event->getStub()->getName());
190			}
191
192			public function testCreateCommand()
193			{
194			$moduleName = "User";
195			$fileName = "RandomCommand";
196			$commandName = "user:dosomethingrandom";
197
198			$this->getModuleGenerator($moduleName)->createCommand($fileName, $commandName);
199
200			$expectedFileName = Larapi::getModule($moduleName)->getCommands()->getPath() . "/$fileName.php";
201			$expectedStubName = "command.stub";
202			$expectedStubOptions = [
203			'NAMESPACE' => 'Modules\User\Console',
204			'CLASS' => 'RandomCommand',
205			'COMMAND_NAME' => $commandName,
206			'MODULE' => 'User'
207			];
208
209			/* @var CommandGeneratedEvent $event */
210			$event = $this->getFirstDispatchedEvent(CommandGeneratedEvent::class);
211
212			$this->assertNotNull($event);
213			$this->assertEquals($expectedFileName, $event->getFilePath());
214			$this->assertEquals($expectedStubName, $event->getStub()->getName());
215			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
216
217			$this->assertEquals($commandName,$event->getConsoleCommand());
218			//$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
219			}
220
221			public function testCreateMiddleware()
222			{
223			$moduleName = "User";
224			$fileName = "RandomMiddleware";
225
226			$this->getModuleGenerator($moduleName)->createMiddleware($fileName);
227
228			$expectedFileName = Larapi::getModule($moduleName)->getMiddleWare()->getPath() . "/$fileName.php";
229			$expectedStubName = "middleware.stub";
230			$expectedStubOptions = [
231			'CLASS' => 'RandomMiddleware',
232			'NAMESPACE' => 'Modules\User\Http\Middleware',
233			'MODULE' => 'User'
234			];
235
236			$event = $this->getFirstDispatchedEvent(MiddlewareGeneratedEvent::class);
237
238			$this->assertNotNull($event);
239			$this->assertEquals($expectedFileName, $event->getFilePath());
240			$this->assertEquals($expectedStubName, $event->getStub()->getName());
241			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
242			}
243
244			public function testCreateProvider()
245			{
246			$moduleName = "User";
247			$fileName = "RandomServiceProvider";
248
249			$this->getModuleGenerator($moduleName)->createServiceProvider($fileName);
250
251			$expectedFileName = Larapi::getModule($moduleName)->getServiceProviders()->getPath() . "/$fileName.php";
252			$expectedStubName = "provider.stub";
253			$expectedStubOptions = [
254			'NAMESPACE' => 'Modules\User\Providers',
255			'CLASS' => 'RandomServiceProvider',
256			'MODULE' => 'User'
257			];
258
259			$event = $this->getFirstDispatchedEvent(ProviderGeneratedEvent::class);
260
261			$this->assertNotNull($event);
262			$this->assertEquals($expectedFileName, $event->getFilePath());
263			$this->assertEquals($expectedStubName, $event->getStub()->getName());
264			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
265			}
266
267			public function testCreateNotification()
268			{
269			$moduleName = "User";
270			$fileName = "RandomNotification";
271
272			$this->getModuleGenerator($moduleName)->createNotification($fileName);
273
274			$expectedFileName = Larapi::getModule($moduleName)->getNotifications()->getPath() . "/$fileName.php";
275			$expectedStubName = "notification.stub";
276			$expectedStubOptions = [
277			'NAMESPACE' => 'Modules\User\Notifications',
278			'CLASS' => 'RandomNotification',
279			'MODULE' => 'User'
280			];
281
282			$event = $this->getFirstDispatchedEvent(NotificationGeneratedEvent::class);
283
284			$this->assertNotNull($event);
285			$this->assertEquals($expectedFileName, $event->getFilePath());
286			$this->assertEquals($expectedStubName, $event->getStub()->getName());
287			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
288			}
289
290			public function testCreateModel()
291			{
292			$moduleName = "User";
293			$fileName = "Address";
294
295			$this->getModuleGenerator($moduleName)->createModel($fileName, false, true);
296
297			$expectedFileName = Larapi::getModule($moduleName)->getModels()->getPath() . "/$moduleName$fileName.php";
298			$expectedStubName = "model.stub";
299			$expectedStubOptions = [
300			'NAMESPACE' => 'Modules\User\Entities',
301			'CLASS' => 'UserAddress',
302			'MODULE' => 'User'
303			];
304
305			$modelEvent = $this->getFirstDispatchedEvent(ModelGeneratedEvent::class);
306			$this->assertNotNull($modelEvent);
307			$this->assertEquals($expectedFileName, $modelEvent->getFilePath());
308			$this->assertEquals($expectedStubName, $modelEvent->getStub()->getName());
309			$this->assertEquals($expectedStubOptions, $modelEvent->getStub()->getOptions());
310
311			$expectedStubName = "migration.stub";
312			$expectedStubOptions = [
313			'CLASS' => 'CreateUserAddressTable',
314			'NAMESPACE' => 'Modules\User\Database\Migrations',
315			'TABLE' => 'user_addresses',
316			'MODULE' => 'User'
317			];
318
319			$migrationEvent = $this->getFirstDispatchedEvent(MigrationGeneratedEvent::class);
320			$this->assertNotNull($migrationEvent);
321			$this->assertEquals($expectedStubName, $migrationEvent->getStub()->getName());
322			$this->assertEquals($expectedStubOptions, $migrationEvent->getStub()->getOptions());
323			}
324
325			public function testCreatePolicy()
326			{
327			$moduleName = "User";
328			$fileName = "UserOwnershipPolicy";
329
330			$this->getModuleGenerator($moduleName)->createPolicy($fileName);
331
332			$expectedFileName = Larapi::getModule($moduleName)->getPolicies()->getPath() . "/$fileName.php";
333			$expectedStubName = "policy.stub";
334			$expectedStubOptions = [
335			'NAMESPACE' => 'Modules\User\Policies',
336			'CLASS' => 'UserOwnershipPolicy',
337			'MODULE' => 'User'
338			];
339
340			$event = $this->getFirstDispatchedEvent(PolicyGeneratedEvent::class);
341			$this->assertNotNull($event);
342			$this->assertEquals($expectedFileName, $event->getFilePath());
343			$this->assertEquals($expectedStubName, $event->getStub()->getName());
344			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
345			}
346
347			public function testCreateTransformer()
348			{
349			$moduleName = "User";
350			$model = "User";
351			$fileName = "BlablaTransformer";
352
353			$this->getModuleGenerator($moduleName)->createTransformer($fileName, $model);
354
355			$expectedFileName = Larapi::getModule($moduleName)->getTransformers()->getPath() . "/$fileName.php";
356			$expectedStubName = "transformer.stub";
357			$expectedStubOptions = [
358			'NAMESPACE' => 'Modules\User\Transformers',
359			'CLASS' => 'BlablaTransformer',
360			'MODEL' => 'User',
361			'MODEL_NAMESPACE' => 'Modules\User\Entities\User',
362			'MODULE' => 'User'
363			];
364
365			$event = $this->getFirstDispatchedEvent(TransformerGeneratedEvent::class);
366			$this->assertNotNull($event);
367			$this->assertEquals($expectedFileName, $event->getFilePath());
368			$this->assertEquals($expectedStubName, $event->getStub()->getName());
369			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
370			}
371
372			public function testCreateUnitTest()
373			{
374			$moduleName = "User";
375			$fileName = "AUserUnitTest";
376
377			$this->getModuleGenerator($moduleName)->createTest($fileName, 'unit');
378
379			$expectedFileName = Larapi::getModule($moduleName)->getTests()->getPath() . "/$fileName.php";
380			$expectedStubName = "unit-test.stub";
381			$expectedStubOptions = [
382			'NAMESPACE' => 'Modules\User\Tests',
383			'CLASS' => $fileName,
384			'MODULE' => $moduleName,
385			'TYPE' => 'unit'
386			];
387
388			$event = $this->getFirstDispatchedEvent(TestGeneratedEvent::class);
389			$this->assertNotNull($event);
390			$this->assertEquals($expectedFileName, $event->getFilePath());
391			$this->assertEquals($expectedStubName, $event->getStub()->getName());
392			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
393			}
394
395			public function testCreateRequest()
396			{
397			$moduleName = "User";
398			$fileName = "ARequest";
399
400			$this->getModuleGenerator($moduleName)->createRequest($fileName);
401
402			$expectedFileName = Larapi::getModule($moduleName)->getRequests()->getPath() . "/$fileName.php";
403			$expectedStubName = "request.stub";
404			$expectedStubOptions = [
405			'NAMESPACE' => 'Modules\User\Http\Requests',
406			'CLASS' => $fileName,
407			'MODULE' => $moduleName
408			];
409
410			$event = $this->getFirstDispatchedEvent(RequestGeneratedEvent::class);
411			$this->assertNotNull($event);
412			$this->assertEquals($expectedFileName, $event->getFilePath());
413			$this->assertEquals($expectedStubName, $event->getStub()->getName());
414			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
415			}
416
417			public function testCreateRule()
418			{
419			$moduleName = "User";
420			$fileName = "BlalkaRule";
421
422			$this->getModuleGenerator($moduleName)->createRule($fileName);
423
424			$expectedFileName = Larapi::getModule($moduleName)->getRules()->getPath() . "/$fileName.php";
425			$expectedStubName = "rule.stub";
426			$expectedStubOptions = [
427			'NAMESPACE' => 'Modules\User\Rules',
428			'CLASS' => 'BlalkaRule',
429			'MODULE' => 'User'
430			];
431
432			$event = $this->getFirstDispatchedEvent(RuleGeneratedEvent::class);
433			$this->assertNotNull($event);
434			$this->assertEquals($expectedFileName, $event->getFilePath());
435			$this->assertEquals($expectedStubName, $event->getStub()->getName());
436			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
437			}
438
439			public function testCreateSeeder()
440			{
441			$moduleName = "User";
442			$fileName = "BlablaSeeder";
443
444			$this->getModuleGenerator($moduleName)->createSeeder($fileName);
445
446			$expectedFileName = Larapi::getModule($moduleName)->getSeeders()->getPath() . "/$fileName.php";
447			$expectedStubName = "seeder.stub";
448			$expectedStubOptions = [
449			'NAMESPACE' => 'Modules\User\Database\Seeders',
450			'CLASS' => 'BlablaSeeder',
451			'MODULE' => 'User'
452			];
453
454			$event = $this->getFirstDispatchedEvent(SeederGeneratedEvent::class);
455			$this->assertNotNull($event);
456			$this->assertEquals($expectedFileName, $event->getFilePath());
457			$this->assertEquals($expectedStubName, $event->getStub()->getName());
458			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
459			}
460
461			public function testCreateRoute()
462			{
463			$moduleName = "Demo";
464			$routename = strtolower(Str::plural($moduleName)) . '.v1';
465
466			$this->getModuleGenerator($moduleName)->createRoute();
467
468			$expectedFileName = Larapi::getModule($moduleName)->getRoutes()->getPath() . "/$routename.php";
469			$expectedStubName = "route.stub";
470			$expectedStubOptions = [
471			'MODULE_NAME' => 'Demo',
472			'CAPS_MODULE_NAME' => 'DEMO',
473			'VERSION' => 'v1',
474			'MODULE' => 'Demo'
475			];
476
477			$event = $this->getFirstDispatchedEvent(RouteGeneratedEvent::class);
478			$this->assertNotNull($event);
479			$this->assertEquals($expectedFileName, $event->getFilePath());
480			$this->assertEquals($expectedStubName, $event->getStub()->getName());
481			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
482			}
483
484			public function testCreateComposer()
485			{
486			$moduleName = "Demo";
487
488			$this->getModuleGenerator($moduleName)->createComposer();
489
490			$expectedFileName = Larapi::getModule($moduleName)->getPath() . "/composer.json";
491			$expectedStubName = "composer.stub";
492			$expectedStubOptions = [
493			'LOWER_MODULE_NAME' => 'demo',
494			'AUTHOR_NAME' => 'arthur devious',
495			'AUTHOR_MAIL' => '[email protected]',
496			'MODULE' => 'Demo'
497			];
498
499			$event = $this->getFirstDispatchedEvent(ComposerGeneratedEvent::class);
500			$this->assertNotNull($event);
501			$this->assertEquals($expectedFileName, $event->getFilePath());
502			$this->assertEquals($expectedStubName, $event->getStub()->getName());
503			$this->assertEquals($expectedStubOptions, $event->getStub()->getOptions());
504			}
505
506			}
507

deviouspk / larapi

Push — master ( 590453...ad5a85 )

FileGeneratorTest::testCreateTransformer() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like