def test_creating_new_user_with_existing_name_failsr(
self, main_menu_factory, database_connection):
old_apina = UserDao(database_connection).get_by_name("apina")
start = time.time()
events = [
MockEvent(pygame.key.key_code("return"), "?"),
MockEvent(pygame.key.key_code("a"), "a"),
MockEvent(pygame.key.key_code("p"), "p"),
MockEvent(pygame.key.key_code("i"), "i"),
MockEvent(pygame.key.key_code("n"), "n"),
MockEvent(pygame.key.key_code("a"), "a"),
MockEvent(pygame.key.key_code("down"), "?"),
MockEvent(pygame.key.key_code("return"), "?"),
MockEvent(pygame.key.key_code("escape"), "?"),
MockEvent(pygame.key.key_code("escape"), "?")
]
event_times = [0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 7]
# should only quit at 7 seconds (second escape) if the
# creation was unsuccessful
assert (time.time() - start - 7) < 0.5
event_handler = EventHandlerMock(events=events,
event_times=event_times)
main_menu = main_menu_factory(event_handler)
main_menu.run()
new_apina = UserDao(database_connection).get_by_name("apina")
assert old_apina.id == new_apina.id
def validate_user_exist(self, user_name_input):
user_name_dao = UserDao()
user_name_value = user_name_dao.get_user_name()
for user_name in user_name_value:
if user_name_input != user_name:
return False
return True
def __init__(self):
self.token = ''
self.bot_user_name = ''
self.bot_name = ''
self.updater = Updater(self.token, use_context=True)
self.user_operations = UserOperaetions()
self.user_dao = UserDao()
self.dp = self.updater.dispatcher
self.updater.start_polling()
self.updater.idle()
def main_menu_factory_empty_database(config, database_connection, screen):
user_dao = UserDao(database_connection)
def _inner(event_handler):
return create_main_menu(screen, event_handler, config,
database_connection)
return _inner
class Bot:
def __init__(self):
self.token = ''
self.bot_user_name = ''
self.bot_name = ''
self.updater = Updater(self.token, use_context=True)
self.user_operations = UserOperaetions()
self.user_dao = UserDao()
self.dp = self.updater.dispatcher
self.updater.start_polling()
self.updater.idle()
def start(self, update, context):
context.bot.send_message(chat_id=update.effective_chat.id,
text="I'm a bot, please talk to me!")
def create_user(self, update, context):
context.bot.send_message(chat_id=update.effective_chat.id,
text="adding your values")
user = self.user_operations.create_user(user_name=context.args[0],
password=context.args[1],
adv_key=context.args[2])
self.user_dao.insert_user_name(user)
def validate_user(self, update, context):
context.bot.send_message(chat_id=update.effective_chat.id,
text="checking your values")
user_name = self.user_operations.validate_user_exist(context.args[0])
if not user_name:
context.bot.send_message(chat_id=update.effective_chat.id,
text="user doesn't exist")
return False
return True
def adv_key(self, update, context):
context.bot.send_message(chat_id=update.effective_chat.id,
text="checking your values")
if self.validate_user(update, context):
streets = self.user_dao.get_streets()
context.bot.send_message(chat_id=update.effective_chat.id,
text=streets)
def unknown(self, update, context):
context.bot.send_message(
chat_id=update.effective_chat.id,
text="Sorry, I didn't understand that command.")
def test_creating_new_user(self, main_menu_factory, database_connection):
events = [
MockEvent(pygame.key.key_code("return"), "?"),
MockEvent(pygame.key.key_code("a"), "a"),
MockEvent(pygame.key.key_code("b"), "b"),
MockEvent(pygame.key.key_code("c"), "c"),
MockEvent(pygame.key.key_code("down"), "?"),
MockEvent(pygame.key.key_code("return"), "?"),
MockEvent(pygame.key.key_code("escape"), "?"),
MockEvent(pygame.key.key_code("escape"), "?")
]
event_times = [0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4]
event_handler = EventHandlerMock(events=events,
event_times=event_times)
main_menu = main_menu_factory(event_handler)
main_menu.run()
user_dao = UserDao(database_connection)
assert user_dao.get_by_name("abc") is not None
def test_user_dao(self):
# Make sure we're not overwriting a database
if exists(f'{TestUserDao.db_name}.db'):
logging.fatal(
f"Database test file '{TestUserDao.db_name}.db' already exists. Aborting."
)
return
# Create the database and dao
db = Db(TestUserDao.db_name)
dao = UserDao()
# Test non-existence
self.assertFalse(db.does_table_exist(dao),
f"User table exists before creation")
# Test creation
try:
db.create_table(dao)
except Exception as e:
self.fail(f"Create user table failed with exception {e}")
self.assertTrue(db.does_table_exist(dao),
f"User table does not exist after creation")
# Test empty count
self.assertEqual(dao.get_count(db), 0,
f"User table contains rows when none entered")
# Test deletion
try:
db.delete_table(dao)
except Exception as e:
self.fail(f"Delete user table failed with exception {e}")
self.assertFalse(db.does_table_exist(dao),
f"User table exists after deletion")
# Clean up
db.destroy()
def main_menu_factory(config, database_connection, screen):
user_dao = UserDao(database_connection)
user_dao.create(User("apina"))
user_dao.create(User("banaani"))
user_dao.create(User("cembalo"))
def _inner(event_handler):
return create_main_menu(screen, event_handler, config,
database_connection)
return _inner
def game_factory_factory(config, database_connection, screen):
user_dao = UserDao(database_connection)
user_dao.create(User("apina"))
user_dao.create(User("banaani"))
user_dao.create(User("cembalo"))
def _inner(game_length, event_handler):
config.game_length = game_length
return GameFactory(config,
user_dao,
event_handler,
screen,
n_players=2)
return _inner
def instance():
if not hasattr(DbManager, "_instance"):
DbManager._instance = DbManager()
DbManager._db_conn = MysqlConnect()
DbManager._daos.update({
'episode':
EpisodeDao(DbManager._db_conn),
'user':
UserDao(DbManager._db_conn),
'keyword':
KeywordDao(DbManager._db_conn),
'keyword_episode':
KeywordEpisodeDao(DbManager._db_conn),
'subject':
SubjectDao(DbManager._db_conn),
'subject_episode':
SubjectEpisodeDao(DbManager._db_conn),
'page_episode':
PageEpisodeDao(DbManager._db_conn),
'ordered':
OrderedDao(DbManager._db_conn),
'page':
PageDao(DbManager._db_conn),
'cat_list':
CatListDao(DbManager._db_conn),
'cat_episode':
CatListEpisodeDao(DbManager._db_conn),
'cat_exclude':
CatExcludeDao(DbManager._db_conn),
'channel_exclude':
ChannelExcludeDao(DbManager._db_conn),
'category':
CategoryDao(DbManager._db_conn),
'tag':
TagDao(DbManager._db_conn),
})
return DbManager._instance
def create_main_menu(screen, event_handler, config, database_connection):
"""A Factory method for MainMenu.
Creates a main menu and along it basically the whole application
Arguments:
`screen`: Screen
The target to which the application will be rendered
`event_handler`: An EventHandler
The input events of the application
`config`: Config
`database_connection`: sqlite3.Connection
"""
user_dao = UserDao(database_connection)
game_factory = GameFactory(config, user_dao, event_handler, screen)
menu_item_renderer = MenuItemRenderer(font_color=config.menu_font_color)
menu_list_renderer = MenuListRenderer(
screen, background_color=config.menu_background_color,
item_spacing=config.menu_item_spacing, item_renderer=menu_item_renderer)
menu_input = MenuInput(event_handler, config.menu_input_config)
menu_list_factory = MenuListFactory(
menu_list_renderer, menu_input, Clock(20, sleep_wait, False))
results_viewer = create_results_viewer(menu_input, screen)
stats_dao = StatsDao(database_connection)
game_organizer = GameOrganizer(results_viewer, stats_dao)
new_game_menu = NewGameMenu(game_factory, menu_list_factory, game_organizer)
user_factory = UserFactory(user_dao)
add_user_menu = AddUserMenu(menu_list_factory, user_factory)
high_score_viewer = create_high_score_viewer(stats_dao, 5, menu_input, screen)
return MainMenu(menu_list_factory, new_game_menu, add_user_menu, high_score_viewer)
import logging
import requests
from db import Db
from user_dao import UserDao
total = 150
git_username = "******"
# git_password = ""
url = 'https://api.github.com/users?accept=application/vnd.github.v3+json&per_page=100'
# logging.basicConfig(level=logging.INFO)
# Instantiate the database objects
db = Db()
user_dao = UserDao()
# Create or clean the database
user_dao.create_or_clear_table(db)
# Prepare to make many requests to the database
count = 0
last_id = 0
while count < total:
# Get 100 user records
try:
response = requests.get(url + f'&since={last_id}',
f'auth=({git_username}, {git_password})')
except NameError:
response = requests.get(url + f'&since={last_id}')
def __init__(self, drive_client, sheets_client):
self._service_dao = ServiceDao(sheets_client)
self._songs_dao = SongsDao(sheets_client, drive_client)
self._user_dao = UserDao()
self._recipient_dao = RecipientDao()
self._band_dao = BandDao(self._recipient_dao)
from user_dao import UserDao
from logger_base import logger
from user import User
option = None
while option != '5':
print('Options')
print('1. View Users:')
print('2. Add User')
print('3. Update User')
print('4. Delete User')
print('5. Exit')
option = input('Inser an option (1-5): ')
if option == '1':
# view users
users = UserDao.select()
for user in users:
print(user)
logger.debug(user)
elif option == '2':
# insert user
username = input('Insert username: '******'Insert password: '******'User insert {insert_data}')
elif option == '3':
# update user
id_user = input('Insert user to update: ')
username = input('Insert new username: ')