def create_kafka_producer_with_schema(schema, protocol):
avro_schema = get_schema(protocol, schema)
producer = AIOKafkaProducer(
loop=asyncio.get_event_loop(),
value_serializer=partial(serialize, schema=avro_schema),
bootstrap_servers=os.environ['kafka_bootstrap_servers'])
DataStoreFactory.scenario_data_store().put('producer', producer)
def create_new_customer(firstname, lastname, email):
driver = BrowserFactory.getWebdriver()
DataStoreFactory.spec_data_store().put(email + '_driver', driver)
signup_as(driver, firstname, lastname, email, password="******")
msg = WebDriverWait(driver, 10).until(lambda driver: driver.find_element(By.CLASS_NAME, 'messages').text)
assert_that(msg, any_of(contains_string("Thank you for registering"), contains_string("There is already an account with this email address")))
def signup(self):
user_name = 'user_{}'.format(time.mktime(datetime.datetime.now().timetuple()))
self.set(SignUpPageLocators.USER_NAME, user_name)
self.set(SignUpPageLocators.EMAIL, '{}@gmail.com'.format(user_name))
self.set(SignUpPageLocators.PASSWORD, 'password')
self.set(SignUpPageLocators.CONFIRM_PASSWORD, 'password')
self.click(SignUpPageLocators.SUBMIT)
DataStoreFactory.scenario_data_store().put('current_user', user_name)
def signup(self):
user_name = 'user_{}'.format(
time.mktime(datetime.datetime.now().timetuple()))
self.set(SignUpPageLocators.USER_NAME, user_name)
self.set(SignUpPageLocators.EMAIL, '{}@gmail.com'.format(user_name))
self.set(SignUpPageLocators.PASSWORD, 'password')
self.set(SignUpPageLocators.CONFIRM_PASSWORD, 'password')
self.click(SignUpPageLocators.SUBMIT)
DataStoreFactory.scenario_data_store().put('current_user', user_name)
def test_data_store_factory(self):
scenario_data_store = DataStoreFactory.scenario_data_store()
spec_data_store = DataStoreFactory.spec_data_store()
suite_data_store = DataStoreFactory.suite_data_store()
data_store = DataStore()
self.assertEqual(data_store, scenario_data_store)
self.assertEqual(data_store, spec_data_store)
self.assertEqual(data_store, suite_data_store)
def check_order_exists(email):
appClient = DataStoreFactory.spec_data_store().get(email + '_app_client')
order_id = appClient.get_order_id()
driver = DataStoreFactory.spec_data_store().get('admin_driver')
navigate_to_orders_page_with_id(driver, order_id)
order_block = WebDriverWait(
driver, 10).until(lambda driver: driver.find_element(
By.CLASS_NAME, 'order-view-account-information').text)
assert_that(order_block, contains_string("Order & Account Information"))
def test_data_store_factory(self):
scenario_data_store = DataStoreFactory.scenario_data_store()
spec_data_store = DataStoreFactory.spec_data_store()
suite_data_store = DataStoreFactory.suite_data_store()
data_store = DataStore()
self.assertEqual(data_store, scenario_data_store)
self.assertEqual(data_store, spec_data_store)
self.assertEqual(data_store, suite_data_store)
def consume_messages_with_timeout(number_messages, timeout):
consumer = DataStoreFactory.scenario_data_store().get('consumer')
loop = asyncio.get_event_loop()
messages = loop.run_until_complete(
_consume_messages(consumer, int(number_messages), int(timeout)))
assert len(messages) == int(
number_messages
), f'{len(messages)} messages found, expected {int(number_messages)}'
DataStoreFactory.scenario_data_store().put('messages', messages)
def create_kafka_consumer_with_schema_listening_to_topic(
schema, protocol, topic):
avro_schema = get_schema(protocol, schema)
consumer = AIOKafkaConsumer(
topic,
loop=asyncio.get_event_loop(),
group_id='acceptance_tests_group_id',
value_deserializer=partial(deserialize, schema=avro_schema),
bootstrap_servers=os.environ['kafka_bootstrap_servers'],
auto_offset_reset='earliest')
DataStoreFactory.scenario_data_store().put('consumer', consumer)
def test_Processor_scenario_data_store_init_request(self):
DataStoreFactory.scenario_data_store().put('scenario', 'value')
self.assertNotEqual(DataStore(), DataStoreFactory.scenario_data_store())
response = Message()
processors[Message.ScenarioDataStoreInit](None, response, None)
self.assertEqual(Message.ExecutionStatusResponse, response.messageType)
self.assertEqual(False, response.executionStatusResponse.executionResult.failed)
self.assertEqual(0, response.executionStatusResponse.executionResult.executionTime)
self.assertEqual(DataStore(), DataStoreFactory.scenario_data_store())
def test_Processor_scenario_data_store_init_request(self):
DataStoreFactory.scenario_data_store().put('scenario', 'value')
self.assertNotEqual(DataStore(), DataStoreFactory.scenario_data_store())
response = Message()
processors[Message.ScenarioDataStoreInit](None, response, None)
self.assertEqual(Message.ExecutionStatusResponse, response.messageType)
self.assertEqual(False, response.executionStatusResponse.executionResult.failed)
self.assertEqual(0, response.executionStatusResponse.executionResult.executionTime)
self.assertEqual(DataStore(), DataStoreFactory.scenario_data_store())
def asserts_messages_contains(table):
message_asserts = [dict(zip(table.headers, row)) for row in table]
messages = DataStoreFactory.scenario_data_store().get('messages')
for message, asserts in zip(messages, message_asserts):
for key, value in asserts.items():
assert str(
message[key]
) == value, f'Value "{message[key]}" differs from expected "{value}"'
def test_data_store_factory_as_proxy(self):
stores = [
(data_store.scenario, DataStoreFactory.scenario_data_store()),
(data_store.spec, DataStoreFactory.spec_data_store()),
(data_store.suite, DataStoreFactory.suite_data_store()),
]
for (store, proxy) in stores:
store['a'] = 'alpha'
self.assertTrue(proxy.is_present('a'))
self.assertEqual(proxy.get('a'), store['a'])
proxy.put('b', 'beta')
self.assertIn('b', store)
self.assertEqual(store['b'], proxy.get('b'))
proxy.clear()
self.assertDictEqual(store, {})
def produce_messages(topic, table):
messages = [
dict(
zip(table.headers,
[row[0], row[1],
int(row[2]), int(row[3]), row[4]])) for row in table
]
producer = DataStoreFactory.scenario_data_store().get('producer')
loop = asyncio.get_event_loop()
loop.run_until_complete(_produce_messages(producer, topic, messages))
def setUp(self):
self.setUpPyfakefs()
DataStoreFactory.suite_data_store().clear()
DataStoreFactory.spec_data_store().clear()
DataStoreFactory.scenario_data_store().clear()
registry.clear()
def save_product_id(self):
DataStoreFactory.scenario_data_store().put('product_id', self.get(ProductPageLocators.ID))
def process_cart(email, firstname, lastname, street, city, region, postcode, country, telephone):
appClient = DataStoreFactory.spec_data_store().get(email + '_app_client')
appClient.set_shipping_info(email, firstname, lastname, street, city, region, postcode, country, telephone)
appClient.submit_cart_payment_info(email, firstname, lastname, street, city, region, postcode, country, telephone)
def visit(self):
self.driver.get(
self.URL.format(
id=DataStoreFactory.scenario_data_store().get('product_id')))
def close(email):
driver = DataStoreFactory.spec_data_store().get(email + '_driver')
driver.quit()
def save_product_id(self):
DataStoreFactory.scenario_data_store().put(
'product_id', self.get(ProductPageLocators.ID))
def login_as_admin():
driver = BrowserFactory.getWebdriver()
DataStoreFactory.spec_data_store().put('admin_driver', driver)
login(driver)
assert_that(driver.title, contains_string("Dashboard"))
def _init_scenario_data_store(request, response, socket):
DataStoreFactory.scenario_data_store().clear()
set_response_values(request, response)
def check_order_contains_item_with_sku(sku):
driver = DataStoreFactory.spec_data_store().get('admin_driver')
sku_block = WebDriverWait(driver,
10).until(lambda driver: driver.find_element(
By.CLASS_NAME, 'product-sku-block').text)
assert_that(sku_block, contains_string(sku))
def add_cart_items(sku, email):
appClient = DataStoreFactory.spec_data_store().get(email + '_app_client')
appClient.add_item_to_cart(sku)
from getgauge.python import step, before_spec, Messages, DataStoreFactory
from src import get_test_client, SignClient, default_infod
from os import chdir, curdir
# --------------------------
# Gauge step implementations
# --------------------------
data_store = DataStoreFactory.spec_data_store()
@step("We can get a token if we input right username and password.")
def get_token():
Messages.write_message("考虑到频繁执行这个测试的风险，我们暂时搁置这个测试。")
"""
_, _, token_fact = get_test_client()
token = token_fact.make_token()
assert token is not None
Messages.write_message(f"the token is {len(token)}.")
assert len(token) >= 64
data_store.put('token', token)
"""
@step("after sign, we will get no sign infomation.")
def sign_test():
c, _, _ = get_test_client()
_, status = c.auto_sign()
if status == 0:
Messages.write_message("签到看起来成功了，接下来看看我们还能不能签。")
_, (e, _) = c.auto_sign()
assert e == 3
def verify_registered_customer_is_listed():
PageFactory.customer_page.verify_user_listed(DataStoreFactory.scenario_data_store().get('current_user'))
def setUp(self):
DataStoreFactory.suite_data_store().clear()
DataStoreFactory.spec_data_store().clear()
DataStoreFactory.scenario_data_store().clear()
registry.clear()
def visit(self):
self.driver.get(self.URL.format(id=DataStoreFactory.scenario_data_store().get('product_id')))
def get_token_for_user(email):
appClient = MobileAppClient(email=email)
DataStoreFactory.spec_data_store().put(email + '_app_client', appClient)
appClient.request_token(password='******')
def _init_suite_data_store(request, response, _socket):
DataStoreFactory.suite_data_store().clear()
set_response_values(request, response)
def create_cart(email):
appClient = DataStoreFactory.spec_data_store().get(email + '_app_client')
appClient.create_cart()
