GeneratorTest::testCreateUnitTest() - Code Metrics - Inspection of "Progress generator. (all commands done)" - deviouspk/larapi - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( c7459e...5c3821 )

by Arthur

created 2019-03-11 18:53 UTC

GeneratorTest::testCreateUnitTest() A

↳ Parent: GeneratorTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	19
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	13
nc	1
nop	0
dl	0
loc	19
rs	9.8333
c	0
b	0
f	0

<?php

namespace Foundation\Tests;

use Foundation\Abstracts\Tests\TestCase;
use Foundation\Core\Larapi;
use Foundation\Generator\Commands\MigrationMakeCommand;
use Foundation\Generator\Commands\ModelMakeCommand;
use Foundation\Generator\Commands\PolicyMakeCommand;
use Foundation\Generator\Commands\RequestMakeCommand;
use Foundation\Generator\Commands\RuleMakeCommand;
use Foundation\Generator\Commands\SeederMakeCommand;
use Foundation\Generator\Commands\TestMakeCommand;
use Foundation\Generator\Commands\TransformerMakeCommand;
use Foundation\Generator\Events\FileGeneratedEvent;
use Foundation\Generator\Managers\GeneratorManager;
use Foundation\Generator\Traits\DispatchedGeneratorEvents;
use Foundation\Traits\DisableRefreshDatabase;
use \Illuminate\Support\Facades\Event;

/**
 * Created by PhpStorm.
 * User: arthur
 * Date: 10.03.19
 * Time: 18:35
 */
