DFFML Development Skills, 23 Aug 2021

Previous Meeting

Next Meeting

⏯

youtube image

►

From YouTube: Test Driven Development

Description

Tutorial on how to do test driven development

- Find the bug
- Write the test case based on the bug (it should fail, since there is a bug)
- Fix the bug
- Check that the test case now passes

A

All right, so this is an example of how we can take a bug and use test driven development when we fix the bug. So we have this bug here where directory structure is not preserved.

A

Essentially, there's operations happening to a arc, create our archives and we need to make sure that we realized that we weren't, we didn't have any sort of directory structure in the archive that we created, and so we need to make sure that that we maintain directory structure. So uh here's what we're going to do so we're going to in this case we have the fix already and it's in the archive operations.

A

So this is what the fix looks like.

A

So we're going to do is we're going to write the test right, so we're going to go back um uh so we're going to revert and tell before we had uh so because we're going to pretend you know like we're, writing the code right, so good check out we'll just all right, we'll check it.

A

So we're gonna revert back to you know before when the bug existed right, okay, so pre-patch right! So now we're just gonna go and we're gonna test, we're going to write test case and we're going to say test iso test tar operations and test extract tar, ops and now we're going to write a test case that helps us catch. This bug right, so the bug is.

A

So this is what we're looking at. This is what exists now and if we fix the bug. This is what it's going to be like all right, so test directory structure, not preserve test archive creation right so.

A

All right so instantiate from our test case class test, preserve directory structure, all right.

A

And we got tar and we've got zip.

A

All right so we're gonna do the tar one first. So where is our tar archive so make tar archive and make zip archive.

A

All right, so, let's look at our function here: input directory path, output, file, path, all right, so we're going to call it function.

A

First, we're going to need to create.

A

First, we're going to go ahead and create a temporary directory with all stuff in it that we care about here.

A

So use the temp file module for that standard library.

A

A

So we're going to actually you know, yeah um we're going to go ahead and.

A

Make our input directory path.

A

And we're going to put it under tempter and so tempter is going to hold both our input directory path and our output file path.

A

And we'll just name these consistently just to keep everything easy.

A

Now we'll create our files or create our directory tree.

A

Variables for our inputs and outputs.

A

And this is our temporary directory to work in now that way, we don't clutter our file system with stuff that we only need just for this test case all right. So let's look at this book.

A

All right 11.98, so this is the example structure that we've been given here.

A

All right, so, let's just create something like this and and we don't really need to do this whole thing. We just need to make sure that a tree structure is perfect, preserved right, so let's see preserve while creating a zip, slash target of directory structures and preserved, and then we see it's flat here so.

A

All right, so we just need to make sure.

A

We just need a single.

A

It's like our minimal case to reproduce a bug.

A

What the hell's going on here.

A

Wait: okay, whatever.

A

Dot and pass so.

A

So the way that I am figuring out.

A

A

A

All right, so this is our minimal.

A

Working example here right, so we have our directory structure, so we have our output file path. We have our input directory path, and so this is the top level der childer. So we can create both those at once by using the path of maker. um We can then create this file and we can just make it empty right, and so now we'll have a multi-level directory structure here. So we should be able to pass this to make tar archive and then we'll observe that output file path, we're going to need to read it.

A

A

All right and just always reference, um you know the standard library documentation or whatever documentation that you're using here.

A

And to make sure that you know you know what to do and what what to call no no looks like it's get. Members, not members.

A

A

All right so um now here's where we're going to do our final checks.

A

Test so now here the final assert is assert that the paths in the tar, the created tar file.

A

Are the same or are what are the same as the or the the directory structure? So we're testing that the directory structure.

A

Of the created tar file is the same as the um that's. You know our input directory path.

A

A

And we'll just leave this blank for now.

A

And we're doing.

A

Nope need to be async.

A

Got an import temp file.

A

Got import path, lib.

A

Gotta import tar file.

A

