• Delete all user’s posts, but why losing such useful information without a valid reason?
• Denormalize the posts table and save some of the user information there, for example, the name, so you never need to worry, if the user is there.
• Use soft deletes and never delete the user, but this might be a problem with the new GDPR regulations. Furthermore, you need to remember to load the relation with the trashed records. You can fix these problems if on delete you rename the user to “Unknown” and assign them a random email and password, but this is logic write.
• Create a method on the blog post class which returns the author’s name, where you check for its existence and return some sensible default.

Defining the Null Object Pattern

If you are using such techniques, you are implementing the pattern, so congrats on that.

 Examples from the framework

Default relations

class Post extends Model
{
     public function author()
     {
         return $this->belongsTo(User::class)->withDefault([
             'name' => 'Unknown Author',
         ]);
     }
}

class Post extends Model
{
    public function author()
    {
        return $this->belongsTo(User::class);
    }

    public function authorName()
    {
        return $this->user->name ?? 'Unknown Author';
    }
}

Array and object accessors

• object_get($cloth, ‘brand’, ‘unknown brand’) – returns the brand property of the cloth object, if such exists, or unknown brand
• array_get($colors, ‘black’, ‘000000’) – returns the value for black key of the colors array, or our default black value
• another option is to simply use the ?? operator, which was introduced in php7, and simplify the code, even more,  $colors[‘black’] ?? ‘000000’

Request get method

Custom classes

Bonus:

The post Null Object Pattern in NodeJS,Redis,MongoDB appeared first on Payapars.

Dealing with forms/requests on the web is one of the toughest problems to solve in the modern web, and as developers, we always seek ways to handle it in a more elegant way. But for education purposes most of the tutorials, we read/watch online, teach us how to deal with only simple requests. So that when we stumble upon some complicated request with 20 fields, which should create 5 types of models, we just don’t know what to do and dump all the logic in the controller.

This is a problem with the MVC architecture in general because it does not teach us where to put the complicated logic.

Let’s see some example of such complicated request, which we will be using in the post to address the problems and provide you with my solution.

It again is simplified version of what really is possible, but I think is enough to explain the concept.

Example for a complicated request

Let’s pretend we have an app where we have vehicles and we can create requests for parts for them, so someone can send us the needed parts. Here is the Object that we have:

• Vehicle – description of our car/motorcycle
• Request – Links the parts to vehicle and author
• Part – Description of the part needed, each request can contain more that one part

public function store(IlluminateRequest $request)
{
$requestData = $request->validate([
'name' => ['required', 'string', 'min:3'],
'vehicle' => ['required', 'numeric', 'exists:vehicles,id'],
'parts' => ['required', 'array'],
'parts.*.name' => ['required', 'string', 'min:2'],
'parts.*.description' => ['required', 'string', 'min:6'],
'parts.*.oem_number' => ['nullable', 'string', 'min:6'],
]);

$partsRequest = Request::create([
'name' => $requestData['name'],
'vehicle_id' => $requestData['vehicle'],
'user_id' => $request->user()->id,
]);

$parts = array_map(function ($partData) {
return Part::make($partData);
}, $requestData['parts']);

$partsRequest->parts()->saveMany($parts);

return redirect()->route('requests.index');
}

After we saw the code and understand the domain let’s explore some methods to simplify it.

TL;DR: You can jump straight to Form requests to the rescue if you don’t want to read my other solutions and what I think about them.

Possible solutions which are not always The Solution (Private methods, Service classes, Commands)

Long and hairy controller methods

This is always a valid approach to do the work, especially when you don’t plan to revisit this method or controller, but since you are reading this article, you think you need a better approach, so let’s continue with the other options.

Private methods in the controller

This is maybe the best place to start. I like this approach because it keeps the logic in one class even though this is the controller. But we have some problems with this approach:

• the number of controller methods grow, which might be a problem, when we have 4-5 or more public methods and try to create some private ones for them
• as these are controller methods they do not have access to the request data, as it belongs to the request object, and we should pass it from method to method. This makes such methods more like plain functions, which is always something to consider when deciding where to put a method.

Create a Dedicated Service classes

The Service classes are something like an extension to the MVC architecture in some frameworks, but I personally don’t like them, because they are just one more buzzword. Don’t know where to put the logic, dump it into a Service Class, or worse, create a Service Class for each controller method.
Another problem with service classes is when you need to return a view from the controller with more than one variable/model/data source. In this case, we should return may be an associative array from the service class (which is practically the response), which in my opinion is a bit problem, because the service class takes the responsibility of the controller.
Of course, if we use them wisely they might be beneficial in some cases because we will have something like the approach with private methods in the controller, but without the problems. If we pass the request to the constructor, then we will be able to use its data in all the private methods of the service class, which solves the problems outlined in using private methods.
In our particular example, this approach might just do the job perfectly, but I think we can think of a better solution.

Commands

