Testing recursive class methods using unit testing python - python-3.x

Question

class Login:
def admin_login(self):
user_name = input('Enter UserName: -')
password = input('please enter password:- ')
try:
with open(r'/home/Downloads/amis/config.yaml') as file:
credentials = yaml.load(file)
if credentials['userid'] == user_name and credentials['password'] == password:
admin_op = AdminOps(credentials)
admin_op.admin_ops()
else:
print("please enter correct login creds")
self.admin_login()
except:
print('err')
self.admin_login()
I am testing this class method and i am trying to mock the method then it is not even going into this method for testing. Can anyone help me writing unit test for this class method.
I tried this for the wrong credentials.
#mock.patch('users.logins.input', create=True)
def test_admin_login_fail(self,ext, inp1):
inp1.side_effect = ['qqq', 'qqq']
login_cls = Login()
login_cls.admin_login()
with mock.patch('file path') as mock_login:
assert mock_login.called

Answer 1

reproducible problem
Admittedly I don't know much about pytest but the problems I see are generic ones and not linked to use of a specific language or library. I'm going to simplify the problem a little bit. Hopefully it can show us a path forward -
def login(creds = {}):
u = input("username:")
p = input("password:")
if u in creds and creds[u] == p:
print(f"{u} logged in")
else:
print(f"invalid login. please retry...")
login(creds)
login({"ripley": "password1"})
I run the program -
username:foo
password:bar
invalid login. please retry...
username:ripley
password:password1
ripley logged in
how to test?
Okay, it works but I still have a testing problem. When an invalid login is provided, login loops endlessly. However, this is not a testing problem, it's a problem with how we wrote our program. The program has a problem of mixing concerns. We already separated one concern by passing credentials as an argument to the login function. Already, if there's a read or yaml.parse error, we don't have to deal with those inside of login. But there's additional concern of input and print side effects...
def login(creds = {}, u = "", p = ""):
return u in creds and creds[u] == p
creds = {"ripley": "password1"}
print(login(creds, "foo", "bar")) # False
print(login(creds, "ripley", "password1")) # True
Now testing is basic login functionality is easy -
def test_login(self):
assert login({}, "foo", "bar") == False
assert login({"foo": "bar"}, "foo", "bar") == True
creds, user, and pass are all arguments to the login function so we can verify our function's behavior without worrying about read or yaml.parse
write functions with parameters
Okay, but what if we want to test login in a looping procedure? Again, we apply what we learned above and write functions that accept arguments -
class ui:
def __init__(self, creds, I, O): # <-- params: creds, input, output
self.creds = creds
self.I = I
self.O = O
self.user = None
def login(self, exit = None): # <-- param: exit handler
u = self.I("user:")
p = self.I("pass:")
if (login(self.creds, u, p)):
self.O(f"{u} logged in")
self.user = u
elif exit is None:
self.O("invalid login")
self.login()
else: exit()
In production, we might run our program like this -
creds = {"ripley": "password1"}
app = ui(creds, input, print) # <-- args: creds, input, output
app.login()
In testing, we could write test_ui_login_failure like this -
def test_ui_login_failure():
def I (prompt): # input
if prompt == "user:":
return "foo"
elif prompt == "pass:":
return "bar"
def O (s): # output
assert s == "invalid login"
app = ui({}, I, O) # <-- args: empty creds, input, and output
app.login(lambda: None) # <-- args: exit handler
Writing test_ui_login_success might look like this -
def test_ui_login_success():
def I (prompt):
if prompt == "user:":
return "foo"
elif prompt == "pass:":
return "bar"
def O (s):
assert s == "foo logged in"
app = ui({"foo": "bar"}, I, O)
app.login(lambda: None)
higher-order control
Adding the exit parameter to ui.login gives us the control we need in the testing environment and it let's us implement a more sophisticated login routine, if needed -
def retry (n = 0, f = lambda _: None):
if n <= 1:
return lambda: None
else:
return lambda: f(retry(n - 1, f))
class ui:
def __init__(self, creds, I, O):
# ...
def login(self, exit = None):
# ...
if (login(self.creds, u, p)):
# ...
elif exit is None:
self.O("invalid login")
self.login(retry(2, self.login)) # <-- retry login twice more
else:
self.O("invalid login")
exit()
We can run ui.login same as last time -
creds = {"ripley": "password1"}
app = ui(creds, input, print)
app.login()
The loop stops after 3 failed attempts -
user:foo
pass:bar
invalid login
user:spaghet
pass:meatbal
invalid login
user:ada
pass:lovelace
invalid login
Our previous tests test_ui_login_failure and test_ui_login_success still pass. Of course you could write a test to verify the retry behaviour as well. This exercise is left for the reader.
remarks
Hopefully these techniques help show that subtle differences in how we write a program can results in dramatic differences in how we test it.