sheet2graph command-line program

Transcript

so now we have some basic tests but we need to

start testing uh real things so um we're gonna need a few helpers

right like a few functions that we're gonna be

calling to create files to check the the size of the images we

generate so let's commit that in a separate

branch and we're gonna call it uh testing

helpers testing helpers and now let's let's see

so basically here we're gonna write tests and uh what is our command

doing right so let's put this here so our command is doing things like

creating files [Music]

creating files like here and generating images of different sizes

so these are things that it would be cool to test

so let's just write here a small list so you don't forget

so things that could be useful to check could be if a file is created

in a specific path then we also have a google docs option

here somewhere exactly so we have this google option right so we also need to

check if google docs is open

uh we need to check if the files in different formats work

so it means if the image is generated like if the image is not generated the

program is not doing what it should be doing it's not working

as intended and the resolutions or the size of the

file of your file okay so we'll just get this

this memento here so we don't forget and uh we're gonna be creating tons of files

right uh so to make sure that we don't mess up

with uh our current files here like uh like the environment or other files that

we could have here we can set up like a a test folder

and then we can create fake files in or real files but uh for tests

inside that folder so in this way we can delete this folder safely knowing

that we even delete anything important so i hope this will become

clearer so basically i create this folder

right i name it here for the output and the name is like

uh something that doesn't exist and it's a bit

complicated that it exists and because of this name is very strange right

um so basically what we want here is that

every time here there's going to be a folder created with this

and then all our test files will be created inside

and then every time we finish or before we start

we're going to delete all those files this way we know that every test

starts from exactly the same point and and that tests are not interacting with

each other we wouldn't like that for instance one test creates one file a png

and then the other test is just checking if a png file was created

and it's checking the other one so this is why we need to

to have this set up and tear down so we're gonna need a few things uh i

would say once we have a file we're gonna need to

check if a file exists right so we're gonna need and these are the

helpers so whether i need something that looks

more or less like this file exists this we don't want to

it's inside this class but it's more like a utility method

so because of this we can mark it as static and then

it doesn't have to self so we can do something like this

and then for this there's like a method from os

path this file so this and we we can import it

so this we can use this helper to see if a file exists

which is something we're gonna for sure need um

because we're creating all these these files no and

then another thing that would be interesting to know

is for the resolution of files we would like to know

the resolution of an image so when we generate

um this kind of images like we want to do the equivalent of

this here of seeing here what is the resolution so

to do this we can use we can use a library called

pill in python and let's create here another method as

well and we're going to do it also static

and we call it resolution solution and we also pass the file path

okay and then we open an image um

we need to install this library but first let's sketch it a bit here

so basically it's like this and then this has a like an attribute called size

you can check this if you want in the documentation

like um exactly so

yeah you can see here the different methods but here there will be for sure

a size [Music]

one image size exactly so this one and it

determines a double of of uh width and height so

if we do that this is going to be we can hide and we return it

so these two methods will help us like to know if a file scripting path

um google docs is also going to be a file creating path

then um if an image is generated we can also test with the

file exists which would just be like for an image file instead and the resolution

of the file we can use this one that we'll just get the

resolution um okay so right now this should

break because we don't have the pill instead right the editor is warning us

also so let's just just run like the test

yeah and it fails because of the import so uh

what we need to install this uh this right but um

this we don't need to add as a dependency i mean the easiest way is we

can just install it like anything else in the

make file so we could like come here and just add

it to the just uh install it with the pip install

and then add it to the requirements but at the same time the user doesn't need

this because this is just to run the test so

only needed to run the test we just have it here in

case some some curious user checks but uh the

easiest way of course is just to add to the requirements so we need to

install it anyway at least for ourselves so let's do that

now so we can do the pip install but

exactly pillow so this one is not called peel

but pillow so if we just install it and now the test run because the import

is valid um so here you can choose but basically

we can add it to the requirements so the user will need to install pillow so it's

one more dependency or we can somehow put it only here

and then the user needs to read this or we could have another set of

requirements in case you want to test so because it's just this library and

it's quite common and we're just going to add it to the

requirements so we can do like make freeze

and then it's added to the requirements right so if we do like uh

we can see here that below what are the requirements um

[Music] of course there could be all these other

solutions like a different requirements file or just some instructions

but for just one dependency and a common one

um i i will just add it here and then um we also need

some some kind of command to run this thing right like um for the

tests so what i mean by this is um our program

is a command line program and we don't want to call it simply

let's say from within this part from within python

we want to call it from the outside but so we we want to actually run these

commands like commands like this one like

environment python so because we want to test the

the parsing of options so um so this test is not going to be about

testing inside python loading some module and checking that the function

that's what we want but we want to actually run it in the command line

so to do that let's add another utility method and we're going to call

this one command and here we'll pass some param

parameters string let's add here some comments

okay and then we're gonna have some comment and the comment

uh will look like this it will look like this so same command

we run plus the parameters here

which is like the continuation of the command so here would be all the options

all the flags and then we need to interpolate these

params okay and then we need to call the

command and there's different ways of doing this in python

for now we're just going to use this one maybe later we'll revisit this but for

now let's keep it simple and we just call

system um yeah so this will just run commands the same as if we would run it

in the command as if we could run them in the command line

so with this i think we have all the basic blocks to start testing

so before we start writing the real test let's just

take a look at the setup and the teardown

so basically for the setup [Music]

we've said that we're going to be using this folder right

so anything we generate any image we generate

is going to be into this folder one two three folder output tests

then what we need to do is uh basically for setup we need to make sure that this

folder exists so that we can create things inside it

and for teardown we want to delete this folder

so that the next time we can create everything from scratch this will happen

for every single test so this way we know that every test that

comes later we have the same baseline the same environment

and that they won't be interacting weirdly with each other

so let's start by doing by loading a pathway which is like this library we

used before with this model uh to deal with paths

because this is all paths and then and to set up we need to

create the folder right okay so let's do that

we can just use path lib and then here we use

we're going to create the folder because this is in the class

self folder output is the way to access it

and then we use this function called make deer that is basically the same as

uh as the command make there right as this

that we used before so we've already used this before

um so let's just let's just i mean type it here but we

can check here we used it before here it is right so it creates uh

parents if necessary if it exists it's okay and so this is

exactly what we want so parents it's true

and exists okay it's true so that's it this one just creates a

folder that we need so we're done with this and then for the

tier then we need to remove uh this folder

then there's different ways to remove a folder

uh but uh there's one library that is part of the standard

library that's called ssh youtubes like like

and then you can check the documentation for that

so it just you use python exactly high level file operations so

here there's different new leads to copy files

and create them and delete them and what we want is this one the remove

tree because inside this folder um

inside this folder that we saw there's gonna be

other folders right so we're gonna have something like this

created automatically and then here we have like test

and then inside this test something else so we want to remove all of these at

once the same as as this so just deleting

all of them and this function does exactly that

so this remove tree is removing recursively

if you say here delete an entire directory three

so basically it goes inside each folder so let's use it

we already imported it and then we do something like this

remove three and with the folder for the output

and something else so now the import works let's just run

the test to see that nothing here is breaking

perfect so it runs as usual so with this we have all the

all the building blocks to to test this we have like an environment that will be

the same for its tests we have a place to build to create

images and files without affecting our system

and we have this utility methods for like

checking if a file exists checking an image resolution

actually here we forgot to open the image with the path

yes so now we have it checking the image resolution

and to run a command um let's move on to write

the real tests but before let's commit the changes we have here you see we have

only the requirements and the test so let's add all of this

okay and we'll commit as helpers