class GeneratorTest extends TestCase
{
    public function setUp(): void
    {
        parent::setUp();

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

    use DisableRefreshDatabase, DispatchedGeneratorEvents;


    public function testCreateSqlMigration()
    {
        GeneratorManager::createMigration("User", "CreateUserTable", 'users', false);

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

        Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedDirectoryPath, $expectedStubName, $expectedStubOptions) {
            $this->assertStringContainsString($expectedDirectoryPath, $event->getFilePath());
            $this->assertEquals($expectedStubName, $event->getStubName());
            $this->assertEquals($expectedStubOptions, $event->getStubOptions());
            return true;
        });
    }

    public function testCreateMongoMigration()
    {
        GeneratorManager::createMigration("User", "CreateUserCollection", 'users', true);
        Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) {
            $this->assertEquals("migration-mongo.stub", $event->getStubName());
            return true;
        });
    }

    public function testCreateFactory()
    {
        $moduleName = "User";
        GeneratorManager::createFactory($moduleName, "User");

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

        Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
            $this->assertEquals($expectedFileName, $event->getFilePath());
            $this->assertEquals($expectedStubName, $event->getStubName());
            $this->assertEquals($expectedStubOptions, $event->getStubOptions());
            return true;
        });
    }

    public function testCreateController()
    {
        $moduleName = "User";
        GeneratorManager::createController($moduleName, "UserController");

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

        Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
            $this->assertEquals($expectedFileName, $event->getFilePath());
            $this->assertEquals($expectedStubName, $event->getStubName());
            $this->assertEquals($expectedStubOptions, $event->getStubOptions());
            return true;
        });
    }

    public function testCreateListener()
    {
        $moduleName = "User";
        GeneratorManager::createListener($moduleName, "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',
        ];

        Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
            $this->assertEquals($expectedFileName, $event->getFilePath());
            $this->assertEquals($expectedStubName, $event->getStubName());
            $this->assertEquals($expectedStubOptions, $event->getStubOptions());
            return true;
        });
    }

    public function testCreateQueuedListener()
    {
        GeneratorManager::createListener("User", "SendWelcomeMail", "UserRegisteredEvent", true);
        Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) {
            $this->assertEquals("listener-queued.stub", $event->getStubName());
            return true;
        });
    }

    public function testCreateJob()
    {
        $moduleName = "User";
        $fileName = "RandomUserJob";
        GeneratorManager::createJob($moduleName, $fileName, false);

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

        Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
            $this->assertEquals($expectedFileName, $event->getFilePath());
            $this->assertEquals($expectedStubName, $event->getStubName());
            $this->assertEquals($expectedStubOptions, $event->getStubOptions());
            return true;
        });
    }

    public function testCreateSynchronousJob()
    {
        GeneratorManager::createJob("User", "AJob", true);
        Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) {
            $this->assertEquals("job.stub", $event->getStubName());
            return true;
        });
    }

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

        GeneratorManager::createCommand($moduleName, $fileName, $commandName);

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

        Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
            $this->assertEquals($expectedFileName, $event->getFilePath());
            $this->assertEquals($expectedStubName, $event->getStubName());
            $this->assertEquals($expectedStubOptions, $event->getStubOptions());
            return true;
        });
    }

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

        GeneratorManager::createMiddleware($moduleName, $fileName);

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

        Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
            $this->assertEquals($expectedFileName, $event->getFilePath());
            $this->assertEquals($expectedStubName, $event->getStubName());
            $this->assertEquals($expectedStubOptions, $event->getStubOptions());
            return true;
        });
    }

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

        GeneratorManager::createServiceProvider($moduleName, $fileName);

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

        Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
            $this->assertEquals($expectedFileName, $event->getFilePath());
            $this->assertEquals($expectedStubName, $event->getStubName());
            $this->assertEquals($expectedStubOptions, $event->getStubOptions());
            return true;
        });
    }

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

        GeneratorManager::createNotification($moduleName, $fileName);

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

        Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
            $this->assertEquals($expectedFileName, $event->getFilePath());
            $this->assertEquals($expectedStubName, $event->getStubName());
            $this->assertEquals($expectedStubOptions, $event->getStubOptions());
            return true;
        });
    }

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

        GeneratorManager::createModel($moduleName, $fileName, false, true);

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

        $modelEvent = $this->getFirstDispatchedEvent(ModelMakeCommand::class);
        $this->assertNotNull($modelEvent);
        $this->assertEquals($expectedFileName, $modelEvent->getFilePath());
        $this->assertEquals($expectedStubName, $modelEvent->getStubName());
        $this->assertEquals($expectedStubOptions, $modelEvent->getStubOptions());

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

        $migrationEvent = $this->getFirstDispatchedEvent(MigrationMakeCommand::class);
        $this->assertNotNull($migrationEvent);
        $this->assertEquals($expectedStubName, $migrationEvent->getStubName());
        $this->assertEquals($expectedStubOptions, $migrationEvent->getStubOptions());
    }

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

        GeneratorManager::createPolicy($moduleName, $fileName);

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

        $event = $this->getFirstDispatchedEvent(PolicyMakeCommand::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStubName());
        $this->assertEquals($expectedStubOptions, $event->getStubOptions());
    }

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

        GeneratorManager::createTransformer($moduleName, $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'
        ];

        $event = $this->getFirstDispatchedEvent(TransformerMakeCommand::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStubName());
        $this->assertEquals($expectedStubOptions, $event->getStubOptions());
    }

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

        GeneratorManager::createTest($moduleName, $fileName, 'unit');

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

        $event = $this->getFirstDispatchedEvent(TestMakeCommand::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStubName());
        $this->assertEquals($expectedStubOptions, $event->getStubOptions());
    }

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

        GeneratorManager::createRequest($moduleName, $fileName);

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

        $event = $this->getFirstDispatchedEvent(RequestMakeCommand::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStubName());
        $this->assertEquals($expectedStubOptions, $event->getStubOptions());
    }

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

        GeneratorManager::createRule($moduleName, $fileName);

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

        $event = $this->getFirstDispatchedEvent(RuleMakeCommand::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStubName());
        $this->assertEquals($expectedStubOptions, $event->getStubOptions());
    }

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

        GeneratorManager::createSeeder($moduleName, $fileName);

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

        $event = $this->getFirstDispatchedEvent(SeederMakeCommand::class);
        $this->assertNotNull($event);
        $this->assertEquals($expectedFileName, $event->getFilePath());
        $this->assertEquals($expectedStubName, $event->getStubName());
        $this->assertEquals($expectedStubOptions, $event->getStubOptions());
    }

}


