[21/38] - Don't Mock What You Don't Own

Hi, I'm Chris from Cod ReviewVidios.com, and in this video, we're going to get started

implementing our tested approach to file upload. In the previous two videos, we've implemented an untested approach to handling file uploads

inside our easy admin bundle back end. And whilst this works, we've tied ourselves very heavily to the way that Symphony works

in particular the way that Symphony's file upload process works. And on the surface of it, this doesn't seem like that big

of an issue, but when it comes to writing our tests, it does kind of throw a spanner in the works

What we're about to do is to revert back to the way our code was structured at the end of

video 18. To do this, I'm going to check out the code as it was when we tagged our code at the

end of video 18. So I'm going to use Glog, which in my case is a shortcut for that command

So I say Glog, and I can see here a list of all the commits in this project

And the one that I'm interested in is the CF521. So press Q there, and then I'll do a Git checkout

that commit hash and so we've now checked out that code but to start working on it properly

what I'm going to do is as it says git checkout dash B and then a new branch name so I've got a

short cut for that and I'll just call this vid 21 now as part of the previous two videos we made a

number of changes to our database so rather than trying to revert them manually or anything like that

I'm just going to drop the database then recreate it after which I'm going to apply all the

migrations and then I can repopulate the database using our fixtures. One

Something that I'd like to do before I reload my fixtures is just make that change that we saw during our prototype phase, where if we look inside our wallpaper entity for the file property, we're not going to want that column annotation

So I'm just going to get rid of that. And because I've made a slight change to our schema as a result, I've removed a column

I'm going to come back into here, just press the up arrow once there to get our previous command back and do a diff

Now just make sure that we've got that drop file column as part of our migrations

Control L on a Mac there to clear the screen and I need to apply that migration

So again, just up arrow there and we'll apply the migrations. And with that change in place

we should now be able to reload our fixtures and our database should be back to its expected state

So with all of that setup out of the way, we can get back on with testing our implementation So we already have a spec for our event listener wallpaper upload listener So what I going to do is I just going to open that by splitting it vertically closing that one down having that one open as well and closing down the sidebar

And just to make sure that we all know where we're at, I'm going to do PHP vendor

bin, PHP, spec, run, and then spec, at bundle, event, and because it's the only one

I can just hit tab a few times there, and we can see we're pretty much where we're at

at the end of video 18. As you've gathered by now, it's not true TDD

which we're practicing here. So what I'm going to do is I'm going to refer back to our reference implementation here

So inside the repositories on GitHub, we've got the wallpaper website tutorial. What we need to do is get to video 20s commit

which is the most recent one at the time of recording. And I'm just going to browse the files

as they were at this point, going to the source, app bundle, event listener, wallpaper, upload, listener, implementation

And this is what we were dealing with when we had a working file upload process

So in order to port this knowledge across to our test suite, let's just quickly step through what this does so far

So I'll start off with the first line, which is to store the outcome of event args get entity into a variable called entity

Now, Lifecycle Event args has this method get entity. We don't need to worry about how the entity will be set

at something that doctrine is going to do for us behind the scenes. But what we do know is that this pre-persist

method is going to be called whether this is a wallpaper entity or a category entity or any other

entity that we come up with in the life of our system. So what we need is this guard statement that

says if we're not dealing with a wallpaper, then just exit early so that we don't end up doing a

bunch of logic needlessly. If we get past that return statement, then our entity must be an

instance of wallpaper. We're adding in this type in just to make PHP Storm able to understand

what our entity is and therefore give us some nice auto-completion on our methods. One of the properties

on our wallpaper entity is the file, even though we're not storing that information

in the database directly. When dealing with an upload, the file will have been set

We know that it will be an instance of Sympani's uploaded file, so we can use the methods that are available

on that class or any of its base classes, which is the file and the SPL file info

as we need to. On the SPL file info, there's get path name

We can call that and we can figure out exactly where we're at currently. We created a new service

which would allow us to take the uploaded file file name and then concatenate it with a path that we care about which in our cases our project directory then the web directory inside that and then the images directory inside that And that will become our new file location With those two pieces of information

we can move the file from wherever it is currently to the location that we wanted to be in the

longer term. And then we were getting a little bit fancy there to pull out the width and the

height dynamically, and finally setting some properties on our entity. So the most important part of this

for us is going to be getting access to the file. How we get access to that file is when we go into Easy Admin bundle into our wallpapers

and we do our Add wallpaper. We've set up a form in our Easy Admin bundle configuration

So we're going to App, Config, Config, Config, Easy Admin bundle. And we've got this form here which tells Easy Admin bundle how to create a wallpaper

or what field we would need to create a wallpaper. And the important one here for us is this property file of 10

type file. And what that's going to do is it's going to add one of symphony's file type form

field types to the outputted form, as you can see here. Now because this is a symphony form

the way in which the implementation behind the scenes works will be the same way in which a

symphony file upload always works, which is how we get to having a symphony uploaded file

instance as part of entity get file. So knowing this, let's put this information into our

tests. It's going to close down some of this to make it a little bit tidier. And so inside

it can pre-persist. Let's start adding in some of this new information. So we know we're going

to get access to some form of uploaded file instance. So let's add that in as something that

we're trying to mock. So I say uploaded file. Let's tap that in there as well. Uploaded file

Let's pop that in. And we'll say whenever uploaded file get path name is called, we will return

so we'll return our fake temp path. So again, looking at the code

we're going to get the temporary location when we call file get path name. So we've just faked that there

and said when that is called, we expect to always give the fake temp path

Okay, so next what we'll do is we'll put this uploaded file onto a wallpaper

And rather than mocking that, we'll just create a new one. There's nothing really that we need to mock here

that we couldn't use a real instance for. So we'll say wallpaper, set file

and we'll put in that uploaded. file And again looking at our code we can see that we going to call event tags get entity And so when we call get entity on event tags which we currently mocking what we going to do making sure to do this after wallpaper has been set up we say eventires get entity will return our wallpaper

So all things being well, even though we've not got this file mover move set up at the moment, the pre-persist part of this test should kind of work maybe

Well, let's give it a shot. So we get an interesting exception here, which is to say that the file was not found and the file speech marks does not exist

In other words, this empty path or maybe this empty file name, it doesn't exist, which we kind of know it doesn't because we're trying to fake it

But this kind of leaves us with a problem. If we can't fake it or if we can't mock this file, then what we're going to do

So the next thing that we might try and do is to rather than use this mocked version, we'll get rid of that, and we'll just create a new instance of it

So I'll say uploaded file equals new uploaded file. And we can see this takes a couple of arguments which are not optional

the path and the original name. Well, we have a fake temp path, so let's just pass that in

And we can give it any name that we like, I guess, some file, as that's the name of the file that we kind of fake him

Because we're not mocking this, we don't need to tell it what to return because we're passing in the temp path anyway

When path name is called, that fake temp path should be returned

At least that's the theory. So let's give that a shot. Now we've got a slightly different error

The file temp some file does not exist. And indeed it doesn't because we've just tried to fake it

And that file doesn't actually exist in this location. So PHP can't find a file, as you would expect

And at this point we seem to be in a really bad position. We can't mock the uploaded file and we can't use a real instance

So how on earth do we proceed? Well, all of this is a result of us losing control of the way our system is working

Rather than making symphony bend to our will, we're bending to symphony's will

Now there's like a golden rule with PHP spec, which you will see banded around

which is to say, don't mock what you don't own. We neither own the life cycle event args, nor the uploaded file

So to finish up with this video, I want you to think about how we can start owning the concept predominantly of the uploaded file

or a file in general, and we will look at one way of solving this problem

in the very next video