All right there we go so that's our directory structure and of the at the tar file right. So uh so now we've got to fill in our list so top of dirt.

A

A

A

A

ah Okay, let's see what the bug is here, so the bug only happens when we're extracted. So let's go ahead and extract this um as well here so because you can see that it looks like we've added all the paths, um including uh so with the debug here, is essentially that we've gone through and added every single path, and so what ends up happening is that we overwrite um the previous ones and we only get stuff at the top level.

A

So if we extract, we should see um that everything is it's only at the top level. So let's go ahead and extract it too, and then we'll we will have our bug and then we can validate from there. So profile path, output, directory path,.

A

Now we can now compare the listing of the output directory path.

A

I don't need profile anymore.

A

Well looks like we didn't get anything in our output directory, so that's not good.

A

A

What directory that.

A

Well, in this test case looks like we didn't get anything at all, so we're failing for apparently a slightly different reason here.

A

Also, what we found out here is that I'm seeing a different bug- I guess maybe because there were no files with contents.

A

Weird, we don't, we seem to be hitting a bigger problem. Even so um the point is we write the test case, um so you write the test case now we're going to apply the patch. So, let's go back to where we were so basically.

A

So you write the test case and you provided there was only one bug. You would assert the correct values here. So let's just go ahead and do that now. um So this is going to be.

A

Just relative to so, let's see.

A

A

All right so we're going through all the paths and what we should see.

A

We're going to do this, so this test passes on windows or linux, so we should see here is top level directory right.

A

Don't get past that chart for that.

A

All right, this is our expectation.

A

Right is that when we list the contents of the directory, uh we end up with top level dir double door, slash child their one double dirt, slash tell dur one slash file one um and we're using os path join. Just because uh you know, if we run this test on windows, then we're gonna have backslashes and so slashes, so we're gonna.

A

Do it this way um that way, it'll pass on windows too so, and then we used relative to to make sure that our paths are getting chopped off and they aren't um absolute paths, because output directory cuts probably an absolute path. uh Two slash tech, we're on linux, so um all right! Okay, so we extract right now it doesn't seem like extracting.

A

Oh well. You know why, because I move this outside the temperature, so there's nothing in that directory. Obviously, okay, uh let's run the test again, yay all right and let's go ahead and sort these two while we're at it.

A

Alright yeah now you see it's really not exactly this. What I was expecting here.

A

Let's see is this: what the book says: yeah we're not seeing top level there here, which is interesting, so we should be seeing at least top level during the output, but.

A

A

So it looks like childhood one filed over, so it's dropping top level dirt entirely. It looks like.

A

Should be the same but let's just.

A

A

So anyways now we have our test um yeah. So it's just drop. It's dropping that top it's rubbing the top level dirt, which is interesting. So it's not preserving the directory structure and it's dropping the top level directory interesting anyway. So here we have our test case now, um all right. So now let's go ahead and check out the we're just going to copy this.

A

We're going to check out yeah what is our character structure attention patch now.

A

There we go yes, okay, so this is the correct now so this has this has the patch. So this is the fix here on the left and there's our test case that we wrote so now. Basically, we write the test case shows the wrong behavior. Now we write the fix and instead of going through how we wrote the fix, we.

A

We are applying the fix from an existing commit, so ideally, what we would do is we would so. This is an example where we wrote the fix and we didn't have a test case associated with the bug, so the ideal workflow here is you write the test case. You make sure that it fails and produces the exact same behavior as your bug report, and then you write the fix and then all of a sudden. The test case will pass right because that's that's!

A

That's the test driven development, so yep that test case passes all right sweet. So let's go ahead and extend this for zip archives. Here.

A

All right so now we've got our test case.

A

Search directory structure, let's run them both all right and uh I got hit with the same bug. So this is why we're subclassing from async test case.

A

A

There we go all right, so this is how we use test driven development to solve this. uh You know to validate our our implementation and solve our bug. So now we've got the test case here and then I'll commit this up all right, great.