1			<?php
2
3			namespace Foundation\Tests;
4
5			use Foundation\Abstracts\Tests\TestCase;
6			use Foundation\Core\Larapi;
7			use Foundation\Generator\Commands\MigrationMakeCommand;
8			use Foundation\Generator\Commands\ModelMakeCommand;
9			use Foundation\Generator\Commands\PolicyMakeCommand;
10			use Foundation\Generator\Commands\RequestMakeCommand;
11			use Foundation\Generator\Commands\RuleMakeCommand;
12			use Foundation\Generator\Commands\SeederMakeCommand;
13			use Foundation\Generator\Commands\TestMakeCommand;
14			use Foundation\Generator\Commands\TransformerMakeCommand;
15			use Foundation\Generator\Events\FileGeneratedEvent;
16			use Foundation\Generator\Managers\GeneratorManager;
17			use Foundation\Generator\Traits\DispatchedGeneratorEvents;
18			use Foundation\Traits\DisableRefreshDatabase;
19			use \Illuminate\Support\Facades\Event;
20
21			/**
22			* Created by PhpStorm.
23			* User: arthur
24			* Date: 10.03.19
25			* Time: 18:35
26			*/
27			class GeneratorTest extends TestCase
28			{
29			public function setUp(): void
30			{
31			parent::setUp();
32
33			/* Do not remove this line. It prevents the listener that generate the file from executing */
34			Event::fake();
35			}
36
37			use DisableRefreshDatabase, DispatchedGeneratorEvents;
38
39
40			public function testCreateSqlMigration()
41			{
42			GeneratorManager::createMigration("User", "CreateUserTable", 'users', false);
43
44			$module = Larapi::getModule("User");
45			$expectedDirectoryPath = $module->getMigrations()->getPath();
46			$expectedStubName = "migration.stub";
47			$expectedStubOptions = [
48			'CLASS' => 'CreateUserTable',
49			'NAMESPACE' => $module->getMigrations()->getNamespace(),
50			'TABLE' => 'users'
51			];
52
53			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedDirectoryPath, $expectedStubName, $expectedStubOptions) {
54			$this->assertStringContainsString($expectedDirectoryPath, $event->getFilePath());
55			$this->assertEquals($expectedStubName, $event->getStubName());
56			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
57			return true;
58			});
59			}
60
61			public function testCreateMongoMigration()
62			{
63			GeneratorManager::createMigration("User", "CreateUserCollection", 'users', true);
64			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) {
65			$this->assertEquals("migration-mongo.stub", $event->getStubName());
66			return true;
67			});
68			}
69
70			public function testCreateFactory()
71			{
72			$moduleName = "User";
73			GeneratorManager::createFactory($moduleName, "User");
74
75			$expectedFileName = Larapi::getModule($moduleName)->getFactories()->getPath() . '/UserFactory.php';
76			$expectedStubName = "factory.stub";
77			$expectedStubOptions = [
78			'CLASS' => 'UserFactory',
79			'MODEL' => 'User',
80			'MODEL_NAMESPACE' => 'Modules\User\Entities\User'
81			];
82
83			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
84			$this->assertEquals($expectedFileName, $event->getFilePath());
85			$this->assertEquals($expectedStubName, $event->getStubName());
86			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
87			return true;
88			});
89			}
90
91			public function testCreateController()
92			{
93			$moduleName = "User";
94			GeneratorManager::createController($moduleName, "UserController");
95
96			$expectedFileName = Larapi::getModule($moduleName)->getControllers()->getPath() . '/UserController.php';
97			$expectedStubName = "controller.stub";
98			$expectedStubOptions = [
99			'CLASS' => 'UserController',
100			'NAMESPACE' => 'Modules\User\Http\Controllers'
101			];
102
103			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
104			$this->assertEquals($expectedFileName, $event->getFilePath());
105			$this->assertEquals($expectedStubName, $event->getStubName());
106			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
107			return true;
108			});
109			}
110
111			public function testCreateListener()
112			{
113			$moduleName = "User";
114			GeneratorManager::createListener($moduleName, "SendWelcomeMail", "UserRegisteredEvent");
115
116			$expectedFileName = Larapi::getModule($moduleName)->getListeners()->getPath() . '/SendWelcomeMail.php';
117			$expectedStubName = "listener.stub";
118			$expectedStubOptions = [
119			'CLASS' => 'SendWelcomeMail',
120			'NAMESPACE' => 'Modules\User\Listeners',
121			'EVENTNAME' => 'Modules\User\Events\UserRegisteredEvent',
122			'SHORTEVENTNAME' => 'UserRegisteredEvent',
123			];
124
125			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
126			$this->assertEquals($expectedFileName, $event->getFilePath());
127			$this->assertEquals($expectedStubName, $event->getStubName());
128			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
129			return true;
130			});
131			}
132
133			public function testCreateQueuedListener()
134			{
135			GeneratorManager::createListener("User", "SendWelcomeMail", "UserRegisteredEvent", true);
136			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) {
137			$this->assertEquals("listener-queued.stub", $event->getStubName());
138			return true;
139			});
140			}
141
142			public function testCreateJob()
143			{
144			$moduleName = "User";
145			$fileName = "RandomUserJob";
146			GeneratorManager::createJob($moduleName, $fileName, false);
147
148			$expectedFileName = Larapi::getModule($moduleName)->getJobs()->getPath() . "/$fileName.php";
149			$expectedStubName = "job-queued.stub";
150			$expectedStubOptions = [
151			'NAMESPACE' => 'Modules\User\Jobs',
152			'CLASS' => 'RandomUserJob'
153			];
154
155			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
156			$this->assertEquals($expectedFileName, $event->getFilePath());
157			$this->assertEquals($expectedStubName, $event->getStubName());
158			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
159			return true;
160			});
161			}
162
163			public function testCreateSynchronousJob()
164			{
165			GeneratorManager::createJob("User", "AJob", true);
166			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) {
167			$this->assertEquals("job.stub", $event->getStubName());
168			return true;
169			});
170			}
171
172			public function testCreateCommand()
173			{
174			$moduleName = "User";
175			$fileName = "RandomCommand";
176			$commandName = "user:dosomethingrandom";
177
178			GeneratorManager::createCommand($moduleName, $fileName, $commandName);
179
180			$expectedFileName = Larapi::getModule($moduleName)->getCommands()->getPath() . "/$fileName.php";
181			$expectedStubName = "command.stub";
182			$expectedStubOptions = [
183			'NAMESPACE' => 'Modules\User\Console',
184			'CLASS' => 'RandomCommand',
185			'COMMAND_NAME' => $commandName
186			];
187
188			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
189			$this->assertEquals($expectedFileName, $event->getFilePath());
190			$this->assertEquals($expectedStubName, $event->getStubName());
191			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
192			return true;
193			});
194			}
195
196			public function testCreateMiddleware()
197			{
198			$moduleName = "User";
199			$fileName = "RandomMiddleware";
200
201			GeneratorManager::createMiddleware($moduleName, $fileName);
202
203			$expectedFileName = Larapi::getModule($moduleName)->getMiddleWare()->getPath() . "/$fileName.php";
204			$expectedStubName = "middleware.stub";
205			$expectedStubOptions = [
206			'CLASS' => 'RandomMiddleware',
207			'NAMESPACE' => 'Modules\User\Http\Middleware'
208			];
209
210			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
211			$this->assertEquals($expectedFileName, $event->getFilePath());
212			$this->assertEquals($expectedStubName, $event->getStubName());
213			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
214			return true;
215			});
216			}
217
218			public function testCreateProvider()
219			{
220			$moduleName = "User";
221			$fileName = "RandomServiceProvider";
222
223			GeneratorManager::createServiceProvider($moduleName, $fileName);
224
225			$expectedFileName = Larapi::getModule($moduleName)->getServiceProviders()->getPath() . "/$fileName.php";
226			$expectedStubName = "provider.stub";
227			$expectedStubOptions = [
228			'NAMESPACE' => 'Modules\User\Providers',
229			'CLASS' => 'RandomServiceProvider'
230			];
231
232			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
233			$this->assertEquals($expectedFileName, $event->getFilePath());
234			$this->assertEquals($expectedStubName, $event->getStubName());
235			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
236			return true;
237			});
238			}
239
240			public function testCreateNotification()
241			{
242			$moduleName = "User";
243			$fileName = "RandomNotification";
244
245			GeneratorManager::createNotification($moduleName, $fileName);
246
247			$expectedFileName = Larapi::getModule($moduleName)->getNotifications()->getPath() . "/$fileName.php";
248			$expectedStubName = "notification.stub";
249			$expectedStubOptions = [
250			'NAMESPACE' => 'Modules\User\Notifications',
251			'CLASS' => 'RandomNotification'
252			];
253
254			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
255			$this->assertEquals($expectedFileName, $event->getFilePath());
256			$this->assertEquals($expectedStubName, $event->getStubName());
257			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
258			return true;
259			});
260			}
261
262			public function testCreateModel()
263			{
264			$moduleName = "User";
265			$fileName = "Address";
266
267			GeneratorManager::createModel($moduleName, $fileName, false, true);
268
269			$expectedFileName = Larapi::getModule($moduleName)->getModels()->getPath() . "/$moduleName$fileName.php";
270			$expectedStubName = "model.stub";
271			$expectedStubOptions = [
272			'NAMESPACE' => 'Modules\User\Entities',
273			'CLASS' => 'UserAddress'
274			];
275
276			$modelEvent = $this->getFirstDispatchedEvent(ModelMakeCommand::class);
277			$this->assertNotNull($modelEvent);
278			$this->assertEquals($expectedFileName, $modelEvent->getFilePath());
279			$this->assertEquals($expectedStubName, $modelEvent->getStubName());
280			$this->assertEquals($expectedStubOptions, $modelEvent->getStubOptions());
281
282			$expectedStubName = "migration.stub";
283			$expectedStubOptions = [
284			'CLASS' => 'CreateUserAddressTable',
285			'NAMESPACE' => 'Modules\User\Database\Migrations',
286			'TABLE' => 'user_addresses'
287			];
288
289			$migrationEvent = $this->getFirstDispatchedEvent(MigrationMakeCommand::class);
290			$this->assertNotNull($migrationEvent);
291			$this->assertEquals($expectedStubName, $migrationEvent->getStubName());
292			$this->assertEquals($expectedStubOptions, $migrationEvent->getStubOptions());
293			}
294
295			public function testCreatePolicy()
296			{
297			$moduleName = "User";
298			$fileName = "UserOwnershipPolicy";
299
300			GeneratorManager::createPolicy($moduleName, $fileName);
301
302			$expectedFileName = Larapi::getModule($moduleName)->getPolicies()->getPath() . "/$fileName.php";
303			$expectedStubName = "policy.stub";
304			$expectedStubOptions = [
305			'NAMESPACE' => 'Modules\User\Policies',
306			'CLASS' => 'UserOwnershipPolicy'
307			];
308
309			$event = $this->getFirstDispatchedEvent(PolicyMakeCommand::class);
310			$this->assertNotNull($event);
311			$this->assertEquals($expectedFileName, $event->getFilePath());
312			$this->assertEquals($expectedStubName, $event->getStubName());
313			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
314			}
315
316			public function testCreateTransformer()
317			{
318			$moduleName = "User";
319			$model = "User";
320			$fileName = "BlablaTransformer";
321
322			GeneratorManager::createTransformer($moduleName, $fileName, $model);
323
324			$expectedFileName = Larapi::getModule($moduleName)->getTransformers()->getPath() . "/$fileName.php";
325			$expectedStubName = "transformer.stub";
326			$expectedStubOptions = [
327			'NAMESPACE' => 'Modules\User\Transformers',
328			'CLASS' => 'BlablaTransformer',
329			'MODEL' => 'User',
330			'MODEL_NAMESPACE' => 'Modules\User\Entities\User'
331			];
332
333			$event = $this->getFirstDispatchedEvent(TransformerMakeCommand::class);
334			$this->assertNotNull($event);
335			$this->assertEquals($expectedFileName, $event->getFilePath());
336			$this->assertEquals($expectedStubName, $event->getStubName());
337			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
338			}
339
340			public function testCreateUnitTest()
341			{
342			$moduleName = "User";
343			$fileName = "BlablaUnitTest";
344
345			GeneratorManager::createTest($moduleName, $fileName, 'unit');
346
347			$expectedFileName = Larapi::getModule($moduleName)->getTests()->getPath() . "/$fileName.php";
348			$expectedStubName = "unit-test.stub";
349			$expectedStubOptions = [
350			'NAMESPACE' => 'Modules\User\Tests',
351			'CLASS' => 'BlablaUnitTest'
352			];
353
354			$event = $this->getFirstDispatchedEvent(TestMakeCommand::class);
355			$this->assertNotNull($event);
356			$this->assertEquals($expectedFileName, $event->getFilePath());
357			$this->assertEquals($expectedStubName, $event->getStubName());
358			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
359			}
360
361			public function testCreateRequest()
362			{
363			$moduleName = "User";
364			$fileName = "BlablaRequest";
365
366			GeneratorManager::createRequest($moduleName, $fileName);
367
368			$expectedFileName = Larapi::getModule($moduleName)->getRequests()->getPath() . "/$fileName.php";
369			$expectedStubName = "request.stub";
370			$expectedStubOptions = [
371			'NAMESPACE' => 'Modules\User\Http\Requests',
372			'CLASS' => 'BlablaRequest'
373			];
374
375			$event = $this->getFirstDispatchedEvent(RequestMakeCommand::class);
376			$this->assertNotNull($event);
377			$this->assertEquals($expectedFileName, $event->getFilePath());
378			$this->assertEquals($expectedStubName, $event->getStubName());
379			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
380			}
381
382			public function testCreateRule()
383			{
384			$moduleName = "User";
385			$fileName = "BlalkaRule";
386
387			GeneratorManager::createRule($moduleName, $fileName);
388
389			$expectedFileName = Larapi::getModule($moduleName)->getRules()->getPath() . "/$fileName.php";
390			$expectedStubName = "rule.stub";
391			$expectedStubOptions = [
392			'NAMESPACE' => 'Modules\User\Rules',
393			'CLASS' => 'BlalkaRule'
394			];
395
396			$event = $this->getFirstDispatchedEvent(RuleMakeCommand::class);
397			$this->assertNotNull($event);
398			$this->assertEquals($expectedFileName, $event->getFilePath());
399			$this->assertEquals($expectedStubName, $event->getStubName());
400			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
401			}
402
403			public function testCreateSeeder()
404			{
405			$moduleName = "User";
406			$fileName = "BlablaSeeder";
407
408			GeneratorManager::createSeeder($moduleName, $fileName);
409
410			$expectedFileName = Larapi::getModule($moduleName)->getSeeders()->getPath() . "/$fileName.php";
411			$expectedStubName = "seeder.stub";
412			$expectedStubOptions = [
413			'NAMESPACE' => 'Modules\User\Database\Seeders',
414			'CLASS' => 'BlablaSeeder'
415			];
416
417			$event = $this->getFirstDispatchedEvent(SeederMakeCommand::class);
418			$this->assertNotNull($event);
419			$this->assertEquals($expectedFileName, $event->getFilePath());
420			$this->assertEquals($expectedStubName, $event->getStubName());
421			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
422			}
423
424			}
425

deviouspk / larapi

Push — master ( c7459e...5c3821 )

GeneratorTest::testCreateUnitTest() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like