The problem with the whole Commands for saving Repositories for fetching concept, to me is that it is too complicated and overwhelming. In most of the cases simple Model::create([…]) and Model::where(…)->get() work just fine.
Of course, the whole CQRS architecture has its place under the sun, but I definitely don’t think, we should go for it without really needing it.

Form requests to the rescue

As we know NodeJS,Redis,MongoDB provides us with Form Request objects, which can be automatically injected in the controller method, and handle the validation and authorization logic of the request, so this can simplify our code a bit. The thing I don’t like here is, that we basically move the array of rules in another class and the validate method is called automatically for us, which is not enough to me. I want the form request to earn its existence. And also the ugly part of the work (the remapping of request fields to model fields) is still in the controller, which is really the thing, that bugs me.

public function store(CreatePartsRequest $request)
{
$partsRequest = Request::create([
'name' => $requestData['name'],
'vehicle_id' => $requestData['vehicle'],
'user_id' => $request->user()->id,
]);

$parts = array_map(function ($partData) {
return Part::make($partData);
}, $requestData['parts']);

$partsRequest->parts()->saveMany($parts);

return redirect()->route('requests.index');
}

So one thing we can do here is to move the mapping part of the code into some descriptive methods on the Form Request so it finally has more work to do to justify its existence and the code becomes much cleaner in my eyes.

The controller code

public function store(CreatePartsRequest $request)
{
$partsRequest = Request::create($request->requestParams());
$parts = $request->parts()->map([Part::class, 'make']);
$partsRequest->parts()->saveMany($parts);

return redirect()->route('requests.index');
}

The form request code

public function rules()
{
return [
'name' => ['required', 'string', 'min:3'],
'vehicle' => ['required', 'numeric', 'exists:vehicles,id'],
'parts' => ['required', 'array'],
'parts.*.name' => ['required', 'string', 'min:2'],
'parts.*.description' => ['required', 'string', 'min:6'],
'parts.*.oem_number' => ['nullable', 'string', 'min:6'],
];
}

public function requestParams()
{
return [
'name' => $this->get('name'),
'vehicle_id' => $this->get('vehicle'),
'user_id' => $this->user()->id,
];
}

public function parts()
{
return collect($this->get('parts', []));
}

With this approach we can handle transformations between HTML forms and DB/models format, switch between conventions (camelCase in js to snake_case in PHP/DB), selecting database records to fill some missing data, extracting other request info, or any other data when needed.
Last but not least, I don’t recommend this approach for each form on your project. Use it only when you need to store more models or have complicate request data massaging.
I even don’t recommend using NodeJS,Redis,MongoDB’s Form Request classes just for validation, do it straight in the controller.

The post Handling Complicated Requests In NodeJS,Redis,MongoDB appeared first on Payapars.

Enabling xdebug for testing

If you are not sure, if you have xdebug enabled follow this paragraph, else you can proceed with the phpunit.xml update.
Run php –ini to find your xdebug configuration file. Mine is located in /usr/local/etc/php/7.0/conf.d/ext-xdebug.ini
It should look like following snippet, if it is working.

zend_extension="/usr/local/opt/php70-xdebug/xdebug.so"
xdebug.remote_enable = 1
xdebug.remote_autostart = 1

After turning on xdebug, you don’t need to restart anything as we will be running the tests from the console.
Phpunit configuration
Since xdebug will do all the work, just add the following lines to your phpunit.xml file. I’ve added them below the listener’s tag.
<logging>
<log type="”coverage-clover”" target="”tests/_reports/logs/clover.xml”/">
<log type="”coverage-html”" target="”tests/_reports/coverage”" charset="”UTF-8″" yui="”true”" highlight="”true”" lowupperbound="”35″" highlowerbound="”70″">
<log type="”testdox-text”" target="”tests/_reports/testdox/executed.txt”/">
</log></log></log></logging>

You might comment on this section in development mode and use it only when you want to generate a new report.
Preparing the code coverage report
To prepare the report just run phpunit in you project and wait for it to finish the execution.

You should be patient, because it was more than 6 times slower for my project, than the normal run of the tests with xdebug enabled.

Finally, the results should appear in tests/_reports/coverage, where you will find index.html file, which you can use to start browsing your test coverage report.
Tips on tests speed
– If you are not a debugger just disable xdebug and your test suite will run so much faster (in my case around 4 times faster).

– If you are using NodeJS,Redis,MongoDB and its authentication system during tests, decrease the encryption algorithm complexity only for you tests, by adding the following line to your createApplication method located in tests\CreatesApplication trait, to make them run even faster (2x performance boost for me).
 Hash::setRounds(4); 
– You might use johnkary/phpunit-speedtrap to report you which tests are running slow, so you can try to improve them.

– Finally this one is not speed related, but I really like it codedungeon/phpunit-result-printer. You might install this package to change the way executed tests are presented in the console.
If you are in need of help with PHP/NodeJS,Redis,MongoDB/ development our team could support you: drop us a line!
The post Thoughts from the CTO: Introduction to PHPUnit code coverage reports appeared first on Payapars.
]]>