In this last lesson on our end-to-end testing module, let's go about adding in a final test in order to test each of the individual flags we can pass into our application.

To do so, I've quickly created a simple test file using the create file function we made in the last lesson. Now with our file created and being cleared up after the end of the function, let's go ahead and run a subtest for each of the three flags we can pass in.

First of all, let's go ahead and do the lines flag as follows, which has our testing function of t.testing. Then inside of this, we can go ahead and get our command, which we can call with

cmd error = get command,

and then passing in the -l flag as well as our file.name. Let's go ahead and check for the error as normal. Here we can do

t.fail, 
t.log, 
fail to get command for,

I will just do fail to get command, print out the error, and we'll do a t.fail.

Next, let's create a bytes.buffer so we can access stdout.

command.stdout = our stdoutput.

Then we can run our command using the cmd.run command, again doing our

if error is not equal to nil,

t.log, fail to run command, as well as printing out what the error actually is. And t.fail.

Lastly, we can go ahead and check our actual output.

output = stdout.string.

Let's go ahead and define our expectation.

expected = format.sprintf.

In fact, sprint line in this case. Let's do sprintf. It's going to be space, space, two, space, space, and then a string, which in this case is going to be the file name. Then if output is not equal to expectation or expected, we can print out our error message as we've seen before, which in this case is going to be

t.log, 
output did not match expectation.

To speed this up, I'm just going to put the output and the expected. And we'll do the t.fail.

Now let's go ahead and test this code to see if it works, which in this case it doesn't. Oh yeah, I have a need to add in a new line. Let's go ahead and do that. Test this again. This time it's working as expected.

Now we could go ahead and just copy this and paste it in, in order to do both the bytes and the words as well. However, this would be a good candidate to do some table-driven tests. So in this case, we could do

test cases = struct.

Which is going to have our name of the test, which is going to be a string. The wants, which is going to be a string. And in this case, we're going to have an input, which is going to be our flags. So let's go ahead and set flag.

flags = a slice of string for each individual flag that we can pass in.

Let's go ahead and create our initial test case, which is going to be a name of line flag. Passing in the flags themselves of string and we'll pass in a single flag of -L, which represents the same flag we're passing in here. I'm going to reorder these just to make them a bit easier for my brain. And then the want or the expectation is going to be what we have here. This

format.sprintf.

Let's go ahead and press that in. Now we can iterate over each of these test cases. So for

tc = range of test cases.

Then we can do

t.run, 
tc.name,

pass in the tc.flags as follows. Then we need to define our inputs, which we can do as

inputs = append(tc.flags).

And we'll pass in the file.name as well. Then we can just go ahead and call our inputs as follows. Lastly, we then want to make sure that we check our expectation, which here, rather than using expected, we can just do tc.want. And we'll make the same change here as well. We'll do

output did not match.

Now if we go ahead and test this, it should pass as it did before, which it does. And we can go ahead and simply add in some other tests into this.

Let's go ahead and add one for the bytes flag, which in this case is going to be a -B. In our case, how many bytes we've got? I think we have 38. I could be wrong here, though. Let's go ahead and add in 38 just to see.

And then we can add in the name of words flag. In this case, it's going to be a string of -W. And for the number of words, we have eight. Let's go ahead and add in that missing comma. Now if we go and test this, everything is working. I must have guessed the correct number of bytes, which we can see by having these subtests being ran and passing.

With that, we now have an acceptable level of end-to-end tests covering our entire application flow. As I mentioned at the start of this module, end-to-end testing is less about ensuring correctness against each possible test case, but in my opinion, is more about having a sort of simple smoke test, ensuring that the functionality that you've implemented is accessible and has the expected behavior. In this case, I think that the end-to-end tests that we have here have managed to complete that mission.

Therefore, as always, let's go ahead and commit this code as follows. First, adding the main.go, where we made some changes there, as well as also adding our new test directory. Then we can commit this as follows. Added in end-to-end testing and deterministic printing. With that, we have now finished the work on our counter application.

With that, you can go ahead and now save this code anywhere you want, or you can make your own adjustments to it, depending on what features you might want to add. Other than that, I'll see you in the next module.