def setUp(self):
self.reserves = []
self.strings = RuReserve
self.chat = Chat()
self.chat.id = 101
self.user = User()
self.user.first_name = "Firstname"
self.user.id = 111
dp = Dispatcher()
self.data_adapter = MemoryDataAdapter()
self.state_manager = StateManager(self.data_adapter)
self.processor = ReserveProcessor(dp, self.state_manager, self.strings)
message = Message()
message.chat = self.chat
message.from_user = self.user
message.message_id = 121
message.text = "Some text"
message.answer = self.answer_mock
message.delete = self.delete_mock
message.edit_text = self.edit_text_mock
self.test_message = message
callback = CallbackQuery()
callback.bot = Bot()
callback.answer = self.callback_answer_mock
callback.message = message
callback.from_user = User()
callback.from_user.id = 101
self.test_callback_query = callback
def setUp(self):
super().setUp()
self.strings = RuWake
self.dp = Dispatcher()
self.data_adapter = MemoryDataAdapter()
self.state_manager = StateManager(self.data_adapter)
self.processor = WakeProcessor(self.dp, self.state_manager,
self.strings)
def setUp(self):
super().setUp()
self.strings = RuSupboard
self.dp = Dispatcher()
self.data_adapter = MemoryDataAdapter()
self.state_manager = StateManager(self.data_adapter)
self.processor = SupboardProcessor(self.dp, self.state_manager,
self.strings)
self.processor.max_count = 6
def setUp(self):
self.data_adapter = MemoryDataAdapter()
self.state_provider.data_adapter = self.data_adapter
self.chat = Chat()
self.chat.id = 101
self.user = User()
self.user.id = 111
state_data1 = {"state": "main", "state_type": "reserve"}
state_data2 = {"state": "book", "state_type": "reserve"}
self.data_adapter.append_data("101-111-121", state_data1)
self.data_adapter.append_data("101-111-122", state_data2)
class SupboardProcessorTestCase(ReserveProcessorTestCase):
"SupboardProcessor class"
def setUp(self):
super().setUp()
self.strings = RuSupboard
self.dp = Dispatcher()
self.data_adapter = MemoryDataAdapter()
self.state_manager = StateManager(self.data_adapter)
self.processor = SupboardProcessor(self.dp, self.state_manager,
self.strings)
self.processor.max_count = 6
def prepare_data(self):
self.connection = sqlite3.connect("bot_tests/data/sqlite/wake.db")
cursor = self.connection.cursor()
cursor.execute("DROP TABLE IF EXISTS sup_reserves")
cursor.execute("DROP TABLE IF EXISTS users")
self.connection.commit()
self.supboard_adapter = SqliteSupboardAdapter(self.connection)
self.user_adapter = SqliteUserAdapter(self.connection)
for user in sup_users:
self.user_adapter.append_data(user)
self.reserves = []
start_time = time(datetime.today().time().hour + 1)
for i in range(8):
user = sup_users[i % 5]
start_date = date.today() + timedelta(i - 2)
supboard = Supboard(user,
start_date=start_date,
start_time=start_time,
set_count=(i + 1))
supboard.count = i % 3
supboard = self.supboard_adapter.append_data(supboard)
self.reserves.append(supboard)
self.processor = SupboardProcessor(self.dp, self.state_manager,
self.strings, self.supboard_adapter,
self.user_adapter)
self.processor.max_count = 6
def append_state(self, key, state_type="*", state="*"):
state_data = {}
state_data["state_type"] = state_type
state_data["state"] = state
self.data_adapter.append_data(key, state_data)
def create_book_keyboard(self):
"""Create book menu InlineKeyboardMarkup"""
result = InlineKeyboardMarkup(row_width=6)
button = InlineKeyboardButton(self.strings.count_button,
callback_data='count')
result.add(button)
# Adding Date- and Time- buttons by a row for each
button = InlineKeyboardButton(self.strings.date_button,
callback_data='date')
result.add(button)
button = InlineKeyboardButton(self.strings.time_button,
callback_data='time')
result.add(button)
# Adding Set- and Hour- buttons in one row
set_button = InlineKeyboardButton(self.strings.set_button,
callback_data='set')
hour_button = InlineKeyboardButton(self.strings.hour_button,
callback_data='set_hour')
result.row(set_button, hour_button)
button = InlineKeyboardButton(self.strings.phone_button,
callback_data='phone')
result.add(button)
if self.state_manager.data:
reserve: Supboard = self.state_manager.data
if reserve.is_complete:
button = InlineKeyboardButton(self.strings.apply_button,
callback_data='apply')
result.add(button)
# Adding Back-button separately
button = InlineKeyboardButton(self.strings.back_button,
callback_data='back')
result.add(button)
return result
def create_main_text(self):
return self.strings.hello_message
def create_list_text(self):
if not self.reserves:
return self.strings.list_empty
result = f"{self.strings.list_header}\n"
cur_date = None
for i in range(2, len(self.reserves)):
reserve = self.reserves[i]
if not cur_date or cur_date != reserve.start_date:
cur_date = reserve.start_date
result += f"*{cur_date.strftime(self.strings.date_format)}*\n"
start_time = reserve.start_time.strftime(self.strings.time_format)
end_time = reserve.end_time.strftime(self.strings.time_format)
result += f" {i - 1}. {start_time} - {end_time}"
result += f" x {reserve.count}"
result += "\n"
return result
def create_book_text(self, show_contact=False):
reserve = self.state_manager.data
result = (f"{self.strings.service_label} "
f"{self.strings.service_type_text}\n")
if reserve.user:
result += f"{self.strings.name_label} {reserve.user.displayname}\n"
if show_contact and reserve.user.phone_number:
result += (f"{self.strings.phone_label} "
f"{reserve.user.phone_number}\n")
result += (f"{self.strings.date_label} "
f"{reserve.start_date.strftime(self.strings.date_format)}"
"\n")
if reserve.start_time:
start_time = reserve.start_time.strftime(self.strings.time_format)
result += (f"{self.strings.start_label} " f"{start_time}\n")
end_time = reserve.end_time.strftime(self.strings.time_format)
result += (f"{self.strings.end_label} " f"{end_time}\n")
result += (f"{self.strings.set_type_label} "
f"{self.strings.set_types[reserve.set_type.set_id]}"
f" ({reserve.set_count})\n")
result += f"{self.strings.count_label} {reserve.count}"
return result
async def test_cmd_supboard(self):
"""Proceed /sup command"""
message = self.test_message
message.text = "/sup"
reply_markup = self.create_main_keyboard()
await self.processor.cmd_sup(message)
state_data = self.data_adapter.get_data_by_keys('101-111-1001')
passed, message = self.assert_params(self.message.text,
self.strings.hello_message)
assert passed, message
passed, message = self.assert_params(self.message.reply_markup,
reply_markup)
assert passed, message
passed, message = self.assert_params(state_data["state_type"], "sup")
assert passed, message
passed, message = self.assert_params(state_data["state"], "main")
assert passed, message
async def test_callback_main_book(self):
"""Proceed press Book button in Main menu"""
callback = self.test_callback_query
callback.data = "book"
reply_markup = self.create_book_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "sup", "main")
checked = self.processor.check_filter(callback.message, "sup", "main")
passed, message = self.assert_params(checked, True)
assert passed, message
await self.processor.callback_main(callback)
text = self.create_book_text()
text += f"\n{self.strings.phone_warning}"
self.check_state(state_key, text, reply_markup, "sup", "book")
async def test_callback_main_list(self):
"""Proceed press List button in Main menu"""
self.prepare_data()
callback = self.test_callback_query
callback.data = "list"
reply_markup = self.create_list_keyboard(True)
state_key = "101-111-121"
self.append_state(state_key, "sup", "main")
checked = self.processor.check_filter(callback.message, "sup", "main")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_main(callback)
self.check_state(state_key, self.create_list_text(), reply_markup,
"sup", "list")
async def test_callback_book_date(self):
"""Proceed press Date button in Book menu"""
callback = self.test_callback_query
callback.data = "date"
reply_markup = self.create_date_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "sup", "book")
checked = self.processor.check_filter(callback.message, "sup", "book")
passed, message = self.assert_params(checked, True)
assert passed, message
await self.processor.callback_book(callback)
self.check_state(state_key, self.create_list_text(), reply_markup,
"sup", "date")
async def test_callback_book_apply(self):
"""Proceed Apply button in Book menu"""
self.prepare_data()
callback = self.test_callback_query
callback.data = "apply"
state_key = "101-111-121"
self.append_state(state_key, "sup", "book")
checked = self.processor.check_filter(callback.message, "sup", "book")
passed, alert = self.assert_params(checked, True)
assert passed, alert
self.reserves[2].start_time = time(22)
self.state_manager.set_state(data=self.reserves[2])
await self.processor.callback_book(callback)
reserve = self.state_manager.data
reserve = self.supboard_adapter.get_data_by_keys(reserve.id)
passed, alert = self.assert_params(reserve.set_count, 3)
assert passed, alert
# Check that state is finished
state_data = self.data_adapter.get_data_by_keys(state_key)
passed, alert = self.assert_params(state_data, None)
assert passed, alert
async def test_callback_details_cancel(self):
"""Proceed press Cancel button in Details menu"""
self.prepare_data()
callback = self.test_callback_query
callback.data = "cancel-4"
state_key = "101-111-121"
self.append_state(state_key, "sup", "details")
checked = self.processor.check_filter(callback.message, "sup",
"details")
passed, alert = self.assert_params(checked, True)
assert passed, alert
reserve = self.supboard_adapter.get_data_by_keys(4)
await self.processor.callback_details(callback)
del self.reserves[3]
reserve = self.supboard_adapter.get_data_by_keys(4)
passed, alert = self.assert_params(reserve.canceled, True)
assert passed, alert
text = self.create_list_text()
reply_markup = self.create_list_keyboard(True)
self.check_state(state_key, text, reply_markup, "sup", "list")
class StateProviderTestCase(BaseTestCase):
"""StateProvider class"""
state_provider = StateProvider()
@state_provider.message_state()
async def message_default(self, message, state_manager):
self.result_text = "Default message"
@state_provider.message_state(state_type="reserve", state="main")
async def message_reserve_main(self, message, state_manager):
self.result_text = (f"{message.text}: {state_manager.state_type}" +
f" {state_manager.state}")
@state_provider.callback_query_state(state_type="reserve", state="book")
async def callback_query_reserve_book(self, callback_query, state_manager):
self.result_text = (f"Callback: {state_manager.state_type}" +
f" {state_manager.state}")
def setUp(self):
self.data_adapter = MemoryDataAdapter()
self.state_provider.data_adapter = self.data_adapter
self.chat = Chat()
self.chat.id = 101
self.user = User()
self.user.id = 111
state_data1 = {"state": "main", "state_type": "reserve"}
state_data2 = {"state": "book", "state_type": "reserve"}
self.data_adapter.append_data("101-111-121", state_data1)
self.data_adapter.append_data("101-111-122", state_data2)
async def test_message_default(self):
"""Default message state"""
test_message = Message()
test_message.chat = self.chat
test_message.from_user = self.user
test_message.message_id = 123
await self.message_default(test_message)
passed, alert = self.assert_params(self.result_text, "Default message")
assert passed, alert
async def test_message_reserve_main(self):
"""Reserve state main message"""
test_message = Message()
test_message.chat = self.chat
test_message.from_user = self.user
test_message.message_id = 121
test_message.text = "Message-121"
await self.message_reserve_main(test_message)
passed, alert = self.assert_params(self.result_text,
"Message-121: reserve main")
assert passed, alert
async def test_callback_query_reserve_book(self):
"""Reserve state main message"""
test_message = Message()
test_message.chat = self.chat
test_message.from_user = self.user
test_message.message_id = 122
test_callback_query = CallbackQuery()
test_callback_query.message = test_message
await self.callback_query_reserve_book(test_callback_query)
passed, alert = self.assert_params(self.result_text,
"Callback: reserve book")
assert passed, alert
class StateManagerTestCase(BaseTestCase):
"""StateManager class"""
def setUp(self):
self.data_adapter = MemoryDataAdapter()
state_data = {"state": "main", "state_type": "reserve"}
self.data_adapter.append_data("101-111-122", state_data)
self.data_adapter.append_data("101-111-122", state_data)
async def test_create_object(self):
state_mgr = StateManager(self.data_adapter, 101, 111)
passed, alert = self.assert_params(state_mgr.data_adapter,
self.data_adapter)
assert passed, alert
passed, alert = self.assert_params(state_mgr.state_id, "101-111")
assert passed, alert
passed, alert = self.assert_params(state_mgr.state_type, "")
assert passed, alert
passed, alert = self.assert_params(state_mgr.state, "")
assert passed, alert
async def test_create_object_with_message(self):
state_mgr = StateManager(self.data_adapter, 101, 111, 121)
passed, alert = self.assert_params(state_mgr.state_id, "101-111-121")
assert passed, alert
passed, alert = self.assert_params(state_mgr.state_type, "")
assert passed, alert
passed, alert = self.assert_params(state_mgr.state, "")
assert passed, alert
async def test_create_object_with_storied(self):
state_mgr = StateManager(self.data_adapter, 101, 111, 122)
passed, alert = self.assert_params(state_mgr.state_id, "101-111-122")
assert passed, alert
passed, alert = self.assert_params(state_mgr.state_type, "reserve")
assert passed, alert
passed, alert = self.assert_params(state_mgr.state, "main")
assert passed, alert
async def test_change_state(self):
state_mgr = StateManager(self.data_adapter, 101, 111, 122)
state_mgr.set_state("book")
passed, alert = self.assert_params(state_mgr.state_id, "101-111-122")
assert passed, alert
passed, alert = self.assert_params(state_mgr.state_type, "reserve")
assert passed, alert
passed, alert = self.assert_params(state_mgr.state, "book")
assert passed, alert
async def test_change_state_type(self):
state_mgr = StateManager(self.data_adapter, 101, 111, 122)
state_mgr.set_state(state_type="reserve1")
passed, alert = self.assert_params(state_mgr.state_id, "101-111-122")
assert passed, alert
passed, alert = self.assert_params(state_mgr.state_type, "reserve1")
assert passed, alert
passed, alert = self.assert_params(state_mgr.state, "main")
assert passed, alert
async def test_set_state(self):
state_mgr = StateManager(self.data_adapter, 101, 111)
state_mgr.set_state("book2", "reserve2", 122)
state_data = self.data_adapter.get_data_by_keys("101-111-122")
passed, alert = self.assert_params(state_data["state_type"],
"reserve2")
assert passed, alert
passed, alert = self.assert_params(state_data["state"], "book2")
assert passed, alert
def setUp(self):
self.data_adapter = MemoryDataAdapter()
state_data = {"state": "main", "state_type": "reserve"}
self.data_adapter.append_data("101-111-122", state_data)
self.data_adapter.append_data("101-111-122", state_data)
class ReserveProcessorTestCase(BaseTestCase):
"ReserveProcessor class"
def setUp(self):
self.reserves = []
self.strings = RuReserve
self.chat = Chat()
self.chat.id = 101
self.user = User()
self.user.first_name = "Firstname"
self.user.id = 111
dp = Dispatcher()
self.data_adapter = MemoryDataAdapter()
self.state_manager = StateManager(self.data_adapter)
self.processor = ReserveProcessor(dp, self.state_manager, self.strings)
message = Message()
message.chat = self.chat
message.from_user = self.user
message.message_id = 121
message.text = "Some text"
message.answer = self.answer_mock
message.delete = self.delete_mock
message.edit_text = self.edit_text_mock
self.test_message = message
callback = CallbackQuery()
callback.bot = Bot()
callback.answer = self.callback_answer_mock
callback.message = message
callback.from_user = User()
callback.from_user.id = 101
self.test_callback_query = callback
async def answer_mock(self, text, parse_mode=None, reply_markup=None):
self.message = Message()
self.message.text = text
self.message.reply_markup = reply_markup
answer = Message()
answer.message_id = 1001
answer.from_user = self.user
answer.chat = self.chat
return answer
async def delete_mock(self):
pass
async def callback_answer_mock(self, text):
self.callback_answer_text = text
async def edit_text_mock(self, text, parse_mode=None, reply_markup=None):
await self.answer_mock(text, parse_mode, reply_markup)
def append_state(self, key, state_type="*", state="*"):
state_data = {}
state_data["state_type"] = state_type
state_data["state"] = state
self.data_adapter.append_data(key, state_data)
def create_main_text(self):
return "Hello message!"
def create_book_text(self, show_contact=False):
reserve = self.state_manager.data
result = ""
if reserve.user:
result += f"{self.strings.name_label} {reserve.user.displayname}\n"
if show_contact and reserve.user.phone_number:
result += (f"{self.strings.phone_label} "
f"{reserve.user.phone_number}\n")
result += (f"{self.strings.date_label} "
f"{reserve.start_date.strftime(self.strings.date_format)}"
"\n")
if reserve.start_time:
start_time = reserve.start_time.strftime(self.strings.time_format)
result += (f"{self.strings.start_label} " f"{start_time}\n")
end_time = reserve.end_time.strftime(self.strings.time_format)
result += (f"{self.strings.end_label} " f"{end_time}\n")
result += (f"{self.strings.set_type_label} "
f"{self.strings.set_types[reserve.set_type.set_id]}"
f" ({reserve.set_count})\n")
result += (f"{self.strings.count_label} " f"{reserve.count}\n")
return result
def create_list_text(self):
if not self.reserves:
return self.strings.list_empty
result = f"{self.strings.list_header}\n"
cur_date = None
for i in range(2, 8):
reserve = self.reserves[i]
if not cur_date or cur_date != reserve.start_date:
cur_date = reserve.start_date
result += f"*{cur_date.strftime(self.strings.date_format)}*\n"
start_time = reserve.start_time.strftime(self.strings.time_format)
end_time = reserve.end_time.strftime(self.strings.time_format)
result += f" {i - 1}. {start_time} - {end_time}"
result += (f" {self.strings.wake.icon_board}x{reserve.board}"
if reserve.board else "")
result += (f" {self.strings.wake.icon_hydro}x{reserve.hydro}"
if reserve.hydro else "")
result += "\n"
return result
def create_phone_text(self):
return f"{self.create_book_text()}\n{self.strings.phone_message}"
def create_main_keyboard(self):
"""Create Main menu InlineKeyboardMarkup"""
result = InlineKeyboardMarkup(row_width=1)
button = InlineKeyboardButton(self.strings.start_book_button,
callback_data='book')
result.add(button)
button = InlineKeyboardButton(self.strings.list_button,
callback_data='list')
result.add(button)
return result
def create_book_keyboard(self):
"""Create book menu InlineKeyboardMarkup"""
result = InlineKeyboardMarkup(row_width=1)
button = InlineKeyboardButton(self.strings.count_button,
callback_data='count')
result.add(button)
# Adding Date- and Time- buttons by a row for each
button = InlineKeyboardButton(self.strings.date_button,
callback_data='date')
result.add(button)
button = InlineKeyboardButton(self.strings.time_button,
callback_data='time')
result.add(button)
button = InlineKeyboardButton(self.strings.phone_button,
callback_data='phone')
result.add(button)
if self.state_manager.data:
reserve: Reserve = self.state_manager.data
if reserve.is_complete:
button = InlineKeyboardButton(self.strings.apply_button,
callback_data='apply')
result.add(button)
# Adding Back-button separately
button = InlineKeyboardButton(self.strings.back_button,
callback_data='back')
result.add(button)
return result
def create_list_keyboard(self, admin_menu=False):
"""Create List menu InlineKeyboardMarkup"""
result = InlineKeyboardMarkup(row_width=5)
if admin_menu:
count = len(self.reserves) if self.reserves else 0
buttons = []
for i in range(count - 2):
buttons.append(
InlineKeyboardButton(str(i + 1),
callback_data=str(
self.reserves[i + 2].id)))
result.add(*buttons)
button = InlineKeyboardButton(self.strings.back_button,
callback_data='back')
result.add(button)
return result
def create_date_keyboard(self):
"""Create Date menu InlineKeyboardMarkup"""
now = date.today()
result = InlineKeyboardMarkup(row_width=3)
buttons = [
InlineKeyboardButton(
(now + timedelta(i)).strftime(self.strings.date_format),
callback_data=str(i)) for i in range(6)
]
result.add(*buttons)
button = InlineKeyboardButton(self.strings.back_button,
callback_data='back')
result.add(button)
return result
def create_hour_keyboard(self, start=9, count=15, row_width=5):
"""Create Hour menu InlineKeyboardMarkup"""
result = InlineKeyboardMarkup(row_width=row_width)
buttons = [
InlineKeyboardButton(
"{:02d}:".format(start + i) if
(start + i) < 24 else "{:02d}:".format(start + i - 24),
callback_data=str(i + self.strings.time_zone))
for i in range(count)
]
result.add(*buttons)
button = InlineKeyboardButton(self.strings.back_button,
callback_data='back')
result.add(button)
return result
def create_minute_keyboard(self, step=5, row_width=6):
"""Create Hour menu InlineKeyboardMarkup"""
result = InlineKeyboardMarkup(row_width=row_width)
buttons = [
InlineKeyboardButton(f"{i}", callback_data=str(i))
for i in range(0, 60, step)
]
result.add(*buttons)
button = InlineKeyboardButton(self.strings.back_button,
callback_data='back')
result.add(button)
return result
def create_count_keyboard(self,
count: int,
start: int = 1,
row_width: int = 6):
"""Create Hour menu InlineKeyboardMarkup"""
result = InlineKeyboardMarkup(row_width=row_width)
buttons = [
InlineKeyboardButton(f"{i}", callback_data=str(i))
for i in range(start, count + 1)
]
result.add(*buttons)
button = InlineKeyboardButton(self.strings.back_button,
callback_data='back')
result.add(button)
return result
def create_details_keyboard(self,
reserve: Reserve) -> InlineKeyboardMarkup:
result = InlineKeyboardMarkup(row_width=1)
buttons = []
buttons.append(
InlineKeyboardButton(self.strings.cancel_button,
callback_data=f"cancel-{reserve.id}"))
buttons.append(
InlineKeyboardButton(self.strings.notify_button,
callback_data=f"notify-{reserve.id}"))
buttons.append(
InlineKeyboardButton(self.strings.back_button,
callback_data="back"))
result.add(*buttons)
return result
async def test_callback_main_book(self):
"""Proceed press Book button in Main menu"""
callback = self.test_callback_query
callback.data = "book"
reply_markup = self.create_book_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "main")
checked = self.processor.check_filter(callback.message, "reserve",
"main")
passed, message = self.assert_params(checked, True)
assert passed, message
await self.processor.callback_main(callback)
text = self.create_book_text()
text += f"\n{self.strings.phone_warning}"
self.check_state(state_key, text, reply_markup, "reserve", "book")
async def test_callback_book_back(self):
"""Proceed press Back button in Book menu"""
callback = self.test_callback_query
callback.data = "back"
reply_markup = self.create_main_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "book")
checked = self.processor.check_filter(callback.message, "reserve",
"book")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_book(callback)
self.check_state(state_key, self.create_main_text(), reply_markup,
"reserve", "main")
async def test_callback_book_date(self):
"""Proceed press Date button in Book menu"""
callback = self.test_callback_query
callback.data = "date"
reply_markup = self.create_date_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "book")
checked = self.processor.check_filter(callback.message, "reserve",
"book")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_book(callback)
self.check_state(state_key, self.create_list_text(), reply_markup,
"reserve", "date")
async def test_callback_date_back(self):
"""Proceed press Back button in Date menu"""
callback = self.test_callback_query
callback.data = "back"
reply_markup = self.create_book_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "date")
checked = self.processor.check_filter(callback.message, "reserve",
"date")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_date(callback)
text = self.create_book_text()
text += f"\n{self.strings.phone_warning}"
self.check_state(state_key, text, reply_markup, "reserve", "book")
async def test_callback_date_date(self):
"""Proceed select date in Date menu"""
callback = self.test_callback_query
callback.data = "1"
reply_markup = self.create_book_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "date")
checked = self.processor.check_filter(callback.message, "reserve",
"date")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_date(callback)
reserve = self.state_manager.data
passed, alert = self.assert_params(date.today() + timedelta(1),
reserve.start_date)
assert passed, alert
text = self.create_book_text()
text += f"\n{self.strings.phone_warning}"
self.check_state(state_key, text, reply_markup, "reserve", "book")
async def test_callback_book_time(self):
"""Proceed press Time button in Book menu"""
callback = self.test_callback_query
callback.data = "time"
reply_markup = self.create_hour_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "book")
checked = self.processor.check_filter(callback.message, "reserve",
"book")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_book(callback)
self.check_state(state_key, self.create_list_text(), reply_markup,
"reserve", "hour")
async def test_callback_book_phone(self):
"""Proceed press Phone button in Book menu"""
callback = self.test_callback_query
callback.data = "phone"
state_key = "101-111-121"
self.append_state(state_key, "reserve", "book")
checked = self.processor.check_filter(callback.message, "reserve",
"book")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_book(callback)
text = self.create_phone_text()
state_key = "101-111"
state_data = self.data_adapter.get_data_by_keys(state_key)
passed, alert = self.assert_params(state_data["state_type"],
self.processor.state_type)
assert passed, alert
passed, alert = self.assert_params(state_data["state"], "phone")
assert passed, alert
passed, alert = self.assert_params(self.processor.dispatcher.bot.text,
text)
assert passed, alert
async def test_callback_hour_back(self):
"""Proceed press Back button in Hour menu"""
callback = self.test_callback_query
callback.data = "back"
reply_markup = self.create_book_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "hour")
checked = self.processor.check_filter(callback.message, "reserve",
"hour")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_hour(callback)
text = self.create_book_text()
text += f"\n{self.strings.phone_warning}"
self.check_state(state_key, text, reply_markup, "reserve", "book")
async def test_callback_minute(self):
"""Proceed select hour in Hour menu"""
callback = self.test_callback_query
callback.data = "18"
reply_markup = self.create_minute_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "hour")
checked = self.processor.check_filter(callback.message, "reserve",
"hour")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_hour(callback)
reserve = self.state_manager.data
passed, alert = self.assert_params(time(hour=18), reserve.start_time)
assert passed, alert
self.check_state(state_key, self.create_list_text(), reply_markup,
"reserve", "minute")
async def test_callback_minute_back(self):
"""Proceed press Back button in Minute menu"""
callback = self.test_callback_query
callback.data = "back"
reply_markup = self.create_hour_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "minute")
checked = self.processor.check_filter(callback.message, "reserve",
"minute")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_minute(callback)
self.check_state(state_key, self.create_list_text(), reply_markup,
"reserve", "hour")
async def test_callback_minute_minute(self):
"""Proceed select minute in Minute menu"""
callback = self.test_callback_query
callback.data = "30"
state_key = "101-111-121"
self.append_state(state_key, "reserve", "minute")
checked = self.processor.check_filter(callback.message, "reserve",
"minute")
passed, alert = self.assert_params(checked, True)
assert passed, alert
reserve = self.state_manager.data
reserve.start_time = time(16, 15)
await self.processor.callback_minute(callback)
passed, alert = self.assert_params(time(hour=16, minute=30),
reserve.start_time)
assert passed, alert
reply_markup = self.create_book_keyboard()
text = self.create_book_text()
text += f"\n{self.strings.phone_warning}"
self.check_state(state_key, text, reply_markup, "reserve", "book")
async def test_callback_book_set(self):
"""Proceed press Set button in Book menu"""
callback = self.test_callback_query
callback.data = "set"
reply_markup = self.create_count_keyboard(6)
state_key = "101-111-121"
self.append_state(state_key, "wake", "book")
checked = self.processor.check_filter(callback.message, "wake", "book")
passed, message = self.assert_params(checked, True)
assert passed, message
await self.processor.callback_book(callback)
self.check_state(state_key, self.create_book_text(), reply_markup,
"wake", "set")
async def test_callback_set_back(self):
"""Proceed press Back button in Set menu"""
callback = self.test_callback_query
callback.data = "back"
reply_markup = self.create_book_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "set")
checked = self.processor.check_filter(callback.message, "reserve",
"set")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_set(callback)
text = self.create_book_text()
text += f"\n{self.strings.phone_warning}"
self.check_state(state_key, text, reply_markup, "reserve", "book")
async def test_callback_set_count(self):
"""Proceed select Count in Set menu"""
callback = self.test_callback_query
callback.data = "3"
reply_markup = self.create_book_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "set")
checked = self.processor.check_filter(callback.message, "reserve",
"set")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_set(callback)
reserve = self.state_manager.data
passed, alert = self.assert_params(3, reserve.set_count)
assert passed, alert
passed, alert = self.assert_params("set", reserve.set_type.set_id)
assert passed, alert
text = self.create_book_text()
text += f"\n{self.strings.phone_warning}"
self.check_state(state_key, text, reply_markup, "reserve", "book")
async def test_callback_book_set_hour(self):
"""Proceed press Set Hour button in Book menu"""
callback = self.test_callback_query
callback.data = "set_hour"
reply_markup = self.create_count_keyboard(6)
state_key = "101-111-121"
self.append_state(state_key, "wake", "book")
checked = self.processor.check_filter(callback.message, "wake", "book")
passed, message = self.assert_params(checked, True)
assert passed, message
await self.processor.callback_book(callback)
self.check_state(state_key, self.create_book_text(), reply_markup,
"wake", "set_hour")
async def test_callback_set_hour_back(self):
"""Proceed press Back button in Set Hour menu"""
callback = self.test_callback_query
callback.data = "back"
reply_markup = self.create_book_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "set_hour")
checked = self.processor.check_filter(callback.message, "reserve",
"set_hour")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_set_hour(callback)
text = self.create_book_text()
text += f"\n{self.strings.phone_warning}"
self.check_state(state_key, text, reply_markup, "reserve", "book")
async def test_callback_set_hour_count(self):
"""Proceed select Count in Set Hour menu"""
callback = self.test_callback_query
callback.data = "2"
reply_markup = self.create_book_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "set_hour")
checked = self.processor.check_filter(callback.message, "reserve",
"set_hour")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_set_hour(callback)
reserve = self.state_manager.data
passed, alert = self.assert_params(2, reserve.set_count)
assert passed, alert
passed, alert = self.assert_params("hour", reserve.set_type.set_id)
assert passed, alert
text = self.create_book_text()
text += f"\n{self.strings.phone_warning}"
self.check_state(state_key, text, reply_markup, "reserve", "book")
async def test_callback_main_list(self):
"""Proceed press List button in Main menu"""
callback = self.test_callback_query
callback.data = "list"
reply_markup = self.create_list_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "main")
self.processor.admin_telegram_ids.append(1234)
checked = self.processor.check_filter(callback.message, "reserve",
"main")
passed, message = self.assert_params(checked, True)
assert passed, message
await self.processor.callback_main(callback)
self.check_state(state_key, self.create_list_text(), reply_markup,
"reserve", "list")
async def test_callback_list_back(self):
"""Proceed press Back button in List menu"""
callback = self.test_callback_query
callback.data = "back"
reply_markup = self.create_main_keyboard()
state_key = "101-111-121"
self.append_state(state_key, "reserve", "list")
checked = self.processor.check_filter(callback.message, "reserve",
"list")
passed, alert = self.assert_params(checked, True)
assert passed, alert
await self.processor.callback_list(callback)
self.check_state(state_key, self.create_main_text(), reply_markup,
"reserve", "main")
def check_state(self,
key,
text,
reply_markup,
state_type=None,
state=None,
data=None):
"""A util method to check current state"""
state_data = self.data_adapter.get_data_by_keys(key)
passed, alert = self.assert_params(self.message.text, text)
assert passed, alert
passed, alert = self.assert_params(self.message.reply_markup,
reply_markup)
assert passed, alert
passed, alert = self.assert_params(state_data["state"], state)
assert passed, alert
if state_type:
passed, alert = self.assert_params(state_data["state_type"],
state_type)
assert passed, alert
if data:
passed, alert = self.assert_params(state_data["data"], data)
assert passed, alert
from wakebot.adapters.data import MemoryDataAdapter
from wakebot.adapters.state import StateManager
from wakebot.adapters.postgres import PostgressWakeAdapter
from wakebot.adapters.postgres import PostgressSupboardAdapter
from wakebot.adapters.postgres import PostgresUserAdapter
from config import DefaultStrings, WakeStrings, SupboardStrings
TOKEN = os.environ["TOKEN"]
DATABASE_URL = os.environ["DATABASE_URL"]
bot = Bot(token=TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
state_manager = StateManager(MemoryDataAdapter())
default_processor = DefaultProcessor(dp, DefaultStrings)
connection = psycopg2.connect(DATABASE_URL)
user_adapter = PostgresUserAdapter(database_url=DATABASE_URL,
table_name="wp38_users")
wake_adapter = PostgressWakeAdapter(database_url=DATABASE_URL,
table_name="wp38_wake")
wake_processor = WakeProcessor(dp,
state_manager=state_manager,
strings=WakeStrings,
data_adapter=wake_adapter,
user_data_adapter=user_adapter)
wake_processor.logger_id = 586350636
def setUp(self):
self.adapter = MemoryDataAdapter()
class MemoryDataAdapterTestCase(BaseTestCase):
"""MemoryDataAdapter class"""
def setUp(self):
self.adapter = MemoryDataAdapter()
async def test_append_data(self):
data = {"attr": "attr_value"}
self.adapter.append_data("test_key", data)
passed, alert = self.assert_params(self.adapter.storage["test_key"],
data)
assert passed, alert
async def test_get_data(self):
data1 = {"data_attr1": "data_value1"}
data2 = {"data_attr2": "data_value2"}
data3 = {"data_attr3": "data_value3"}
data4 = {"data_attr4": "data_value4"}
data5 = {"data_attr5": "data_value5"}
self.adapter.append_data("key1", data1)
self.adapter.append_data("key2", data2)
self.adapter.append_data("key3", data3)
self.adapter.append_data("key4", data4)
self.adapter.append_data("key4", data5)
data_rows = self.adapter.get_data()
passed, alert = self.assert_params(len(data_rows), 4)
assert passed, alert
passed, alert = self.assert_params(data_rows["key1"], data1)
assert passed, alert
passed, alert = self.assert_params(data_rows["key2"], data2)
assert passed, alert
passed, alert = self.assert_params(data_rows["key3"], data3)
assert passed, alert
passed, alert = self.assert_params(data_rows["key4"], data5)
assert passed, alert
async def test_get_data_by_keys(self):
data1 = {"data_attr1": "data_value1"}
data2 = {"data_attr2": "data_value2"}
data3 = {"data_attr3": "data_value3"}
data4 = {"data_attr4": "data_value4"}
data5 = {"data_attr5": "data_value5"}
self.adapter.append_data("key1", data1)
self.adapter.append_data("key2", data2)
self.adapter.append_data("key3", data3)
self.adapter.append_data("key4", data4)
self.adapter.append_data("key4", data5)
passed, alert = self.assert_params(
self.adapter.get_data_by_keys("key1"), data1)
assert passed, alert
passed, alert = self.assert_params(
self.adapter.get_data_by_keys("key2"), data2)
assert passed, alert
passed, alert = self.assert_params(
self.adapter.get_data_by_keys("key3"), data3)
assert passed, alert
passed, alert = self.assert_params(
self.adapter.get_data_by_keys("key4"), data5)
assert passed, alert