[16/38] - Using PhpSpec to Test our FileMover

Hi, I'm Chris from CodereviewVidio.com and in this video we're continuing our file mover

test and implementation. Now going back to our implementation, to actually be able to move a file, we can do this in a multitude

of ways. The three that I can think of off the top of the head are to use either PHP's built-in functions

or we can use something like Fly System or Gau-Ret, some sort of file system abstraction, or

we can use the Symphony File System component. Well, as we're using symphony anyway, we might as well make use of the components it provides

We've already got them. We don't need to include any other dependencies. And as this is a symphony service, the way in which we'll get access to that file system is to simply inject it

Now, if you're unsure, what we can do at this point is do a PHP bin console, debug, container

and then we'll pass in file system as the thing that we're looking for. And you can see here it dumps out all the service information for us

The one that we're interested in here will be the service ID, which is file system

or one word lowercase and because we're going to be injecting this

we'll need to prefix it with the at symbol to indicate that it's a service

But knowing this, if we're going to inject it, we can go ahead, set this up

via a constructor to inject our concrete implementation of the symphony file system

And notice the use statement's been brought in. I'm going to alt and return on that on a Mac

to initialize the fields. That should all be good And then I going to add the implementation here So it this file system and then there a bunch of methods that you can do with it The one we interested in is rename We going to rename from the existing file path to the new file path And unfortunately

this is actually a void method. If we look at it, it doesn't return anything. It throws a couple

of things and that's quite useful, but it doesn't actually return anything, which is why we can't

just simply return the outcome of this. That's why we have to return true. So now if we try and run

our tests again, you can see that both of them have broken. This is to be expected because now

we've just changed the implementation to expect that we're passing in a file system instance

but inside our spec, we're not really doing that at all. So we can start fixing this by injecting

a file system into each test, making sure that we've got the right use statement, and I'll just

call that FS just to make it a little bit more shorthand, and again we can do it for this one

and then what we can do, apologies, what we can do is do this, be constructed with

and I can say FS to make sure that whenever we call our file mover

it gets constructed with an instance of the file system. So again, we'll run our test now and we're back to passing

because we're injecting the expected dependency. But of course, you don't want to keep having to do this

for every single test that you create. So PHP spec's got a better solution to this

which is the let function. So we'll just say let, create that

and we'll say be constructed with. That's cool, and that's cool. We don't need these anymore

So just get rid of them but I do need it inside the let method or the let function So now we should still have two passing tests which we do albeit with a little less duplication

Okay, but let's look back at what our tests are actually testing. So we've got, it is initializable, and that checks that this file mover class exists

And also now, in our case, that our constructor depends on a file system

But it's not really testing anything in terms of our implementation. For that, we've added our own test

It can move a file from temporary to controlled storage, and we call move. with our current location or new location, it should return true

And that test is passing. We're not actually testing anything to do with this injected file system

So this isn't actually an instance of the file system. It's called a collaborator

And we can see this if we cheat a little bit, and we'll do a dump here

And just rerun our test now, and you can see that what's been dumped out is an object that's an instance of a PHP spec collaborator

And effectively what this allows us to do is completely fake out the dependencies

but also spy on them, by which I mean that we can check now that inside our file mover

this file system renamed was called with these two expected arguments. So let's do that

So we've got let file system. What we're going to need to do is get access to this file system a little later on in our test

And to do that, all we need to do is say this file system or whatever property you wish to create

It equals FS. And then we'll just add that as a private field

Okay so we constructed with it and everything and then we go into our test and after our test is run what we could now do is say this file system rename with these two properties or two arguments

should I say should have been called so we expect this file system rename with that and that to

have been called and if so then we should have a passing test that's quite cool and what it means is

if we jump inside our file mover maybe we change this out to be just one two three just to break it

run our tests you can see that we didn't quite meet the requirements of our tests

So we know, even though we're not testing the symphony component, which has its own unit tests and is completely isolated from us

we know that if we send in the right arguments, assuming that code all works that symphony are providing

and that's a fair assumption to make, then our code should behave in line with that

So that's really useful, in my opinion. And again, just to bring that out, rerun the tests, and we're all good

So really the only thing that's left to do at this point is to make sure that we have the appropriate service definition set up

So this is really straightforward. We're going to have app, service, file mover

It's going to have the class of app, bundle, service, file mover

And we know now that it takes one argument, which is the app file system

So let's just take a quick copy of that. Do a PHP bin, console, debug container

Paste that in and you can see, well, it didn't throw an error so we can be pretty certain that this service is properly configured