def test_get_week_post_does_not_save_event_ending_on_the_next_day(
self, default_user
):
self.__insert_week()
wrong_end_event = {
"event-id": -1,
"title": "test_title",
"description": "test_description",
"location": "test_location",
"start_date": "2020-10-20",
"start_time": "02:00:00",
"end_date": "2020-10-21",
"end_time": "01:00:00",
"business_hour": 1,
"action": "Save",
"guest-name": "",
}
r = self.client.post(f"/{YEAR}/{WEEK}", data=wrong_end_event)
template, context = self.rendered_templates[0]
AssertThat(template.name).IsEqualTo("event.html")
AssertThat(r.data).Contains(b"Event ends on a different day!")
def test_create_app_sets_current_year(self):
app = create_app()
AssertThat(app.jinja_env.globals["current_year"]).IsEqualTo(
datetime.now().isocalendar()[0])
AssertThat(app.jinja_env.globals["current_week"]).IsEqualTo(
datetime.now().isocalendar()[1])
def test_brk_will_push_pc_and_ps_onto_the_stack(cpu):
"""BRKWillPushPCandPSOntoTheStack"""
cpu.reset_to(0xFF00)
cpu.Memory[0xFF00] = OpCodes.INS_BRK
expected_cycles = 7
cpu_copy = copy.copy(cpu)
old_sp = cpu_copy.stack_pointer
# When:
cycles_used = cpu.execute(expected_cycles)
# Then:
AssertThat(expected_cycles).IsEqualTo(cycles_used)
AssertThat(cpu.Memory[(0x100 | old_sp) - 0]).IsEqualTo(0xFF)
"""https://www.c64-wiki.com/wiki/BRK
Note that since BRK increments the program counter by
2 instead of 1, it is advisable to use a NOP after it
to avoid issues"""
AssertThat(cpu.Memory[(0x100 | old_sp) - 1]).IsEqualTo(0x02)
AssertThat(cpu.Memory[(0x100 | old_sp) - 2]).IsEqualTo(
cpu_copy.processor_status | ProcessorStatus.UnusedFlagBit | ProcessorStatus.BreakFlagBit
)
"""https://wiki.nesdev.com/w/index.php/Status_flags
Instruction |Bits 5 and 4 | Side effects after pushing
BRK | 11 | I is set to 1 """
AssertThat(cpu.Flag.I).IsTruthy()
async def test_get_playlist_info(response_get_mock: MagicMock, ) -> None:
"""Test get playlist info if everything is fine."""
playlist_id: str = "test"
expected_tracks: List[Dict[str, Any]] = [{"name": "test"}]
expected_playlist: Dict[str, Any] = {
"url": "test_url",
"name": "test",
"spotify_id": playlist_id,
}
response_data: Dict[str, Any] = {
"external_urls": {
"spotify": expected_playlist["url"]
},
"name": expected_playlist["name"],
"tracks": {
"items": expected_tracks
},
}
response_get_mock.return_value = get_response_mock(
method="POST",
response_data=response_data,
valid=True,
)
playlist_info, tracks = await get_playlist_info(playlist_id=playlist_id,
access_token="test")
AssertThat(playlist_info).IsEqualTo(expected_playlist)
AssertThat(tracks).IsEqualTo(expected_tracks)
def test_event_does_not_render_guest_registration(self, default_user):
week = Week(year=2020, week_num=2)
db.session.add(week)
event = Event(
event_type=1,
title="test_event",
start="2020-01-06 00:00:00",
end="2020-01-06 01:00:00",
week_id=week.id,
user_id=default_user.id,
)
db.session.add(event)
db.session.commit()
r = self.client.post(
"/event",
data={
"year": "2020",
"week": "2",
"hour": "0",
"day": "0"
},
)
template, context = self.rendered_templates[0]
AssertThat(r.data).Contains(b'checked id="businesshour"')
AssertThat(r.data).Contains(b'placeholder="Guest name here"')
def test_get_share_link_creates_shareable_link_correctly(
self, default_user
):
r = self.client.get(
"/get-share-link",
query_string={
"expiration": (datetime.now() + timedelta(days=7)).strftime(
"%Y-%m-%d"
),
"share-content": "true",
},
)
now = datetime.now().isocalendar()
token = re.search(
f"{current_app.config['CALENDAR_URL']}/{now[0]}/{now[1]}/shared-calendar/(.*)",
r.json["token"],
).group(1)
decoded_token = UserAccess(
current_app.config["SHARING_TOKEN_SECRET"]
).decode(token)
AssertThat(decoded_token["user_id"]).IsEqualTo(default_user.id)
AssertThat(decoded_token["share_content"]).IsTrue()
def test_share_renders_template(self, default_user):
r = self.client.get("/share")
template, context = self.rendered_templates[0]
AssertThat(r.status_code).IsEqualTo(200)
AssertThat(template.name).IsEqualTo("share.html")
def test_get_week_event_insertion_handles_wrongly_formatted_time(
self, default_user
):
self.__insert_week()
wrong_time_event = {
"event-id": -1,
"title": "test_title",
"description": "test_description",
"location": "test_location",
"start_date": "2020-10-20",
"start_time": "02:00",
"end_date": "2020-10-20",
"end_time": "03:00",
"business_hour": 1,
"action": "Save",
"guest-name": "",
}
r = self.client.post(f"/{YEAR}/{WEEK}", data=wrong_time_event)
template, context = self.rendered_templates[0]
AssertThat(template.name).IsEqualTo("week.html")
AssertThat(r.data).Contains(wrong_time_event["title"].encode())
async def test_base_auth_route_on_post_user_created(
set_mock: MagicMock,
user_fixture: User,
) -> None:
"""
Check auth handler when AuthAccount is not exists, but User exists and logged in,
AuthAccount should be created and added for user,
tokens should be returned.
"""
set_mock.return_value = asyncio.Future()
set_mock.return_value.set_result(True)
route = get_patched_route()
route_handler = route.get_route_handler()
request: Request = await get_auth_request(method="POST",
user_id=str(user_fixture.id))
response: ORJSONResponse = await route_handler(request)
response_body = loads(response.body)
auth_account: AuthAccount = await AuthAccount.get(_id=AUTH_ACCOUNT_ID,
user=user_fixture)
user: User = await User.get(auth_accounts__in=[auth_account])
AssertThat(AuthOut(**response_body).validate(response_body)).IsNotEmpty()
AssertThat(auth_account).IsNotNone()
AssertThat(user).IsNotNone()
def test_event_does_not_render_events_of_other_users(self, default_user):
user2 = User(username="******", password="******")
db.session.add(user2)
event = Event(
event_type=1,
title="<title>",
description="<desc>",
location="<loc>",
start="2020-10-20 00:00:00",
end="2020-10-20 01:00:00",
user_id=user2.id,
)
db.session.add(event)
db.session.commit()
r = self.client.post(
"/event",
data={
"year": "2020",
"week": "43",
"hour": "0",
"day": "1"
},
)
AssertThat(r.status_code).IsEqualTo(200)
template, context = self.rendered_templates[0]
AssertThat(context["event"]).IsEqualTo(None)
def test_get_week_post_does_not_save_event_shorter_than_one_hour(
self, default_user
):
self.__insert_week()
short_event = {
"event-id": -1,
"title": "test_title",
"description": "test_description",
"location": "test_location",
"start_date": "2020-10-20",
"start_time": "02:00:00",
"end_date": "2020-10-20",
"end_time": "02:59:00",
"business_hour": 1,
"action": "Save",
"guest-name": "",
}
r = self.client.post(f"/{YEAR}/{WEEK}", data=short_event)
template, context = self.rendered_templates[0]
AssertThat(template.name).IsEqualTo("event.html")
AssertThat(r.data).Contains(b"Event cannot be shorter, than 1 hour!")
def test_get_week_post_does_not_save_overlapping_event(
self, start_time, end_time, default_user
):
week = self.__insert_week()
self.__insert_event(default_user.id, week.id)
overlapping_event = {
"event-id": -1,
"title": "test_title",
"description": "test_description",
"location": "test_location",
"start_date": "2020-10-20",
"start_time": start_time,
"end_date": "2020-10-20",
"end_time": end_time,
"business_hour": 1,
"action": "Save",
"guest-name": "",
}
r = self.client.post(f"/{YEAR}/{WEEK}", data=overlapping_event)
template, context = self.rendered_templates[0]
AssertThat(template.name).IsEqualTo("event.html")
AssertThat(r.data).Contains(b"Overlapping event!")
def test_get_week_post_does_not_save_events_with_equal_end_and_start(
self, default_user
):
self.__insert_week()
wrong_end_event = {
"event-id": -1,
"title": "test_title",
"description": "test_description",
"location": "test_location",
"start_date": "2020-10-20",
"start_time": "02:00:00",
"end_date": "2020-10-20",
"end_time": "02:00:00",
"business_hour": 1,
"action": "Save",
"guest-name": "",
}
r = self.client.post(f"/{YEAR}/{WEEK}", data=wrong_end_event)
template, context = self.rendered_templates[0]
AssertThat(template.name).IsEqualTo("event.html")
AssertThat(r.data).Contains(
b"End of event cannot be earlier than (or equal to) its start!"
)
def test_get_week_post_saves_event_to_db(self, default_user):
self.__insert_week()
r = self.client.post(f"/{YEAR}/{WEEK}", data=TEST_EVENT)
AssertThat(r.status_code).IsEqualTo(200)
event = Event.query.filter_by(title=TEST_EVENT["title"]).first()
AssertThat(event.title).IsEqualTo(TEST_EVENT["title"])
AssertThat(event.description).IsEqualTo(TEST_EVENT["description"])
AssertThat(event.location).IsEqualTo(TEST_EVENT["location"])
AssertThat(event.start).IsEqualTo(
datetime.strptime(
f"{TEST_EVENT['start_date']} {TEST_EVENT['start_time']}",
"%Y-%m-%d %H:%M:%S",
)
)
AssertThat(event.end).IsEqualTo(
datetime.strptime(
f"{TEST_EVENT['end_date']} {TEST_EVENT['end_time']}",
"%Y-%m-%d %H:%M:%S",
)
)
AssertThat(event.event_type).IsEqualTo(TEST_EVENT["business_hour"])
week = Week.query.filter_by(year=YEAR, week_num=WEEK).first()
AssertThat(len(week.events)).IsEqualTo(1)
AssertThat(week.events[0].title).IsEqualTo(TEST_EVENT["title"])
AssertThat(week.events[0].user_id).IsEqualTo(default_user.id)
def test_post_week_handles_invalid_week(
self, year, week, expected_week, default_user
):
r = self.client.post(f"/{year}/{week}", data=TEST_EVENT)
AssertThat(r.status_code).IsEqualTo(200)
AssertThat(r.data).Contains(f"Week - {expected_week}".encode())
def test_get_week_post_does_not_save_event_on_delete(self, default_user):
self.__insert_week()
r = self.client.post(f"/{YEAR}/{WEEK}", data=TEST_DELETE_EVENT)
AssertThat(r.status_code).IsEqualTo(200)
event = Event.query.filter_by(title=TEST_DELETE_EVENT["title"]).first()
AssertThat(event).IsEqualTo(None)
def test_get_week_get_persists_week_into_db(self, default_user):
r = self.client.get(f"/{YEAR}/{WEEK}")
week = Week.query.filter_by(year=YEAR, week_num=WEEK).first()
AssertThat(r.status_code).IsEqualTo(200)
AssertThat(week.year).IsEqualTo(YEAR)
AssertThat(week.week_num).IsEqualTo(WEEK)
def test_get_week_get_does_not_save_already_existing_week_again(
self, default_user
):
self.__insert_week()
r = self.client.get(f"/{YEAR}/{WEEK}")
weeks = Week.query.filter_by(year=YEAR, week_num=WEEK).all()
AssertThat(r.status_code).IsEqualTo(200)
AssertThat(len(weeks)).IsEqualTo(1)
def test_calculate_different_year_handles_anniversaries_correctly(
self, year, week, expected_year, expected_week
):
(
calculated_year,
calculated_week,
) = self.date_time_helper.calculate_different_year(year, week)
AssertThat(calculated_year).IsEqualTo(expected_year)
AssertThat(calculated_week).IsEqualTo(expected_week)
def validate_range(val, min, max):
AssertThat(val).IsAtMost(max)
AssertThat(val).IsAtLeast(min)
AssertThat(val + 1).IsAtMost(max)
AssertThat(val + 1).IsAtLeast(min)
AssertThat(val - 1).IsAtMost(max)
AssertThat(val - 1).IsAtLeast(min)
AssertThat(val << 8).IsAtMost(max)
AssertThat(val << 8).IsAtLeast(min)
AssertThat(val >> 8).IsAtMost(max)
AssertThat(val >> 8).IsAtLeast(min)
async def test_base_auth_route_on_get() -> None:
"""
Check auth handler on GET will return sign in link for external provider.
"""
route = get_patched_route()
route_handler = route.get_route_handler()
request: Request = await get_auth_request(method="GET")
response: ORJSONResponse = await route_handler(request)
response_body = loads(response.body)
AssertThat(response.status_code).IsEqualTo(200)
AssertThat(response_body).IsEqualTo({"link": REDIRECT_LINK})
def test_brk_will_push_3_bytes_onto_the_stack(cpu):
"""BRKWillPush3BytesOntoTheStack"""
cpu.reset_to(0xFF00)
cpu.Memory[0xFF00] = OpCodes.INS_BRK
expected_cycles = 7
cpu_copy = copy.copy(cpu)
# When:
cycles_used = cpu.execute(expected_cycles)
# Then:
AssertThat(expected_cycles).IsEqualTo(cycles_used)
AssertThat(cpu.stack_pointer).IsEqualTo(cpu_copy.stack_pointer - 3)
def test_brk_will_set_the_break_flag(cpu):
"""BRKWillSetTheBreakFlag"""
# Given:
cpu.reset_to(0xFF00)
cpu.Flag.B = False
cpu.Memory[0xFF00] = OpCodes.INS_BRK
expected_cycles = 7
# When:
cycles_used = cpu.execute(expected_cycles)
# Then:
AssertThat(expected_cycles).IsEqualTo(cycles_used)
AssertThat(cpu.Flag.B).IsTruthy()
def test_week_and_event_can_be_inserted_and_queried(self):
event = Event(
event_type=0,
title="<event>",
description="<description>",
location="<location>",
start="2020-10-19 00:00:00",
end="2020-10-19 01:00:00",
)
db.session.add(event)
db.session.add(Week(year=2020, week_num=1, events=[event]))
db.session.commit()
AssertThat(len(
Week.query.filter_by(week_num=1).first().events)).IsEqualTo(1)
queried_week_event = Week.query.filter_by(week_num=1).first().events[0]
AssertThat(queried_week_event.event_type).IsEqualTo(event.event_type)
AssertThat(queried_week_event.title).IsEqualTo(event.title)
AssertThat(queried_week_event.description).IsEqualTo(event.description)
AssertThat(queried_week_event.location).IsEqualTo(event.location)
AssertThat(queried_week_event.start).IsEqualTo(event.start)
AssertThat(queried_week_event.end).IsEqualTo(event.end)
AssertThat(queried_week_event.guest_name).IsEqualTo(event.guest_name)
def test_case_RFID_2():
with allure.step("Send requests to the MQTT"):
mqtt.req83(ename="RFID_2", etype="text", evalue="99296465799940")
with allure.step("Send GET request to the server"):
r = requests.get(TD.url83() + "/get/status")
with allure.step("LOGGER get info"):
LOGGER.info(r.json())
LOGGER.info(r.status_code)
with allure.step("Assert Contains Item"):
with allure.step("RFID_2 should have name САМОСВАЛ КАМАЗ 55102"):
AssertThat(r.json()["result"]["guest"]).ContainsItem(
"name", "САМОСВАЛ КАМАЗ 55102")
AssertThat(r.json()["result"]["guest"]).ContainsItem(
"card_uid", "99296465799940")
def test_worker_parseDate1_generative(mocker, input_date):
# given
input_string = input_date.strftime(format="%d%b%Y")
worker = Worker()
# when
result = worker.parseDate(input_string)
print(input_string, result)
# then
AssertThat(result).IsInstanceOf(str)
AssertThat(result).HasSize(10)
AssertThat(result.split('-')).HasSize(3)
def test_brk_will_load_the_program_counter_from_the_interrupt_vector_2(cpu):
"""BRKWillLoadTheProgramCounterFromTheInterruptVector2"""
# Given:
cpu.reset_to(0xFF00)
cpu.Memory[0xFF00] = OpCodes.INS_BRK
cpu.Memory[0xFFFE] = 0x00
cpu.Memory[0xFFFF] = 0x90
expected_cycles = 7
# When:
cycles_used = cpu.execute(expected_cycles)
# Then:
AssertThat(expected_cycles).IsEqualTo(cycles_used)
AssertThat(cpu.program_counter).IsEqualTo(0x9000)
def test_state_machine_transition_invalid_raises_invalid_machine_error(transitions, initial_state, expected_error):
vid = GenericVideo()
if expected_error is None:
vid.set_machine(transitions, initial_state)
else:
with AssertThat(expected_error).IsRaised():
vid.set_machine(transitions, initial_state)
def test_format_track() -> None:
"""Check formatted track has valid format"""
formatted_track: Optional[Dict[str,
Any]] = format_track(track_info=RAW_TRACK)
AssertThat(TrackModel(**formatted_track).validate(
formatted_track)).IsNotEmpty() # type: ignore
def test_state_change_triggered_on_play_errors_when_moving_from_play():
vid = GoodVideo()
assert vid.machine.state == vid.STOPPED
vid.play()
assert vid.machine.state == vid.PLAYING
with AssertThat(MachineError).IsRaised():
vid.play()
