-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathtest.py
371 lines (287 loc) · 13.5 KB
/
test.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
import unittest
from selenium import webdriver
from selenium.webdriver.firefox.options import Options
from tests.pages.front import FrontPage
from tests.pages.admin import AdminPage
from tests.my_contact_provider import MyContactProvider
import sys
import os
import time
import pdb
import json
from datetime import date, datetime, timedelta
from configparser import ConfigParser
from faker import Faker
from tests.my_contact_provider import MyContactProvider
from tests.booker_api import BookerAPI
def setUpRun():
"""Setup the webdriver and initialize API."""
global driver
global booker_api
options = Options()
if HEADLESS:
options.add_argument('-headless')
print("Create a new Firefox session")
driver = webdriver.Firefox(options=options)
print("Set implicitly wait")
driver.implicitly_wait(15)
print("Window size: {width}x{height}".format(**driver.get_window_size()))
booker_api = BookerAPI(
base_url=BASE_URL, username=BOOKER_API_USERNAME, password=BOOKER_API_PASSWORD)
def tearDownRun():
"""Close the webdriver."""
global driver
screenshot_filename = "result_{}.png".format(
time.strftime("%Y%m%d-%H%M%S"))
screenshots_dir = "screenshots"
screenshot_path = "{}/{}".format(screenshots_dir, screenshot_filename)
print("Saving screenshot: %s" % screenshot_path)
if not os.path.exists(screenshots_dir):
os.mkdir(screenshots_dir)
driver.save_screenshot(screenshot_path)
print("Close the Firefox session")
driver.quit()
class BaseModel(unittest.TestCase):
"""Contains common methods for all models."""
def setUpModel(self):
global driver
global booker_api
print("Set up for: {}".format(type(self).__name__))
self.driver = driver
self.booker_api = booker_api
self.name = None
self.subject = None
def e_load_frontpage(self):
page = FrontPage(self.driver, BASE_URL)
page.open()
def e_submit_valid_contact_data(self, data):
page = FrontPage(self.driver, BASE_URL)
page.contact_form.wait_for_region_to_load()
name = fake.valid_name()
email = fake.valid_email()
phone = fake.valid_phone()
subject = fake.valid_subject()
description = fake.valid_description()
# variables could be saved in python side, in this object, but we'll need to share them between models which use a different class & o§bject
# self.name = fake.valid_name()
# self.subject = fake.valid_subject()
data['global.last_contact_name'] = name
data['global.last_contact_email'] = email
data['global.last_contact_phone'] = phone
data['global.last_contact_subject'] = subject
data['global.last_contact_description'] = description
page.contact_form.fill_contact_data(
name=name, email=email, phone=phone, subject=subject, description=description)
def v_contact_successful(self, data):
page = FrontPage(self.driver, BASE_URL)
# if we saved variables in the object itself...
# self.assertEqual(page.contact_form.contact_feedback_message,
# f"Thanks for getting in touch {self.name}!\nWe'll get back to you about\n{self.subject}\nas soon as possible.")
name = data['last_contact_name']
subject = data['last_contact_subject']
self.assertEqual(page.contact_form.contact_feedback_message,
f"Thanks for getting in touch {name}!\nWe'll get back to you about\n{subject}\nas soon as possible.")
def v_contact_unsuccessful(self):
page = FrontPage(self.driver, BASE_URL)
self.assertTrue(page.contact_form.is_error_message_present,
"error message must be present")
def v_frontpage_can_contact(self):
page = FrontPage(self.driver, BASE_URL)
self.assertTrue(page.contact_form.is_form_available,
"contact form is unavailable for submission")
def v_start(self):
pass
class ContactForm(BaseModel):
def e_submit_invalid_contact_data(self):
page = FrontPage(self.driver, BASE_URL)
page.contact_form.wait_for_region_to_load()
name = ""
email = ""
phone = ""
subject = ""
description = ""
invalid = False
# randomly generate invalid contact fields (at least one of them)
if fake.pyint(max_value=1) > 0:
name = fake.invalid_name()
else:
name = fake.valid_name()
invalid = True
if fake.pyint(max_value=1) > 0:
email = fake.invalid_email()
else:
email = fake.valid_email()
invalid = True
if fake.pyint(max_value=1) > 0:
phone = fake.invalid_phone()
else:
phone = fake.valid_phone()
invalid = True
if fake.pyint(max_value=1) > 0:
subject = fake.invalid_subject()
else:
subject = fake.valid_subject()
invalid = True
if fake.pyint(max_value=1) > 0 or invalid:
description = fake.invalid_description()
else:
description = fake.valid_description()
page.contact_form.fill_contact_data(
name=name, email=email, phone=phone, subject=subject, description=description)
class ContactFormDetailed(BaseModel):
def e_submit_invalid_contact_name(self):
page = FrontPage(self.driver, BASE_URL)
page.contact_form.wait_for_region_to_load()
page.contact_form.fill_contact_data(
name=fake.invalid_name(), email=fake.valid_email(), phone=fake.valid_phone(), subject=fake.valid_subject(), description=fake.valid_description())
def e_submit_invalid_contact_email(self):
page = FrontPage(self.driver, BASE_URL)
page.contact_form.wait_for_region_to_load()
page.contact_form.fill_contact_data(
name=fake.valid_name(), email=fake.invalid_email(), phone=fake.valid_phone(), subject=fake.valid_subject(), description=fake.valid_description())
def e_submit_invalid_contact_phone(self):
page = FrontPage(self.driver, BASE_URL)
page.contact_form.wait_for_region_to_load()
page.contact_form.fill_contact_data(
name=fake.valid_name(), email=fake.valid_email(), phone=fake.invalid_phone(), subject=fake.valid_subject(), description=fake.valid_description())
def e_submit_invalid_contact_subject(self):
page = FrontPage(self.driver, BASE_URL)
page.contact_form.wait_for_region_to_load()
page.contact_form.fill_contact_data(
name=fake.valid_name(), email=fake.valid_email(), phone=fake.valid_phone(), subject=fake.invalid_subject(), description=fake.valid_description())
def e_submit_invalid_contact_message(self):
page = FrontPage(self.driver, BASE_URL)
page.contact_form.wait_for_region_to_load()
page.contact_form.fill_contact_data(
name=fake.valid_name(), email=fake.valid_email(), phone=fake.valid_phone(), subject=fake.valid_subject(), description=fake.invalid_description())
class MessageBackoffice(BaseModel):
def e_click_admin_panel(self):
page = FrontPage(self.driver)
page.click_admin_panel()
def e_admin_click_rooms(self):
page = AdminPage(self.driver)
page.click_rooms()
def e_click_frontpage(self):
page = AdminPage(self.driver)
page.click_frontpage()
def e_admin_click_inbox(self):
page = AdminPage(self.driver)
page.click_inbox()
def e_admin_correct_login(self):
page = AdminPage(self.driver)
page.authenticate_with_valid_credentials()
def e_click_last_message(self, data):
page = AdminPage(self.driver)
name = data['last_contact_name']
subject = data['last_contact_subject']
page.inbox.find_and_open_unread_message(name=name, subject=subject)
def e_close_message_details(self):
page = AdminPage(self.driver)
page.inbox.close_message_details()
def v_admin_login(self):
page = AdminPage(self.driver)
self.assertTrue(page.is_login_form_available,
"login form is unavailable")
def v_admin_messages(self):
page = AdminPage(self.driver)
self.assertTrue(page.inbox.is_message_section_open,
"message section is not opened")
def v_admin_rooms(self):
page = AdminPage(self.driver)
self.assertTrue(page.rooms.is_rooms_section_open,
"rooms section is not opened")
def v_message_details(self, data):
page = AdminPage(self.driver)
name = data['last_contact_name']
email = data['last_contact_email']
phone = data['last_contact_phone']
subject = data['last_contact_subject']
description = data['last_contact_description']
self.assertEqual(page.inbox.message_detail_name,
f"From: {name}", "message's name doesnt match")
self.assertEqual(page.inbox.message_detail_email,
f"Email: {email}", "message's email doesnt match")
self.assertEqual(page.inbox.message_detail_phone,
f"Phone: {phone}", "message's phone doesnt match")
self.assertEqual(page.inbox.message_detail_subject, subject,
"message's subject doesnt match")
self.assertEqual(page.inbox.message_detail_description,
description, "message's description doesnt match")
class NewBooking1(BaseModel):
def e_click_available_room(self):
page = FrontPage(self.driver, BASE_URL)
page.open()
# click on first room
room = page.rooms.available_rooms()[0]
page.rooms.click_book_room(room)
def e_select_calendar_dates(self, data):
page = FrontPage(self.driver, BASE_URL)
# book some nights, starting today
today = date.today()
self.start_date = today
total_nights = int(data['total_nights'])
self.end_date = today+timedelta(days=total_nights)
page.rooms.select_calendar_dates(
start_day=self.start_date.day, end_day=self.end_date.day)
def v_booking_dates_selected(self, data):
page = FrontPage(self.driver, BASE_URL)
# check displayed information on the total nights and price, before submitting
price_per_night = self.booker_api.get_rooms()[0]['roomPrice']
total_nights = int(data['total_nights'])
total_price = price_per_night*total_nights
for selection_block in page.rooms.get_date_selection_blocks():
self.assertEqual(selection_block.text,
f'{total_nights} night(s) - £{total_price}')
def e_fill_booking_contact(self):
page = FrontPage(self.driver, BASE_URL)
self.first_name = fake.first_name()
self.last_name = fake.last_name()
self.email = fake.valid_email()
self.phone = fake.valid_phone()
page.rooms.fill_booking_contact_data(
first_name=self.first_name, last_name=self.last_name, email=self.email, phone=self.phone)
def v_rooms_available(self):
page = FrontPage(self.driver, BASE_URL)
self.assertTrue(page.rooms.available_rooms(), "no available rooms")
def v_room_new_booking_dialog(self):
page = FrontPage(self.driver, BASE_URL)
self.assertTrue(page.rooms.is_booking_calendar_present,
"booking calendar is not present")
self.assertTrue(page.rooms.is_booking_contact_form_present,
"booking contact form is not present")
def v_booking_contact_filled(self):
page = FrontPage(self.driver, BASE_URL)
self.assertTrue(page.rooms.is_booking_contact_filled,
"booking contact has not been filled")
def e_confirm_booking(self):
page = FrontPage(self.driver, BASE_URL)
page.rooms.click_submit_booking()
def v_room_booked(self):
page = FrontPage(self.driver, BASE_URL)
# check confirmation message and stored booking on system
last_booking = self.booker_api.get_bookings()[-1]
start_date_str = self.start_date.isoformat()
end_date_str = self.end_date.isoformat()
self.assertEqual(page.rooms.booking_confirmed_message,
f"Booking Successful!\nCongratulations! Your booking has been confirmed for:\n{start_date_str} - {end_date_str}\nClose")
self.assertTrue(last_booking['firstname'] == self.first_name and last_booking['lastname'] == self.last_name and last_booking['bookingdates']['checkin']
== start_date_str and last_booking['bookingdates']['checkout'] == end_date_str, f"booking not found (last_booking={last_booking}")
#########
HEADLESS = False
driver = None
config = ConfigParser()
config.read('config.ini')
BASE_URL = os.environ.get("BASE_URL", config.get('app', 'base_url'))
BOOKER_API_USERNAME = config.get('app', 'booker_api_username')
BOOKER_API_PASSWORD = config.get('app', 'booker_api_password')
debugger = pdb.Pdb(skip=['altwalker.*'], stdout=sys.stdout)
fake = Faker()
fake.add_provider(MyContactProvider)
# Enforce a specific seed; there are currently some limitations in both AltWalker and GraphWalker though
# seed works in GW 4.3 but AltWaker doesn't have a way to enforce it or obtain it
with open('models/contact_form.json') as f:
models_data = json.load(f)
seed = models_data["seed"] or os.environ.get(
"SEED", config.getint('other', 'seed'))
print(f'seed: {seed}')
Faker.seed(int(seed))