GeneratorTest::testCreateProvider() - Code Metrics - Inspection of "Progress generator (event based)" - deviouspk/larapi - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b3b4c7...2fd2da )

by Arthur

created 2019-03-10 21:39 UTC

GeneratorTest::testCreateProvider() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	20
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	14
nc	1
nop	0
dl	0
loc	20
rs	9.7998
c	1
b	0
f	0

<?php

use Foundation\Core\Larapi;
use Foundation\Generator\Events\FileGeneratedEvent;
use Foundation\Generator\Managers\GeneratorManager;
use \Illuminate\Support\Facades\Event;

/**
 * Created by PhpStorm.
 * User: arthur
 * Date: 10.03.19
 * Time: 18:35
 */
class GeneratorTest extends \Foundation\Abstracts\Tests\TestCase
{
    public function testCreateSqlMigration()
    {
        Event::fake();
        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()
    {
        Event::fake();
        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";
        Event::fake();
        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";
        Event::fake();
        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";
        Event::fake();
        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()
    {
        Event::fake();
        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";
        Event::fake();
        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()
    {
        Event::fake();
        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";

        Event::fake();
        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";

        Event::fake();
        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";

        Event::fake();
        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";

        Event::fake();
        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;
        });
    }
}


1			<?php
2
3			use Foundation\Core\Larapi;
4			use Foundation\Generator\Events\FileGeneratedEvent;
5			use Foundation\Generator\Managers\GeneratorManager;
6			use \Illuminate\Support\Facades\Event;
7
8			/**
9			* Created by PhpStorm.
10			* User: arthur
11			* Date: 10.03.19
12			* Time: 18:35
13			*/
14			class GeneratorTest extends \Foundation\Abstracts\Tests\TestCase
15			{
16			public function testCreateSqlMigration()
17			{
18			Event::fake();
19			GeneratorManager::createMigration("User", "CreateUserTable", 'users', false);
20
21			$module = Larapi::getModule("User");
22			$expectedDirectoryPath = $module->getMigrations()->getPath();
23			$expectedStubName = "migration.stub";
24			$expectedStubOptions = [
25			'CLASS' => 'CreateUserTable',
26			'NAMESPACE' => $module->getMigrations()->getNamespace(),
27			'TABLE' => 'users'
28			];
29
30			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedDirectoryPath, $expectedStubName, $expectedStubOptions) {
31			$this->assertStringContainsString($expectedDirectoryPath, $event->getFilePath());
32			$this->assertEquals($expectedStubName, $event->getStubName());
33			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
34			return true;
35			});
36			}
37
38			public function testCreateMongoMigration()
39			{
40			Event::fake();
41			GeneratorManager::createMigration("User", "CreateUserCollection", 'users', true);
42			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) {
43			$this->assertEquals("migration-mongo.stub", $event->getStubName());
44			return true;
45			});
46			}
47
48			public function testCreateFactory()
49			{
50			$moduleName = "User";
51			Event::fake();
52			GeneratorManager::createFactory($moduleName, "User");
53
54			$expectedFileName = Larapi::getModule($moduleName)->getFactories()->getPath() . '/UserFactory.php';
55			$expectedStubName = "factory.stub";
56			$expectedStubOptions = [
57			'CLASS' => 'UserFactory',
58			'MODEL' => 'User',
59			'MODEL_NAMESPACE' => 'Modules\User\Entities\User'
60			];
61
62			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
63			$this->assertEquals($expectedFileName, $event->getFilePath());
64			$this->assertEquals($expectedStubName, $event->getStubName());
65			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
66			return true;
67			});
68			}
69
70			public function testCreateController()
71			{
72			$moduleName = "User";
73			Event::fake();
74			GeneratorManager::createController($moduleName, "UserController");
75
76			$expectedFileName = Larapi::getModule($moduleName)->getControllers()->getPath() . '/UserController.php';
77			$expectedStubName = "controller.stub";
78			$expectedStubOptions = [
79			'CLASS' => 'UserController',
80			'NAMESPACE' => 'Modules\User\Http\Controllers'
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 testCreateListener()
92			{
93			$moduleName = "User";
94			Event::fake();
95			GeneratorManager::createListener($moduleName, "SendWelcomeMail", "UserRegisteredEvent");
96
97			$expectedFileName = Larapi::getModule($moduleName)->getListeners()->getPath() . '/SendWelcomeMail.php';
98			$expectedStubName = "listener.stub";
99			$expectedStubOptions = [
100			'CLASS' => 'SendWelcomeMail',
101			'NAMESPACE' => 'Modules\User\Listeners',
102			'EVENTNAME' => 'Modules\User\Events\UserRegisteredEvent',
103			'SHORTEVENTNAME' => 'UserRegisteredEvent',
104			];
105
106			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
107			$this->assertEquals($expectedFileName, $event->getFilePath());
108			$this->assertEquals($expectedStubName, $event->getStubName());
109			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
110			return true;
111			});
112			}
113
114			public function testCreateQueuedListener()
115			{
116			Event::fake();
117			GeneratorManager::createListener("User", "SendWelcomeMail", "UserRegisteredEvent", true);
118			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) {
119			$this->assertEquals("listener-queued.stub", $event->getStubName());
120			return true;
121			});
122			}
123
124			public function testCreateJob()
125			{
126			$moduleName = "User";
127			$fileName = "RandomUserJob";
128			Event::fake();
129			GeneratorManager::createJob($moduleName, $fileName, false);
130
131			$expectedFileName = Larapi::getModule($moduleName)->getJobs()->getPath() . "/$fileName.php";
132			$expectedStubName = "job-queued.stub";
133			$expectedStubOptions = [
134			'NAMESPACE' => 'Modules\User\Jobs',
135			'CLASS' => 'RandomUserJob'
136			];
137
138			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
139			$this->assertEquals($expectedFileName, $event->getFilePath());
140			$this->assertEquals($expectedStubName, $event->getStubName());
141			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
142			return true;
143			});
144			}
145
146			public function testCreateSynchronousJob()
147			{
148			Event::fake();
149			GeneratorManager::createJob("User", "AJob", true);
150			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) {
151			$this->assertEquals("job.stub", $event->getStubName());
152			return true;
153			});
154			}
155
156			public function testCreateCommand()
157			{
158			$moduleName = "User";
159			$fileName = "RandomCommand";
160			$commandName = "user:dosomethingrandom";
161
162			Event::fake();
163			GeneratorManager::createCommand($moduleName, $fileName, $commandName);
164
165			$expectedFileName = Larapi::getModule($moduleName)->getCommands()->getPath() . "/$fileName.php";
166			$expectedStubName = "command.stub";
167			$expectedStubOptions = [
168			'NAMESPACE' => 'Modules\User\Console',
169			'CLASS' => 'RandomCommand',
170			'COMMAND_NAME' => $commandName
171			];
172
173			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
174			$this->assertEquals($expectedFileName, $event->getFilePath());
175			$this->assertEquals($expectedStubName, $event->getStubName());
176			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
177			return true;
178			});
179			}
180
181			public function testCreateMiddleware()
182			{
183			$moduleName = "User";
184			$fileName = "RandomMiddleware";
185
186			Event::fake();
187			GeneratorManager::createMiddleware($moduleName, $fileName);
188
189			$expectedFileName = Larapi::getModule($moduleName)->getMiddleWare()->getPath() . "/$fileName.php";
190			$expectedStubName = "middleware.stub";
191			$expectedStubOptions = [
192			'CLASS' => 'RandomMiddleware',
193			'NAMESPACE' => 'Modules\User\Http\Middleware'
194			];
195
196			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
197			$this->assertEquals($expectedFileName, $event->getFilePath());
198			$this->assertEquals($expectedStubName, $event->getStubName());
199			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
200			return true;
201			});
202			}
203
204			public function testCreateProvider()
205			{
206			$moduleName = "User";
207			$fileName = "RandomServiceProvider";
208
209			Event::fake();
210			GeneratorManager::createServiceProvider($moduleName, $fileName);
211
212			$expectedFileName = Larapi::getModule($moduleName)->getServiceProviders()->getPath() . "/$fileName.php";
213			$expectedStubName = "provider.stub";
214			$expectedStubOptions = [
215			'NAMESPACE' => 'Modules\User\Providers',
216			'CLASS' => 'RandomServiceProvider'
217			];
218
219			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
220			$this->assertEquals($expectedFileName, $event->getFilePath());
221			$this->assertEquals($expectedStubName, $event->getStubName());
222			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
223			return true;
224			});
225			}
226
227			public function testCreateNotification()
228			{
229			$moduleName = "User";
230			$fileName = "RandomNotification";
231
232			Event::fake();
233			GeneratorManager::createNotification($moduleName, $fileName);
234
235			$expectedFileName = Larapi::getModule($moduleName)->getNotifications()->getPath() . "/$fileName.php";
236			$expectedStubName = "notification.stub";
237			$expectedStubOptions = [
238			'NAMESPACE' => 'Modules\User\Notifications',
239			'CLASS' => 'RandomNotification'
240			];
241
242			Event::assertDispatched(FileGeneratedEvent::class, function (FileGeneratedEvent $event) use ($expectedFileName, $expectedStubName, $expectedStubOptions) {
243			$this->assertEquals($expectedFileName, $event->getFilePath());
244			$this->assertEquals($expectedStubName, $event->getStubName());
245			$this->assertEquals($expectedStubOptions, $event->getStubOptions());
246			return true;
247			});
248			}
249			}
250

deviouspk / larapi

Push — master ( b3b4c7...2fd2da )

GeneratorTest::testCreateProvider() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like