def test_load_users(monkeypatch):
'''
Test each aspect of load_users
'''
def bad_file(self): # pylint: disable=W0613
'''
Simulates an empty file for testing
'''
return iter([]) # Empty file
header = 'header to be eaten'
bad_data = [
('way', 'too', 'many', 'params', 'test'), # Too many parameters
('not', 'enough', 'params'), # Not enough parameters
('', '*****@*****.**', 'one', 'name'), # Empty user_id
('missing2', '', 'two', 'name'), # Empty email
('missing3', '*****@*****.**', '', 'name'), # Empty name
('missing4', '*****@*****.**', 'four', '')
] # Empty last name
assert main.load_users('accounts.csv') # Test sucessful inserts
assert not main.load_users('accounts') # Refuse non csv files
monkeypatch.setattr(csv, 'reader', bad_file)
assert not main.load_users('accounts.csv') # Refuse empty files
for test in bad_data:
user_data = [header] + [test]
csv.reader = Mock(return_value=iter(user_data))
assert not main.load_users('accounts.csv') # Refuse to use bad data
def test_load_users_ignore_existing(filename, csv_collection):
main.load_users(filename, csv_collection)
loaded_users = []
for key in csv_collection.database:
loaded_users.append(key)
for item in loaded_users:
assert loaded_users.count(item) == 1
assert len(loaded_users) == 3
def baseline():
'''
Method needed for memory profiling
'''
user_baseline = main.init_user_collection()
status_baseline = main.init_status_collection()
main.load_users('accounts.csv', user_baseline)
main.load_status_updates('status_updates.csv', status_baseline)
main.add_user('dave03', '*****@*****.**', 'Dave', 'Jones', user_baseline)
main.add_status('dave03', 'dave03_01', 'Random text', status_baseline)
main.update_user('dave03', '*****@*****.**', 'Dave', 'Rex', user_baseline)
main.update_status('dave03', 'dave03_01', 'Whos in charge now',
status_baseline)
main.search_user('dave03', user_baseline)
main.search_status('dave03_01', status_baseline)
main.delete_status('dave03_01', status_baseline)
main.delete_user('dave03', user_baseline)
def test_load_users_bad_file(user_file):
'''
Test that load_users will only work with .csv files
'''
csv.reader = Mock(return_value=iter([]))
with patch('main.users.UserCollection') as mocker:
insert = mocker.return_value.table.insert_many
assert not main.load_users(user_file[:-4], mocker())
insert.assert_not_called()
def test_load_users_empty_file(user_file):
'''
Test that load_users reports empty files
'''
with patch('main.users.UserCollection') as mocker:
csv.reader = Mock(return_value=iter([]))
assert not main.load_users(user_file, mocker())
insert = mocker.return_value.table.insert_many
insert.assert_not_called()
def load_users():
"""
Loads user accounts from a file
"""
filename = input('Enter filename of user file: ')
if not main.load_users(filename, user_collection):
print("An error occurred while trying to load users")
else:
print("Load users was successful")
def test_load_users(user_file):
'''
Test that user data is tranfered from the CSV file to the database
'''
db_fields = ('user_id', 'user_name', 'user_last_name', 'user_email')
# Last item must have be a repeaded user_id
user_data = [('header to be eaten'),
('evmiles97', 'Eve', 'Miles', '*****@*****.**'),
('dave03', 'David', 'Yuen', '*****@*****.**'),
('evmiles97', 'Eve', 'Miles', '*****@*****.**')]
csv.reader = Mock(return_value=iter(user_data))
with patch('main.users.UserCollection') as mocker:
insert = mocker.return_value.table.insert_many
assert main.load_users(user_file, mocker())
insert.assert_called_once_with(user_data[1:-1], fields=db_fields)
def test_load_users_empty_data(user_file):
'''
Test that load_users will not transfer empty data
'''
bad_data = [('', '*****@*****.**', 'one', 'name'),
('missing2', '', 'two', 'name'),
('missing3', '*****@*****.**', '', 'name'),
('missing4', '*****@*****.**', 'four', '')]
header = 'header to be eaten'
with patch('main.users.UserCollection') as mocker:
insert = mocker.return_value.table.insert_many
for test in bad_data:
user_data = [header] + [test]
csv.reader = Mock(return_value=iter(user_data))
assert not main.load_users(user_file, mocker())
insert.assert_not_called()
def test_load_users_param_check(user_file):
'''
Test that load_users will only transfer data with four parameters
'''
bad_data = [('way', 'too', 'many', 'params', 'test'),
('*****@*****.**', 'one', 'name'),
('missing2', 'two', 'name'),
('missing3', '*****@*****.**', 'name'),
('missing4', '*****@*****.**', 'four')]
header = 'header to be eaten'
with patch('main.users.UserCollection') as mocker:
insert = mocker.return_value.table.insert_many
for test in bad_data:
user_data = [header] + [test]
csv.reader = Mock(return_value=iter(user_data))
assert not main.load_users(user_file, mocker())
insert.assert_not_called()
def test_load_users(user_file, user_keys):
'''
Test that user data is tranfered from the CSV file to the database
'''
db_fields = (user_keys[0], user_keys[2], user_keys[3], user_keys[1])
# Last item must have be a repeaded user_id
user_data = [('header to be eaten'),
('evmiles97', 'Eve', 'Miles', '*****@*****.**'),
('dave03', 'David', 'Yuen', '*****@*****.**'),
('evmiles97', 'Eve', 'Miles', '*****@*****.**')]
call_data = []
for data in user_data[1:-1]:
call_data.append(dict(zip(db_fields, data)))
csv.reader = Mock(return_value=iter(user_data))
with patch('main.users.UserCollection') as mocker:
assert main.load_users(user_file, mocker())
insert = mocker.return_value.table.insert_many
insert.assert_called_once_with(call_data)
def test_load_users(db):
assert main.load_users('accounts_small.csv') is True
print(list(db['users']))
assert list(db['users']) == [{
'id': 1,
'NAME': 'Eve',
'EMAIL': '*****@*****.**',
'USER_ID': 'evmiles97',
'LASTNAME': 'Miles'
}, {
'id': 2,
'NAME': 'David',
'EMAIL': '*****@*****.**',
'USER_ID': 'dave03',
'LASTNAME': 'Yuen'
}, {
'id': 3,
'NAME': 'Alvaro',
'EMAIL': '*****@*****.**',
'USER_ID': 'alcon49',
'LASTNAME': 'Conejo'
}]
def test_load_users(self):
self.assertEqual(main.load_users('accounts.csv', self.user_collection),
True)
def test_load_users_true(filename, collection):
result = main.load_users(filename, collection)
assert result is True
def test_load_users_false(collection):
result = main.load_users('missing_fields.csv', collection)
assert result is False
'''
Simple test for loading data into database
'''
from multiprocessing import Process, Queue
import main
def fun(queue):
'''
Example demenstrating queues
'''
queue.put([42, None, 'hello'])
if __name__ == '__main__':
que = Queue()
pro = Process(target=fun, args=(que,))
pro.start()
print(que.get()) # prints "[42, None, 'hello']"
pro.join()
# test main now
accounts = main.init_user_collection()
statuses = main.init_status_collection()
accounts.table.drop()
statuses.table.drop()
print(main.load_users('accounts.csv', accounts))
print(main.load_status_updates('status_updates.csv', statuses))
'''
Import into ipython for easier testing
'''
import peewee as pw # pylint: disable = W0611
import main
user = main.init_user_collection()
status = main.init_status_collection()
main.load_users('accounts.csv', user)
main.load_status_updates('status_updates.csv', status)
def load_users():
'''
Loads user accounts from a file
'''
filename = input('Enter filename of user file: ')
main.load_users(filename)
def test_load_users():
'''
Test each aspect of load_users
'''
assert main.load_users('accounts.csv')
def test_save_users(self):
main.load_users('accounts.csv', self.user_collection)
self.assertEqual(
main.save_users('accounts_saved.csv', self.user_collection), True)
def load_users():
'''
Loads user accounts from a file
'''
filename = input('Enter filename of user file: ').strip()
main.load_users(filename, user_collection)
