The next thing I wanted to do is to generate the random values the computer hides that the user will have to guess. In the original description I describe that both the number of the hidden items and the type of their value is flexible, but at first let's use only 4 different digits between 1-6.
Test the random values
The first thing was to add the a test case to the already existing test file, that will verify that the, not yet existing new_secret
will return the correct results.
However, we have a problem. How can we test a function that will return a random set of values?
In our case we could check
- if the correct number of values were returned
- if they are distinct
- if they are from the same pool of data
def test_new_secret():
secret = mm.new_secret()
assert len(secret) == 4
assert len(set(secret)) == 4
assert set(secret).issubset(list(range(1, 7)))
If we run pytest
now it will obviously fail as the new_secret
has not been implemented yet, but we can do that.
The implementation
It is actually shorter than the test:
import random
def new_secret():
pool = list(range(1, 7))
return random.sample(pool, 4)
Running the tests
Now we can run the tests
PYTHONPATH=. pytest
Let's see the full files:
mastermind/game.py
import random
def play():
...
def new_secret():
pool = list(range(1, 7))
return random.sample(pool, 4)
tests/test_game.py
import mastermind.game as mm
def test_game():
mm.play()
assert True
def test_new_secret():
secret = mm.new_secret()
assert len(secret) == 4
assert len(set(secret)) == 4
assert set(secret).issubset(list(range(1, 7)))
The problem of duplication
I feel a bit that this test is a bit of overdoing things, but it will be useful to have when we'll start to allow the user to have different size of hidden value and different types of hidden values.
The more problematic thing is that several values were duplicated. For example the pool and the size of hidden value.
Create global constants
One solution to this is to move these values to global variables or global constants. Let's see that:
mastermind/game.py
import random
POOL = list(range(1, 7))
SIZE = 4
def play():
...
def new_secret():
return random.sample(POOL, SIZE)
tests/test_game.py
import mastermind.game as mm
def test_game():
mm.play()
assert True
def test_new_secret():
secret = mm.new_secret()
assert len(secret) == mm.SIZE
assert len(set(secret)) == mm.SIZE
assert set(secret).issubset(mm.POOL)
I used upper-case variable names as in python the convention is that constants (basically variable that should not change) are named in upper case.
In a way this is better solution as we don't repeat the number 4 and the creation of the POOL, but now that they are global we won't be able to set them without using some nasty code.
We'll have to deal with that later.
In addition now the test depends on the code generating the POOL
correctly.
Test the exact returned values
Let's add another test case which is a lot more fixed. In which we check the exact values returned by the new_secret
function.
The problem is that these are random values so they will be different every time we run the test. To see this I added a print
statement to the test code:
secret = mm.new_secret()
print(secret)
Then I ran pytests
several times with the -s
flag. That tells pytest
to let through the output that goes to STDOUT and STDERR.
PYTHONPATH=. pytest -s
Indeed the result printed was different every time:
[6, 5, 1, 4]
[5, 4, 3, 2]
[5, 6, 2, 3]
Test by fixing the random generator
You might already know that the random
module of Python generates Pseudo-random numbers and that the random.sample()
function uses these Pseudo-random numbers to select the sample.
You might also know that using random.seed()
we can fix where the Pseudo-random number generator starts.
So we can write a test where do just that:
import random
def test_fixed_secret():
random.seed(42)
secret = mm.new_secret()
print(secret)
The 42 was selected in a totally arbitrary way.
This time, no matter how many times we run the test we will get back the exact same result:
[6, 1, 5, 3]
So our new test will look like this:
def test_fixed_secret():
random.seed(42)
secret = mm.new_secret()
assert secret == [6, 1, 5, 3]
Now we have two separate test functions. One reuses the current values of the POOL and SIZE, the other one expect a very specific result.
The whole test file
Just for completeness, here is the whole test file as we have it now:
import random
import mastermind.game as mm
def test_game():
mm.play()
assert True
def test_new_secret():
secret = mm.new_secret()
assert len(secret) == mm.SIZE
assert len(set(secret)) == mm.SIZE
assert set(secret).issubset(mm.POOL)
def test_fixed_secret():
random.seed(42)
secret = mm.new_secret()
# print(secret)
assert secret == [6, 1, 5, 3]
Conclusion
There are choices in the implementation that will impact how nice our code will look like, but having tests will make it much safer to change our code as we will be able to easily verify that we did not break anything.
In the meantime you can try to play with the above code. You could enable the print
statement, change the value of the seed
, run the tests and see how for every seed we get a different response.
See you next part
Top comments (0)