def test_process_most_recent_sleep_query_after_midnight(hallo_getter):
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
mood_date = date(2019, 1, 18)
sleep_datetime = datetime.combine(mood_date, time(23, 55, 56))
mood_datetime = datetime.combine(mood_date + timedelta(days=1),
time(0, 3, 2))
msg_id = 41212
mood_data = dict()
spreadsheet = DailysSpreadsheetMock(
test_user, test_chan, saved_data={"mood": {
mood_date: mood_data
}})
# Setup field
times = [DailysMoodField.TIME_SLEEP]
moods = ["Happiness", "Anger", "Tiredness"]
field = DailysMoodField(spreadsheet, times, moods)
# Send sleep message, check response
evt_sleep = EventMessage(test_server, test_chan, test_user,
"sleep").with_raw_data(
RawDataTelegram(
get_telegram_time(sleep_datetime)))
field.passive_trigger(evt_sleep)
notif_dict = spreadsheet.saved_data["mood"][mood_date]
assert DailysMoodField.TIME_SLEEP in notif_dict
assert "message_id" in notif_dict[DailysMoodField.TIME_SLEEP]
notif_dict[DailysMoodField.TIME_SLEEP]["message_id"] = msg_id
spreadsheet.saved_data["mood"][mood_date] = notif_dict
test_server.get_send_data()
# Send message
evt_mood = EventMessage(
test_server, test_chan, test_user,
"413").with_raw_data(RawDataTelegram(get_telegram_time(mood_datetime)))
field.passive_trigger(evt_mood)
# Check mood response is logged
notif_dict = spreadsheet.saved_data["mood"][mood_date]
assert DailysMoodField.TIME_SLEEP in notif_dict
assert "message_id" in notif_dict[DailysMoodField.TIME_SLEEP]
assert notif_dict[DailysMoodField.TIME_SLEEP]["message_id"] == msg_id
assert notif_dict[DailysMoodField.TIME_SLEEP]["Happiness"] == 4
assert notif_dict[DailysMoodField.TIME_SLEEP]["Anger"] == 1
assert notif_dict[DailysMoodField.TIME_SLEEP]["Tiredness"] == 3
# Check response is given
data_wake = test_server.get_send_data(1, test_chan, EventMessage)
assert "added" in data_wake[0].text.lower()
assert DailysMoodField.TIME_SLEEP in data_wake[0].text
assert mood_date.isoformat() in data_wake[0].text
assert "413" in data_wake[0].text
def test_field_classes_added_to_factory(hallo_getter):
"""
Test tht all field classes which are implemented are added to DailysFieldFactory
"""
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
module_obj = importlib.import_module("hallo.modules.dailys")
# Loop through module, searching for DailysField subclasses.
for function_tuple in inspect.getmembers(module_obj, inspect.isclass):
function_class = function_tuple[1]
# Only look at subclasses of DailysField
if not inherits_from(function_class, "DailysField"):
continue
# Only look at implemented classes.
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
# noinspection PyBroadException
try:
function_class.create_from_input(
EventMessage(test_server, test_chan, test_user, "hello"),
spreadsheet,
)
except NotImplementedError:
continue
except Exception:
pass
# Check it's in DailysFieldFactory
assert function_class.__name__ in [
sub_class.__name__ for sub_class in DailysFieldFactory.fields
]
def test_process_no_mood_query(hallo_getter):
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
mood_date = date(2019, 1, 18)
mood_datetime = datetime.combine(mood_date, time(13, 13, 6))
moods = ["Happiness", "Anger", "Tiredness"]
msg_id = 41212
mood_data = dict()
mood_data[DailysMoodField.TIME_WAKE] = dict()
mood_data[DailysMoodField.TIME_WAKE]["message_id"] = msg_id
for mood in moods:
mood_data[DailysMoodField.TIME_WAKE][mood] = 3
spreadsheet = DailysSpreadsheetMock(
test_user, test_chan, saved_data={"mood": {
mood_date: mood_data
}})
# Setup field
times = [DailysMoodField.TIME_WAKE, time(14, 0, 0)]
field = DailysMoodField(spreadsheet, times, moods)
# Send message
evt_mood = EventMessage(
test_server, test_chan, test_user,
"413").with_raw_data(RawDataTelegram(get_telegram_time(mood_datetime)))
field.passive_trigger(evt_mood)
# Check mood response is not logged
notif_dict = spreadsheet.saved_data["mood"][mood_date]
assert DailysMoodField.TIME_WAKE in notif_dict
assert notif_dict[DailysMoodField.TIME_WAKE]["message_id"] == msg_id
assert notif_dict[DailysMoodField.TIME_WAKE]["Happiness"] == 3
assert notif_dict[DailysMoodField.TIME_WAKE]["Anger"] == 3
assert notif_dict[DailysMoodField.TIME_WAKE]["Tiredness"] == 3
assert str(time(14, 0, 0)) not in notif_dict
# Check no response is given
test_server.get_send_data(0)
def test_day_rollover(hallo_getter):
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
# Setup FA key
udp = UserDataParser()
key = FAKeyData(os.getenv("test_cookie_a"), os.getenv("test_cookie_b"))
udp.set_user_data(test_user, key)
# Setup field
field = DailysFAField(spreadsheet)
# Send a new day event
evt = EventDay()
field.passive_trigger(evt)
assert evt.get_send_time().date() not in spreadsheet.saved_data
notif_dict = spreadsheet.saved_data["furaffinity"][
evt.get_send_time().date() - timedelta(1)]
assert "submissions" in notif_dict
assert "comments" in notif_dict
assert "journals" in notif_dict
assert "favourites" in notif_dict
assert "watches" in notif_dict
assert "notes" in notif_dict
assert "watchers_count" in notif_dict
assert "watching_count" in notif_dict
assert len(test_server.send_data) == 1
assert isinstance(test_server.send_data[0], EventMessage)
assert test_server.send_data[0].text == json.dumps(notif_dict)
assert test_server.send_data[0].channel == test_chan
assert test_server.send_data[0].user == test_user
def test_sleep_sleep_wake(self):
sleep_date = date(2018, 12, 23)
# before midnight
sleep = {
"title": "before midnight",
"sleep1": datetime(2018, 12, 23, 22, 44, 13),
"sleep2": datetime(2018, 12, 23, 22, 56, 26),
"wake": datetime(2018, 12, 23, 23, 47, 34),
}
spreadsheet = DailysSpreadsheetMock(self.test_user, self.test_chan)
# Setup field
field = DailysSleepField(spreadsheet)
# Send sleep message with telegram time
date_sleep1 = sleep["sleep1"]
evt_sleep = EventMessage(self.server, self.test_chan, self.test_user,
"sleep").with_raw_data(
RawDataTelegram(
self.get_telegram_time(date_sleep1)))
field.passive_trigger(evt_sleep)
# Check sleep time is logged
notif_dict = spreadsheet.saved_data["sleep"][sleep_date]
assert "sleep_time" in notif_dict
assert notif_dict["sleep_time"] == date_sleep1.isoformat()
# Check response is given
data_sleep = self.server.get_send_data(1, self.test_chan, EventMessage)
assert "goodnight" in data_sleep[0].text.lower()
# Send second sleep message with telegram time
date_sleep2 = sleep["sleep2"]
evt_sleep = EventMessage(self.server, self.test_chan, self.test_user,
"sleep").with_raw_data(
RawDataTelegram(
self.get_telegram_time(date_sleep2)))
field.passive_trigger(evt_sleep)
# Check sleep time is logged
notif_dict = spreadsheet.saved_data["sleep"][sleep_date]
assert "sleep_time" in notif_dict
assert notif_dict["sleep_time"] == date_sleep2.isoformat()
# Check response is given
data_sleep = self.server.get_send_data(1, self.test_chan, EventMessage)
assert "good night again" in data_sleep[0].text.lower()
# Send wake message with telegram time
date_wake = sleep["wake"]
evt_wake = EventMessage(self.server, self.test_chan, self.test_user,
"morning").with_raw_data(
RawDataTelegram(
self.get_telegram_time(date_wake)))
field.passive_trigger(evt_wake)
# Check wake time is logged
notif_dict = spreadsheet.saved_data["sleep"][sleep_date]
assert "sleep_time" in notif_dict
assert "wake_time" in notif_dict
assert notif_dict["sleep_time"] == date_sleep2.isoformat()
assert notif_dict["wake_time"] == date_wake.isoformat()
# Check response is given
data_wake = self.server.get_send_data(1, self.test_chan, EventMessage)
assert "good morning" in data_wake[0].text.lower()
def test_record_dream(hallo_getter):
hallo, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
# Setup field
field = DailysDreamField(spreadsheet)
evt = EventMessage(
test_server,
test_chan,
test_user,
"dream about some thing",
)
# Send a message event
field.passive_trigger(evt)
dream_dict = spreadsheet.saved_data[field.type_name][
evt.get_send_time().date()]
assert "dreams" in dream_dict
assert len(dream_dict["dreams"]) == 1
dream = dream_dict["dreams"][0]
assert "text" in dream
assert dream["text"] == "dream about some thing"
# Check sent data
assert len(test_server.send_data) == 1
assert isinstance(test_server.send_data[0], EventMessage)
assert "Logged dream." in test_server.send_data[0].text
assert "1st of the day" in test_server.send_data[0].text
assert test_server.send_data[0].channel == test_chan
assert test_server.send_data[0].user == test_user
def test_process_sleep_specified(hallo_getter):
hallo, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
mood_date = date(2019, 1, 18)
mood_datetime = datetime.combine(mood_date, time(13, 13, 6))
moods = ["Happiness", "Anger", "Tiredness"]
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
# Setup field
times = [
DailysMoodField.TIME_WAKE,
time(14, 0, 0), DailysMoodField.TIME_SLEEP
]
field = DailysMoodField(spreadsheet, times, moods)
# Send message
evt_mood = EventMessage(test_server, test_chan, test_user,
"HAT sleep 413").with_raw_data(
RawDataTelegram(
get_telegram_time(mood_datetime)))
field.passive_trigger(evt_mood)
# Check mood response is logged
notif_dict = spreadsheet.saved_data["mood"][mood_date]
assert DailysMoodField.TIME_SLEEP in notif_dict
assert "message_id" not in notif_dict[DailysMoodField.TIME_SLEEP]
assert notif_dict[DailysMoodField.TIME_SLEEP]["Happiness"] == 4
assert notif_dict[DailysMoodField.TIME_SLEEP]["Anger"] == 1
assert notif_dict[DailysMoodField.TIME_SLEEP]["Tiredness"] == 3
# Check response is given
data_sleep = test_server.get_send_data(1, test_chan, EventMessage)
assert "added" in data_sleep[0].text.lower()
assert DailysMoodField.TIME_SLEEP in data_sleep[0].text
assert mood_date.isoformat() in data_sleep[0].text
assert "413" in data_sleep[0].text
def test_trigger_time_exactly_once(hallo_getter):
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
mood_date = date(2019, 1, 18)
# Setup
spreadsheet = DailysSpreadsheetMock(test_user,
test_chan,
saved_data={"mood": {}})
# Setup field
times = [
DailysMoodField.TIME_WAKE,
time(14, 0, 0), DailysMoodField.TIME_SLEEP
]
moods = ["Happiness", "Anger", "Tiredness"]
field = DailysMoodField(spreadsheet, times, moods)
# Prepare events
evt1 = EventMinute()
evt1.send_time = datetime(2019, 1, 18, 13, 59, 11)
evt2 = EventMinute()
evt2.send_time = datetime(2019, 1, 18, 14, 0, 11)
evt3 = EventMinute()
evt3.send_time = datetime(2019, 1, 18, 14, 1, 11)
# Send time before trigger time
field.passive_trigger(evt1)
# Check mood data not updated and query not sent
assert mood_date not in spreadsheet.saved_data["mood"]
test_server.get_send_data(0)
# Send time after trigger time
field.passive_trigger(evt2)
# Check mood query is sent
notif_dict = spreadsheet.saved_data["mood"][mood_date]
assert str(time(14, 0, 0)) in notif_dict
assert "message_id" in notif_dict[str(time(14, 0, 0))]
# Check query is given
data_wake = test_server.get_send_data(1, test_chan, EventMessage)
assert "how are you feeling" in data_wake[0].text.lower()
assert str(time(14, 0, 0)) in data_wake[0].text
assert all([mood in data_wake[0].text for mood in moods])
# Set message ID to something
msg_id = "test_message_id"
notif_dict[str(time(14, 0, 0))]["message_id"] = msg_id
spreadsheet.saved_data["mood"][mood_date] = notif_dict
# Send another time after trigger time
field.passive_trigger(evt3)
# Check mood data not updated and query not sent
notif_dict = spreadsheet.saved_data["mood"][mood_date]
assert notif_dict[str(time(14, 0, 0))]["message_id"] == msg_id
test_server.get_send_data(0)
def test_sleep_wake(self):
sleep_date = date(2018, 12, 23)
sleeps = list()
# before midnight
sleeps.append({
"title": "before midnight",
"sleep": datetime(2018, 12, 23, 22, 44, 13),
"wake": datetime(2018, 12, 23, 23, 47, 34),
})
# over midnight
sleeps.append({
"title": "over midnight",
"sleep": datetime(2018, 12, 23, 22, 44, 13),
"wake": datetime(2018, 12, 24, 11, 47, 34),
})
# after midnight
sleeps.append({
"title": "after midnight",
"sleep": datetime(2018, 12, 24, 1, 44, 13),
"wake": datetime(2018, 12, 24, 11, 47, 34),
})
for sleep in sleeps:
with self.subTest(sleep["title"]):
spreadsheet = DailysSpreadsheetMock(self.test_user,
self.test_chan)
# Setup field
field = DailysSleepField(spreadsheet)
# Send sleep message with telegram time
date_sleep = sleep["sleep"]
evt_sleep = EventMessage(
self.server, self.test_chan, self.test_user,
"sleep").with_raw_data(
RawDataTelegram(self.get_telegram_time(date_sleep)))
field.passive_trigger(evt_sleep)
# Check sleep time is logged
notif_dict = spreadsheet.saved_data["sleep"][sleep_date]
assert "sleep_time" in notif_dict
assert notif_dict["sleep_time"] == date_sleep.isoformat()
# Check response is given
data_sleep = self.server.get_send_data(1, self.test_chan,
EventMessage)
assert "goodnight" in data_sleep[0].text.lower()
# Send wake message with telegram time
date_wake = sleep["wake"]
evt_wake = EventMessage(
self.server, self.test_chan, self.test_user,
"morning").with_raw_data(
RawDataTelegram(self.get_telegram_time(date_wake)))
field.passive_trigger(evt_wake)
# Check wake time is logged
notif_dict = spreadsheet.saved_data["sleep"][sleep_date]
assert "sleep_time" in notif_dict
assert "wake_time" in notif_dict
assert notif_dict["sleep_time"] == date_sleep.isoformat()
assert notif_dict["wake_time"] == date_wake.isoformat()
# Check response is given
data_wake = self.server.get_send_data(1, self.test_chan,
EventMessage)
assert "good morning" in data_wake[0].text.lower()
def test_no_trigger_after_processed(hallo_getter):
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
mood_date = date(2019, 1, 18)
mood_datetime = datetime.combine(mood_date, time(13, 13, 6))
moods = ["Happiness", "Anger", "Tiredness"]
msg_id = 41212
mood_data = dict()
mood_data[DailysMoodField.TIME_WAKE] = dict()
mood_data[DailysMoodField.TIME_WAKE]["message_id"] = msg_id
for mood in moods:
mood_data[DailysMoodField.TIME_WAKE][mood] = 3
spreadsheet = DailysSpreadsheetMock(
test_user, test_chan, saved_data={"mood": {
mood_date: mood_data
}})
# Setup field
times = [DailysMoodField.TIME_WAKE, time(14, 0, 0)]
field = DailysMoodField(spreadsheet, times, moods)
# Send message
evt_mood = EventMessage(test_server, test_chan, test_user,
"HAT 1400 413").with_raw_data(
RawDataTelegram(
get_telegram_time(mood_datetime)))
field.passive_trigger(evt_mood)
# Check mood response is logged
notif_dict = spreadsheet.saved_data["mood"][mood_date]
assert DailysMoodField.TIME_WAKE in notif_dict
assert notif_dict[DailysMoodField.TIME_WAKE]["message_id"] == msg_id
assert notif_dict[DailysMoodField.TIME_WAKE]["Happiness"] == 3
assert notif_dict[DailysMoodField.TIME_WAKE]["Anger"] == 3
assert notif_dict[DailysMoodField.TIME_WAKE]["Tiredness"] == 3
assert str(time(14, 0, 0)) in notif_dict
assert "message_id" not in notif_dict[str(time(14, 0, 0))]
assert notif_dict[str(time(14, 0, 0))]["Happiness"] == 4
assert notif_dict[str(time(14, 0, 0))]["Anger"] == 1
assert notif_dict[str(time(14, 0, 0))]["Tiredness"] == 3
# Check response is given
data_1400 = test_server.get_send_data(1, test_chan, EventMessage)
assert "added" in data_1400[0].text.lower()
assert str(time(14, 0, 0)) in data_1400[0].text
assert mood_date.isoformat() in data_1400[0].text
assert "413" in data_1400[0].text
# Check that when the time happens, a query isn't sent
evt_time = EventMinute()
evt_time.send_time = datetime.combine(mood_date, time(14, 3, 10))
field.passive_trigger(evt_time)
# Check data isn't added
notif_dict = spreadsheet.saved_data["mood"][mood_date]
assert str(time(14, 0, 0)) in notif_dict
assert "message_id" not in notif_dict[str(time(14, 0, 0))]
assert notif_dict[str(time(14, 0, 0))]["Happiness"] == 4
assert notif_dict[str(time(14, 0, 0))]["Anger"] == 1
assert notif_dict[str(time(14, 0, 0))]["Tiredness"] == 3
# Check query isn't sent
test_server.get_send_data(0)
def test_trigger_sleep_no_query_if_already_given(hallo_getter):
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
moods = ["Happiness", "Anger", "Tiredness"]
evt_sleep1 = EventMessage(test_server, test_chan, test_user, "night")
saved_data = dict()
saved_data[DailysMoodField.TIME_WAKE] = dict()
saved_data[DailysMoodField.TIME_WAKE]["message_id"] = 1232
saved_data[str(time(14, 0, 0))] = dict()
saved_data[str(time(14, 0, 0))]["message_id"] = 1234
for mood in moods:
saved_data[DailysMoodField.TIME_WAKE][mood] = 3
saved_data[str(time(14, 0, 0))][mood] = 2
spreadsheet = DailysSpreadsheetMock(
test_user,
test_chan,
saved_data={"mood": {
evt_sleep1.get_send_time().date(): saved_data
}},
)
# Setup field
times = [
DailysMoodField.TIME_WAKE,
time(14, 0, 0), DailysMoodField.TIME_SLEEP
]
field = DailysMoodField(spreadsheet, times, moods)
# Send message
evt_sleep1 = EventMessage(test_server, test_chan, test_user, "night")
field.passive_trigger(evt_sleep1)
# Check mood query is sent
notif_dict = spreadsheet.saved_data["mood"][
evt_sleep1.get_send_time().date()]
assert DailysMoodField.TIME_SLEEP in notif_dict
assert "message_id" in notif_dict[DailysMoodField.TIME_SLEEP]
# Check query is given
data_wake = test_server.get_send_data(1, test_chan, EventMessage)
assert "how are you feeling" in data_wake[0].text.lower()
assert DailysMoodField.TIME_SLEEP in data_wake[0].text
assert all([mood in data_wake[0].text for mood in moods])
# Set message ID to something
msg_id = "test_message_id"
notif_dict[DailysMoodField.TIME_SLEEP]["message_id"] = msg_id
spreadsheet.saved_data["mood"][
evt_sleep1.get_send_time().date()] = notif_dict
# Send second sleep query
evt_sleep2 = EventMessage(test_server, test_chan, test_user, "night")
field.passive_trigger(evt_sleep2)
# Check no mood query is sent
notif_dict = spreadsheet.saved_data["mood"][
evt_sleep1.get_send_time().date()]
assert notif_dict[DailysMoodField.TIME_SLEEP]["message_id"] == msg_id
test_server.get_send_data(0)
def test_day_rollover_no_data(hallo_getter):
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
# Setup field
field = DailysFAField(spreadsheet)
# Send a new day event
try:
field.passive_trigger(EventDay())
assert False, "Should have failed to check FA data."
except hallo.modules.dailys.dailys_field.DailysException as e:
assert ("no fa data"
in str(e).lower()), "Exception should say there's no FA data."
def test_create_from_input_col_specified(self):
# Setup
cmd_name = "setup dailys field"
cmd_args = "sleep"
evt = EventMessage(
self.server,
self.test_chan,
self.test_user,
"{} {}".format(cmd_name, cmd_args),
)
evt.split_command_text(cmd_name, cmd_args)
spreadsheet = DailysSpreadsheetMock(self.test_user, self.test_chan)
# Create from input
field = DailysSleepField.create_from_input(evt, spreadsheet)
assert field.spreadsheet == spreadsheet
def test_sleep_after_5(self):
spreadsheet = DailysSpreadsheetMock(self.test_user, self.test_chan)
# Setup field
field = DailysSleepField(spreadsheet)
# Send sleep message with telegram time
sleep_time = datetime(2018, 12, 23, 23, 44, 13)
evt = EventMessage(self.server, self.test_chan, self.test_user,
"sleep").with_raw_data(
RawDataTelegram(
self.get_telegram_time(sleep_time)))
field.passive_trigger(evt)
# Check data is saved to today
notif_dict = spreadsheet.saved_data["sleep"][sleep_time.date()]
assert "sleep_time" in notif_dict
assert notif_dict["sleep_time"] == sleep_time.isoformat()
def test_now_time(self):
spreadsheet = DailysSpreadsheetMock(self.test_user, self.test_chan)
# Setup field
field = DailysSleepField(spreadsheet)
# Send sleep message with telegram time
evt = EventMessage(self.server, self.test_chan, self.test_user,
"sleep")
now = datetime.now()
today_date = now.date()
yesterday_date = today_date - timedelta(1)
field.passive_trigger(evt)
# Check data is saved
notif_dict = spreadsheet.saved_data["sleep"][
yesterday_date if now.hour <= 16 else today_date]
assert "sleep_time" in notif_dict
logged_time = dateutil.parser.parse(notif_dict["sleep_time"])
assert logged_time - now < timedelta(0, 10)
def test_trigger_sleep_no_query_if_not_in_times(hallo_getter):
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
spreadsheet = DailysSpreadsheetMock(test_user,
test_chan,
saved_data={"mood": {}})
# Setup field
times = [DailysMoodField.TIME_WAKE, time(14, 0, 0)]
moods = ["Happiness", "Anger", "Tiredness"]
field = DailysMoodField(spreadsheet, times, moods)
# Send message
evt_sleep = EventMessage(test_server, test_chan, test_user, "night")
field.passive_trigger(evt_sleep)
# Check mood query is not sent or added to saved data
assert evt_sleep.get_send_time().date(
) not in spreadsheet.saved_data["mood"]
test_server.get_send_data(0)
def test_create_from_input_password_first(self):
# Setup
cmd_name = "setup dailys field"
cmd_args = "duolingo {} {}".format(self.TEST_PASSWORD,
self.TEST_USERNAME)
evt = EventMessage(
self.server,
self.test_chan,
self.test_user,
"{} {}".format(cmd_name, cmd_args),
)
evt.split_command_text(cmd_name, cmd_args)
spreadsheet = DailysSpreadsheetMock(self.test_user, self.test_chan)
# Create from input
field = DailysDuolingoField.create_from_input(evt, spreadsheet)
assert field.spreadsheet == spreadsheet
assert field.username == self.TEST_USERNAME
assert field.password == self.TEST_PASSWORD
def get_field_objects(test_user, test_chan):
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
field_obs = list()
field_obs.append(
DailysDuolingoField(spreadsheet, "cabinet",
os.getenv("test_duo_password")))
field_obs.append(
DailysMoodField(
spreadsheet,
[DailysMoodField.TIME_SLEEP,
time(14, 00),
time(22, 00)],
["Happiness", "Anger", "Sleepiness"],
))
field_obs.append(DailysFAField(spreadsheet))
field_obs.append(DailysSleepField(spreadsheet))
field_obs.append(DailysDreamField(spreadsheet))
return field_obs
def test_telegram_time(self):
spreadsheet = DailysSpreadsheetMock(self.test_user, self.test_chan)
# Setup field
field = DailysSleepField(spreadsheet)
# Send sleep message with telegram time
msg_date = datetime(2018, 12, 23, 23, 44, 13)
today = msg_date.date()
yesterday = today - timedelta(1)
evt = EventMessage(self.server, self.test_chan, self.test_user,
"sleep").with_raw_data(
RawDataTelegram(
self.get_telegram_time(msg_date)))
field.passive_trigger(evt)
# Check data is saved
notif_dict = spreadsheet.saved_data["sleep"][yesterday if msg_date.
hour <= 16 else today]
assert "sleep_time" in notif_dict
assert notif_dict["sleep_time"] == msg_date.isoformat()
def test_record_second_dream(hallo_getter):
hallo, test_server, test_chan, test_user = hallo_getter({"dailys"})
evt = EventMessage(
test_server,
test_chan,
test_user,
"Dream about some second thing",
)
previous_dream = {"text": "Dreamt the first time"}
saved_data = {
"dreams": {
evt.get_send_time().date(): {
"dreams": [previous_dream]
}
}
}
spreadsheet = DailysSpreadsheetMock(test_user,
test_chan,
saved_data=saved_data)
# Setup field
field = DailysDreamField(spreadsheet)
# Send a message event
field.passive_trigger(evt)
# Check data is added
dream_dict = spreadsheet.saved_data[field.type_name][
evt.get_send_time().date()]
assert "dreams" in dream_dict
assert len(dream_dict["dreams"]) == 2
dream1 = dream_dict["dreams"][0]
assert "text" in dream1
assert dream1["text"] == "Dreamt the first time"
dream2 = dream_dict["dreams"][1]
assert "text" in dream2
assert dream2["text"] == "Dream about some second thing"
# Check sent data
assert len(test_server.send_data) == 1
assert isinstance(test_server.send_data[0], EventMessage)
assert "Logged dream." in test_server.send_data[0].text
assert "2nd of the day" in test_server.send_data[0].text
assert test_server.send_data[0].channel == test_chan
assert test_server.send_data[0].user == test_user
def test_create_from_input(hallo_getter):
hallo, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
cmd_name = "setup dailys field"
cmd_args = "dream"
evt = EventMessage(
test_server,
test_chan,
test_user,
"{} {}".format(cmd_name, cmd_args),
)
evt.split_command_text(cmd_name, cmd_args)
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
# Create from input
field = DailysDreamField.create_from_input(evt, spreadsheet)
assert field.spreadsheet == spreadsheet
assert field.type_name == "dreams"
def test_no_trigger_wake_after_processed(hallo_getter):
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
mood_date = date(2019, 1, 18)
mood_datetime = datetime.combine(mood_date, time(13, 13, 6))
wake_datetime = datetime.combine(mood_date, time(13, 15, 7))
moods = ["Happiness", "Anger", "Tiredness"]
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
# Setup field
times = [DailysMoodField.TIME_WAKE, time(14, 0, 0)]
field = DailysMoodField(spreadsheet, times, moods)
# Send message
evt_mood = EventMessage(test_server, test_chan, test_user,
"HAT wake 413").with_raw_data(
RawDataTelegram(
get_telegram_time(mood_datetime)))
field.passive_trigger(evt_mood)
# Check mood response is logged
notif_dict = spreadsheet.saved_data["mood"][mood_date]
assert DailysMoodField.TIME_WAKE in notif_dict
assert "message_id" not in notif_dict[DailysMoodField.TIME_WAKE]
assert notif_dict[DailysMoodField.TIME_WAKE]["Happiness"] == 4
assert notif_dict[DailysMoodField.TIME_WAKE]["Anger"] == 1
assert notif_dict[DailysMoodField.TIME_WAKE]["Tiredness"] == 3
# Check response is given
data_wake = test_server.get_send_data(1, test_chan, EventMessage)
assert "added" in data_wake[0].text.lower()
assert DailysMoodField.TIME_WAKE in data_wake[0].text
assert mood_date.isoformat() in data_wake[0].text
assert "413" in data_wake[0].text
# Send wake message, ensure no response
evt_wake = EventMessage(test_server, test_chan, test_user,
"morning").with_raw_data(
RawDataTelegram(
get_telegram_time(wake_datetime)))
field.passive_trigger(evt_wake)
# Check query isn't logged
notif_dict = spreadsheet.saved_data["mood"][mood_date]
assert DailysMoodField.TIME_WAKE in notif_dict
assert "message_id" not in notif_dict[DailysMoodField.TIME_WAKE]
# Check response wasn't given
test_server.get_send_data(0)
def test_ignore_other(hallo_getter):
hallo, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
# Setup field
field = DailysDreamField(spreadsheet)
evt = EventMessage(
test_server,
test_chan,
test_user,
"some other message",
)
# Send a message event
field.passive_trigger(evt)
assert field.type_name not in spreadsheet.saved_data
# Check sent data
assert len(test_server.send_data) == 0
def test_create_from_input(hallo_getter):
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
cmd_name = "setup dailys field"
cmd_args = "furaffinity"
evt = EventMessage(
test_server,
test_chan,
test_user,
"{} {}".format(cmd_name, cmd_args),
)
evt.split_command_text(cmd_name, cmd_args)
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
# Setup an FA key, doesn't matter if it works
udp = UserDataParser()
key = FAKeyData("cookie_a", "cookie_b")
udp.set_user_data(test_user, key)
# Create from input
field = DailysFAField.create_from_input(evt, spreadsheet)
assert field.spreadsheet == spreadsheet
def test_trigger_morning_query(hallo_getter):
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
# Setup field
times = [DailysMoodField.TIME_WAKE, time(14, 0, 0)]
moods = ["Happiness", "Anger", "Tiredness"]
field = DailysMoodField(spreadsheet, times, moods)
# Send message
evt_wake = EventMessage(test_server, test_chan, test_user, "morning")
field.passive_trigger(evt_wake)
# Check mood query is sent
notif_dict = spreadsheet.saved_data["mood"][
evt_wake.get_send_time().date()]
assert DailysMoodField.TIME_WAKE in notif_dict
assert "message_id" in notif_dict[DailysMoodField.TIME_WAKE]
# Check query is given
data_wake = test_server.get_send_data(1, test_chan, EventMessage)
assert "how are you feeling" in data_wake[0].text.lower()
assert DailysMoodField.TIME_WAKE in data_wake[0].text
assert all([mood in data_wake[0].text for mood in moods])
def test_create_from_input__no_static_data(hallo_getter, requests_mock):
# Setup stuff
command_name = "setup dailys field"
command_args = "mood"
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
evt = EventMessage(
test_server,
test_chan,
test_user,
"{} {}".format(command_name, command_args),
)
evt.split_command_text(command_name, command_args)
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
requests_mock.get("{}/stats/mood/static/".format(spreadsheet.dailys_url),
json=[])
# Try and create dailys field
with pytest.raises(hallo.modules.dailys.dailys_field.DailysException) as e:
DailysMoodField.create_from_input(evt, spreadsheet)
assert "mood field static data has not been set up on dailys system" in str(
e.value).lower()
def test_create_from_input_no_fa_data(hallo_getter):
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
# Setup
cmd_name = "setup dailys field"
cmd_args = "furaffinity"
evt = EventMessage(
test_server,
test_chan,
test_user,
"{} {}".format(cmd_name, cmd_args),
)
evt.split_command_text(cmd_name, cmd_args)
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
# Create from input
try:
DailysFAField.create_from_input(evt, spreadsheet)
assert (
False
), "Should have failed to create DailysFAField due to missing FA login info."
except hallo.modules.dailys.dailys_field.DailysException as e:
assert ("no fa data" in str(e).lower(
)), "Exception did not mention that there was no FA data set up."
def test_create_from_input(hallo_getter, requests_mock):
dailys_times = ["WakeUpTime", "12:00:00", "SleepTime"]
dailys_moods = ["happiness", "anger", "tiredness", "boisterousness"]
# Setup stuff
command_name = "setup dailys field"
command_args = "mood"
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
evt = EventMessage(
test_server,
test_chan,
test_user,
"{} {}".format(command_name, command_args),
)
evt.split_command_text(command_name, command_args)
spreadsheet = DailysSpreadsheetMock(test_user, test_chan)
requests_mock.get("{}/stats/mood/static/".format(spreadsheet.dailys_url),
json=[{
"date": "static",
"source": "Mock test data",
"stat_name": "mood",
"data": {
"moods": dailys_moods,
"times": dailys_times
}
}])
# Try and create dailys field
field = DailysMoodField.create_from_input(evt, spreadsheet)
assert field.spreadsheet == spreadsheet
assert isinstance(field.times, list)
assert len(field.times) == 3
assert DailysMoodField.TIME_WAKE in field.times
assert DailysMoodField.TIME_SLEEP in field.times
assert time(12, 0, 0) in field.times
assert isinstance(field.moods, list)
assert len(field.moods) == 4
assert field.moods == dailys_moods
def test_trigger_sleep_after_midnight(hallo_getter):
hallo_obj, test_server, test_chan, test_user = hallo_getter({"dailys"})
mood_date = date(2019, 1, 15)
sleep_time = datetime(2019, 1, 16, 0, 34, 15)
times = [
DailysMoodField.TIME_WAKE,
time(14, 0, 0), DailysMoodField.TIME_SLEEP
]
moods = ["Happiness", "Anger", "Tiredness"]
# Setup
saved_data = dict()
saved_data[DailysMoodField.TIME_WAKE] = dict()
saved_data[DailysMoodField.TIME_WAKE]["message_id"] = 1232
saved_data[str(time(14, 0, 0))] = dict()
saved_data[str(time(14, 0, 0))]["message_id"] = 1234
for mood in moods:
saved_data[DailysMoodField.TIME_WAKE][mood] = 3
saved_data[str(time(14, 0, 0))][mood] = 2
spreadsheet = DailysSpreadsheetMock(
test_user, test_chan, saved_data={"mood": {
mood_date: saved_data
}})
# Setup field
field = DailysMoodField(spreadsheet, times, moods)
# Send message
evt_sleep = EventMessage(
test_server, test_chan, test_user,
"night").with_raw_data(RawDataTelegram(get_telegram_time(sleep_time)))
field.passive_trigger(evt_sleep)
# Check mood query is sent for previous day
notif_dict = spreadsheet.saved_data["mood"][mood_date]
assert DailysMoodField.TIME_SLEEP in notif_dict
assert "message_id" in notif_dict[DailysMoodField.TIME_SLEEP]
# Check query is given
data_wake = test_server.get_send_data(1, test_chan, EventMessage)
assert "how are you feeling" in data_wake[0].text.lower()
assert DailysMoodField.TIME_SLEEP in data_wake[0].text
assert all([mood in data_wake[0].text for mood in moods])
def test_create_from_input_no_password(self):
# Setup
cmd_name = "setup dailys field"
cmd_args = "duolingo {}".format(self.TEST_USERNAME)
evt = EventMessage(
self.server,
self.test_chan,
self.test_user,
"{} {}".format(cmd_name, cmd_args),
)
evt.split_command_text(cmd_name, cmd_args)
spreadsheet = DailysSpreadsheetMock(self.test_user, self.test_chan)
# Create from input
try:
DailysDuolingoField.create_from_input(evt, spreadsheet)
assert (
False
), "Should have failed to create DailysDuolingoField due to missing password."
except DailysException as e:
assert (
"you must specify both a duolingo username, and password"
in str(e).lower()
), "Exception did not prompt to specify a username and password."
