def test_topup_wallet_balance(self):
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.USD)
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.USD,
"balance": 0
},
json.loads(DefaultController.get(r))["result"])
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.USD)
r.set("amount", 100)
result = json.loads(DefaultController.topup(r))["result"]
self.assertTrue(result)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.USD,
"balance": 100
},
json.loads(DefaultController.get(r))["result"])
def test_success_scenario(self):
# Registration:
r = Request()
r.set("login", 'MyLogin')
r.set("password", "MySecret")
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
# Authentication:
r = Request()
r.set("login", 'MyLogin')
r.set("password", "MySecret")
token1 = json.loads(DefaultController.auth(r))["result"]
# We got a token 32-symbols length
self.assertEqual(32, len(token1))
# Second authentication provides as with same-length token:
token2 = json.loads(DefaultController.auth(r))["result"]
self.assertEqual(32, len(token2))
# But this time it is not equal with the first one:
self.assertNotEqual(token1, token2)
# Authentication with token:
r = Request()
r.set("token", token2)
result = json.loads(DefaultController.auth(r))["result"]
self.assertTrue(result)
def ajax_auth(cls, user, request: Request, **kwargs):
request.set("login", Phone(request.get("login")).get_value())
if AuthController.auth(request, **kwargs):
return {
"user": user.stringify(["position_name", "name", "phone", "phone_verified", "email", "email_verified"]),
"preview_randomizer": datetime.now().microsecond
}
def new_default_account(cls, request: Request, do_auth=True, auto_register=False) -> Account:
account = Account({"login": AuthentificationService.gen_password(), "password": AuthentificationService.gen_password()})
if do_auth:
request.set("token", account.set_new_token())
cls.auth(request)
if auto_register:
cls.users_collection().get_new_item().load_from_array({"name": "Анонимный пользователь", "account": account}).save()
return account
def test_override(self):
""" Из нескольких значений аргумента в запросе сохранится последнее переданное """
request = Request({'prop': 1}, {'prop': 2})
self.assertEqual(2, request.get('prop'))
request.set('prop', 3)
self.assertEqual(3, request.get('prop'))
request.update({'prop': 4})
self.assertEqual(4, request.get('prop'))
def test_no_data(self):
r = Request()
r.set("base_currency", Currencies.EUR)
self.assertEqual(
{
"error": {
"code": "CONVERTER_1",
"message": "No Data For Requested Currency"
}
}, json.loads(DefaultController.get_last_value(r)))
def test_override(self):
""" Из нескольких значений аргумента в запросе сохранится последнее переданное """
request = Request({'prop': 1}, {'prop': 2})
self.assertEqual(2, request.get('prop'))
request.set('prop', 3)
self.assertEqual(3, request.get('prop'))
request.update({'prop': 4})
self.assertEqual(4, request.get('prop'))
def test_creating_on_demand(self):
""" gracefull degradation: if someone authenticates with given login - we have to create a wallet for him """
r = Request()
r.set("login", "MyLogin")
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.USD,
"balance": 0
},
json.loads(DefaultController.get(r))["result"])
def test_creating_on_demand(self):
""" gracefull degradation: if someone authenticates with given login - we have to create a user for him """
r = Request()
r.set("login", "MyLogin")
self.assertEqual(
{
"login": "******",
"name": "Unknown",
"country_id": None,
"city_id": None
},
json.loads(DefaultController.get(r))["result"])
def test_supported_currencies(self):
r = Request()
self.assertEqual({
'1': "USD",
'2': "EUR",
'3': "CAD",
'4': "CNY"
},
json.loads(
DefaultController.get_currencies(r))["result"])
# Creating 4 wallets for ONE login (Supported currencies):
for base_currency in [1, 2, 3, 4]:
r = Request()
r.set("login", f"MyLogin{base_currency}")
r.set("base_currency", base_currency)
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
# Attempt to create unsupported wallet
r = Request()
r.set("login", "MyLoginBTC")
r.set("base_currency", "BTC")
self.assertEqual(
{
"code": "WALLETS_1",
"message": "Unsupported Currency"
},
json.loads(DefaultController.create(r))["error"])
def test_cities(self):
# Request a city with a country that doesn't exist
r = Request()
r.set("name", "City1")
r.set("country_id", 1)
self.assertEqual({
"code": "GEO_1",
"message": "Unknown country"
},
json.loads(DefaultController.get_city(r))["error"])
# Create a country:
r = Request()
r.set("name", "Country1")
self.assertEqual({
"id": 1,
"name": "Country1"
},
json.loads(
DefaultController.get_country(r))["result"])
# Request a city that doesn't exist with just created country:
r = Request()
r.set("name", "City1")
r.set("country_id", 1)
self.assertEqual({
"id": 1,
"name": "City1",
"country_id": 1
},
json.loads(DefaultController.get_city(r))["result"])
# Request a city that doesn't exist by id:
r = Request()
r.set("id", 2)
r.set("country_id", 1)
self.assertEqual({
"code": "GEO_2",
"message": "Unknown city"
},
json.loads(DefaultController.get_city(r))["error"])
def test_countries(self):
# Request a country that doesn't exist yet
r = Request()
r.set("name", "Country1")
self.assertEqual({
"id": 1,
"name": "Country1"
},
json.loads(
DefaultController.get_country(r))["result"])
# Request just created country by its id:
r = Request()
r.set("id", 1)
self.assertEqual({
"id": 1,
"name": "Country1"
},
json.loads(
DefaultController.get_country(r))["result"])
# Request a country that doesn't exist by id:
r = Request()
r.set("id", 2)
self.assertEqual({
"code": "GEO_1",
"message": "Unknown country"
},
json.loads(DefaultController.get_country(r))["error"])
def test_wallets(self):
# Creating:
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.CNY)
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
# Getting back:
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.CNY)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.CNY,
"balance": 0
},
json.loads(DefaultController.get(r))["result"])
def test_bulk_upload(self):
r = Request()
r.set("data", [
{
"base_currency": Currencies.EUR,
"value": 1.2,
"datetime": datetime.now().strftime("%c")
},
{
"base_currency": Currencies.CNY,
"value": 3.4,
"datetime": datetime.now().strftime("%c")
},
])
self.assertTrue(json.loads(DefaultController.save_bulk(r))["result"])
r = Request()
r.set("base_currency", Currencies.EUR)
last_value = json.loads(DefaultController.get_last_value(r))["result"]
self.assertEqual(
{
"uuid": last_value["uuid"],
"value": 1.2,
"base_currency": Currencies.EUR,
"datetime": last_value["datetime"]
}, last_value)
r = Request()
r.set("base_currency", Currencies.CNY)
last_value = json.loads(DefaultController.get_last_value(r))["result"]
self.assertEqual(
{
"uuid": last_value["uuid"],
"value": 3.4,
"base_currency": Currencies.CNY,
"datetime": last_value["datetime"]
}, last_value)
class RequestTests(unittest.TestCase):
def setUp(self):
""" Каждый тест получает пустой объект запроса """
self.request = Request()
def test_getter(self):
""" Запрос инициализируется любым количеством словарей """
request = Request({'a': 1}, {'b': 2}, {'c': 3}, {'d': 4})
self.assertEqual(1, request.get('a'))
self.assertEqual(2, request.get('b'))
self.assertEqual(3, request.get('c'))
self.assertEqual(4, request.get('d'))
def test_getter_type_casting(self):
""" Автоматическое приведение аргументов к нужному типу """
request = Request({'b': '2'})
self.assertEqual('2', request.get('b'))
self.assertEqual(2, request.get('b', cast_type=int))
def test_getter_type_casting_exception(self):
""" Выброс исключения при невозможности приведения аргументов к нужному типу """
request = Request({'a': '1abc'})
self.assertRaises(Request.ArgumentTypeError,
request.get,
'a',
cast_type=int)
self.assertEqual('1abc', request.get('a'))
def test_getter_default(self):
request = Request({'a': 1}, {'b': 2}, {'c': 3}, {'d': 4})
self.assertRaises(Request.RequiredArgumentIsMissing, request.get, 'x')
self.assertEqual("xxx", request.get('x', "xxx"))
self.assertEqual("xxx", request.get('x', default="xxx"))
self.assertEqual(None, request.get('x', None))
self.assertEqual(None, request.get('x', default=None))
def test_setter(self):
""" Сеттер добавляет в запрос новый аргумент """
self.request.set('argument', True)
self.assertEqual(True, self.request.get('argument'))
def test_update_from_dictionary(self):
""" Запрос можно обновить данными из словаря """
self.request.update({'a': 1, 'b': 2})
self.assertEqual(1, self.request.get('a'))
self.assertEqual(2, self.request.get('b'))
def test_update_from_non_dictionary(self):
""" Попытка обновить запрос не из словаря вызывает исключение """
self.assertRaises(TypeError, self.request.update, 1)
self.assertRaises(TypeError, self.request.update, [])
def test_missing_argument_with_default_value(self):
""" Запрос отсутствующего аргумента с указанием дефолтного значения возвращает переданное дефолтное значение """
self.assertEqual(
2, self.request.get('missing_argument_with_default_value', 2))
def test_missing_argument(self):
""" Запрос отсутствующего аргумента без указания дефолтного значения вызывает исключение """
self.assertRaises(Request.RequiredArgumentIsMissing, self.request.get,
'missing_argument')
def test_override(self):
""" Из нескольких значений аргумента в запросе сохранится последнее переданное """
request = Request({'prop': 1}, {'prop': 2})
self.assertEqual(2, request.get('prop'))
request.set('prop', 3)
self.assertEqual(3, request.get('prop'))
request.update({'prop': 4})
self.assertEqual(4, request.get('prop'))
def test_ajax_type_detection(self):
""" Ajax запрос определяется по заголовку HTTP_X_REQUESTED_WITH """
request = Request(environ={"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"})
self.assertEqual(Request.Types.AJAX, request.type())
def test_pjax_type_detection(self):
""" Pjax запрос определяется по двум заголовкам HTTP_X_REQUESTED_WITH и HTTP_X_PJAX """
request = Request(environ={
"HTTP_X_PJAX": True,
"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"
})
self.assertEqual(Request.Types.PJAX, request.type())
def test_json_rpc_type_detection(self):
""" JsonRPC запрос определяется по наличию аргумента q в запросе и только по нему одному """
request = Request({"q": "{}"})
self.assertEqual(Request.Types.JSON_RPC, request.type())
request = Request({"q": "{}"},
environ={"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"})
self.assertEqual(Request.Types.JSON_RPC, request.type())
def test_static_type_detection(self):
""" Любой запрос не являющийся Ajax, Pjax, Json_RPC является STATIC """
request = Request()
self.assertEqual(Request.Types.STATIC, request.type())
def test_successful_transfer_between_wallets_USD_TO_USD(self):
# Create first empty wallet with USD:
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.USD)
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.USD,
"balance": 0
},
json.loads(DefaultController.get(r))["result"])
# Create seconds empty wallet with USD:
r = Request()
r.set("login", "MyLogin2")
r.set("base_currency", Currencies.USD)
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.USD,
"balance": 0
},
json.loads(DefaultController.get(r))["result"])
# Top up first wallet with some 1 USD
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.USD)
r.set("amount", 100)
result = json.loads(DefaultController.topup(r))["result"]
self.assertTrue(result)
# Transfer funds:
r = Request()
r.set("from_login", "MyLogin")
r.set("from_base_currency", Currencies.USD)
r.set("to_login", "MyLogin2")
r.set("to_base_currency", Currencies.USD)
r.set("amount", 50)
result = json.loads(DefaultController.transfer(r))["result"]
self.assertTrue(result)
# Check:
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.USD)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.USD,
"balance": 50
},
json.loads(DefaultController.get(r))["result"])
r.set("base_currency", Currencies.USD)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.USD,
"balance": 50
},
json.loads(DefaultController.get(r))["result"])
def test_get_routes(self):
"""
Проверка контроллера на получение полетов и сортировки
:return:
"""
r = Request()
r.set('source', 'DXB')
r.set('destination', 'BKK')
r.set('departure_date', date(2018, 10, 27))
result = json.loads(RoutesController().get_routes(r)).get('result')
self.assertEqual(102, len(result['routes']))
r.set('departure_date', date(2018, 10, 22))
result = json.loads(RoutesController().get_routes(r)).get('result')
self.assertEqual(200, len(result['routes']))
r.set('order_field', 'price')
r.set('order_value', 'asc')
r.set('limit', 1)
result = json.loads(RoutesController().get_routes(r)).get('result')
self.assertEqual(1, len(result['routes']))
def test_successful_transfer_between_wallets_CNY_TO_USD(self):
# We need a mock for converter:
class MockConverter(Currencies.Converter):
get_last_value = lambda bc: 0.25
get_by_uuid = lambda uuid: {
"uuid": uuid,
"value": 0.25,
"base_currency": Currencies.CNY,
"datetime": datetime.now().strftime("%c")
}
# Set up our mock:
Currencies.Converter = MockConverter
# Create first empty wallet with USD:
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.CNY)
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.CNY,
"balance": 0.0
},
json.loads(DefaultController.get(r))["result"])
# Create seconds empty wallet with USD:
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.USD)
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.USD,
"balance": 0.0
},
json.loads(DefaultController.get(r))["result"])
# Top up first wallet with some 10 CNY
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.CNY)
r.set("amount", 10)
result = json.loads(DefaultController.topup(r))["result"]
self.assertTrue(result)
# Transfer funds:
r = Request()
r.set("from_login", "MyLogin")
r.set("from_base_currency", Currencies.CNY)
r.set("to_login", "MyLogin")
r.set("to_base_currency", Currencies.USD)
r.set("conversion_rate_uuid_1", "576ff813-d370-475d-aa02-c576ef291b96")
r.set("conversion_rate_uuid_2", None)
r.set("amount", 10)
result = json.loads(DefaultController.transfer(r))["result"]
self.assertTrue(result)
# Check:
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.CNY)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.CNY,
"balance": 0
},
json.loads(DefaultController.get(r))["result"])
r.set("base_currency", Currencies.USD)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.USD,
"balance": 2.5
},
json.loads(DefaultController.get(r))["result"])
def test_success_scenario(self):
# Saving rates:
r = Request()
r.set("base_currency", Currencies.EUR)
r.set("value", 1.246778)
self.assertTrue(json.loads(DefaultController.save(r))["result"])
r = Request()
r.set("base_currency", Currencies.CNY)
r.set("value", 3.467789)
self.assertTrue(json.loads(DefaultController.save(r))["result"])
# Get last value:
r = Request()
r.set("base_currency", Currencies.CNY)
last_value = json.loads(DefaultController.get_last_value(r))["result"]
self.assertEqual(
{
"uuid": last_value["uuid"],
"value": 3.467789,
"base_currency": Currencies.CNY,
"datetime": last_value["datetime"]
}, last_value)
r = Request()
r.set("base_currency", Currencies.EUR)
last_value = json.loads(DefaultController.get_last_value(r))["result"]
self.assertEqual(
{
"uuid": last_value["uuid"],
"value": 1.246778,
"base_currency": Currencies.EUR,
"datetime": last_value["datetime"]
}, last_value)
# Get by uuid:
r = Request()
r.set("uuid", last_value["uuid"])
last_value = json.loads(DefaultController.get_by_uuid(r))["result"]
self.assertEqual(
{
"uuid": last_value["uuid"],
"value": 1.246778,
"base_currency": Currencies.EUR,
"datetime": last_value["datetime"]
}, last_value)
def test_users(self):
# Creating:
r = Request()
r.set("login", "MyLogin")
r.set("name", "MyName")
r.set("country_id", 1)
r.set("city_id", 2)
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
# Getting back:
r = Request()
r.set("login", "MyLogin")
self.assertEqual(
{
"login": "******",
"name": "MyName",
"country_id": 1,
"city_id": 2
},
json.loads(DefaultController.get(r))["result"])
# Updating:
r = Request()
r.set("login", "MyLogin")
r.set("name", "MyName Updated")
r.set("country_id", 11)
r.set("city_id", 22)
result = json.loads(DefaultController.change(r))["result"]
self.assertTrue(result)
# Check:
r = Request()
r.set("login", "MyLogin")
self.assertEqual(
{
"login": "******",
"name": "MyName Updated",
"country_id": 11,
"city_id": 22
},
json.loads(DefaultController.get(r))["result"])
def test_wrong_credentials(self):
""" common test with entity `credentials` """
# Registration:
r = Request()
r.set("login", 'MyLogin')
r.set("password", "MySecret")
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
# Second attempt to register with the same login:
r = Request()
r.set("login", 'MyLogin')
r.set("password", "MySecret")
self.assertEqual(
{"error": {"code": "AUTH_4", "message": "Already registred"}},
json.loads(DefaultController.create(r))
)
# Authetntication with incorrect login:
r = Request()
r.set("login", 'BadLogin')
r.set("password", "MySecret")
self.assertEqual(
{"error": {"code": "AUTH_1", "message": "Incorrect login"}},
json.loads(DefaultController.auth(r))
)
# Authetntication with incorrect password:
r = Request()
r.set("login", 'MyLogin')
r.set("password", "BadPassword")
self.assertEqual(
{"error": {"code": "AUTH_2", "message": "Incorrect password"}},
json.loads(DefaultController.auth(r))
)
# Authentication with incorrect token:
r = Request()
r.set("token", "BadToken")
self.assertEqual(
{"error": {"code": "AUTH_3", "message": "Incorrect token"}},
json.loads(DefaultController.auth(r))
)
def test_successful_transfer_between_wallets_CNY_TO_EUR(self):
# We need a mock for converter:
class MockConverter(Currencies.Converter):
get_last_value = lambda bc: 0.25 if bc == Currencies.CNY else 1.2
get_by_uuid = lambda uuid: {
"uuid":
uuid,
"value":
0.25 if uuid == "CNY-USD" else 1.2,
"base_currency":
Currencies.CNY if uuid == "CNY-USD" else Currencies.EUR,
"datetime":
datetime.now().strftime("%c")
}
# Set up our mock:
Currencies.Converter = MockConverter
# Create first empty wallet with CNY:
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.CNY)
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.CNY,
"balance": 0.0
},
json.loads(DefaultController.get(r))["result"])
# Create seconds empty wallet with EUR:
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.EUR)
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.EUR,
"balance": 0.0
},
json.loads(DefaultController.get(r))["result"])
# Top up first wallet with some 10 CNY
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.CNY)
r.set("amount", 10)
result = json.loads(DefaultController.topup(r))["result"]
self.assertTrue(result)
# Transfer funds:
r = Request()
r.set("from_login", "MyLogin")
r.set("from_base_currency", Currencies.CNY)
r.set("to_login", "MyLogin")
r.set("to_base_currency", Currencies.EUR)
r.set("conversion_rate_uuid_1", "CNY-USD")
r.set("conversion_rate_uuid_2", "USD-EUR")
r.set("amount", 10)
tx_result = json.loads(DefaultController.transfer(r))["result"]
tx_uuid = tx_result["uuid"]
tx_datetime = tx_result["datetime"]
self.assertEqual(36, len(tx_uuid))
# Check:
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.CNY)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.CNY,
"balance": 0
},
json.loads(DefaultController.get(r))["result"])
r.set("base_currency", Currencies.EUR)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.EUR,
"balance": 2.0833
},
json.loads(DefaultController.get(r))["result"])
# Check reports:
r = Request()
r.set("login", "MyLogin")
self.assertEqual(
{
"incoming": [[
tx_uuid, "MyLogin", Currencies.EUR, 2.0833, "USD-EUR",
tx_datetime
]],
"outgoing": [[
tx_uuid, "MyLogin", Currencies.CNY, 10.0, "CNY-USD",
tx_datetime
]],
},
json.loads(DefaultController.get_transactions(r))["result"])
def test_insufficient_funds(self):
# Create first empty wallet with USD:
r = Request()
r.set("login", "MyLogin")
r.set("base_currency", Currencies.USD)
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.USD,
"balance": 0
},
json.loads(DefaultController.get(r))["result"])
# Create seconds empty wallet with USD:
r = Request()
r.set("login", "MyLogin2")
r.set("base_currency", Currencies.USD)
result = json.loads(DefaultController.create(r))["result"]
self.assertTrue(result)
self.assertEqual(
{
"login": "******",
"base_currency": Currencies.USD,
"balance": 0
},
json.loads(DefaultController.get(r))["result"])
# Test rejection:
r = Request()
r.set("from_login", "MyLogin")
r.set("from_base_currency", Currencies.USD)
r.set("to_login", "MyLogin")
r.set("to_base_currency", Currencies.USD)
r.set("amount", 1)
self.assertEqual(
{"error": {
"code": "WALLETS_3",
"message": "Insufficient Funds"
}}, json.loads(DefaultController.transfer(r)))
class RequestTests(unittest.TestCase):
def setUp(self):
""" Каждый тест получает пустой объект запроса """
self.request = Request()
def test_getter(self):
""" Запрос инициализируется любым количеством словарей """
request = Request({'a': 1}, {'b': 2}, {'c': 3}, {'d': 4})
self.assertEqual(1, request.get('a'))
self.assertEqual(2, request.get('b'))
self.assertEqual(3, request.get('c'))
self.assertEqual(4, request.get('d'))
def test_getter_type_casting(self):
""" Автоматическое приведение аргументов к нужному типу """
request = Request({'b': '2'})
self.assertEqual('2', request.get('b'))
self.assertEqual(2, request.get('b', cast_type=int))
def test_getter_type_casting_exception(self):
""" Выброс исключения при невозможности приведения аргументов к нужному типу """
request = Request({'a': '1abc'})
self.assertRaises(Request.ArgumentTypeError, request.get, 'a', cast_type=int)
self.assertEqual('1abc', request.get('a'))
def test_getter_default(self):
request = Request({'a': 1}, {'b': 2}, {'c': 3}, {'d': 4})
self.assertRaises(Request.RequiredArgumentIsMissing, request.get, 'x')
self.assertEqual("xxx", request.get('x', "xxx"))
self.assertEqual("xxx", request.get('x', default="xxx"))
self.assertEqual(None, request.get('x', None))
self.assertEqual(None, request.get('x', default=None))
def test_setter(self):
""" Сеттер добавляет в запрос новый аргумент """
self.request.set('argument', True)
self.assertEqual(True, self.request.get('argument'))
def test_update_from_dictionary(self):
""" Запрос можно обновить данными из словаря """
self.request.update({'a': 1, 'b': 2})
self.assertEqual(1, self.request.get('a'))
self.assertEqual(2, self.request.get('b'))
def test_update_from_non_dictionary(self):
""" Попытка обновить запрос не из словаря вызывает исключение """
self.assertRaises(TypeError, self.request.update, 1)
self.assertRaises(TypeError, self.request.update, [])
def test_missing_argument_with_default_value(self):
""" Запрос отсутствующего аргумента с указанием дефолтного значения возвращает переданное дефолтное значение """
self.assertEqual(2, self.request.get('missing_argument_with_default_value', 2))
def test_missing_argument(self):
""" Запрос отсутствующего аргумента без указания дефолтного значения вызывает исключение """
self.assertRaises(Request.RequiredArgumentIsMissing, self.request.get, 'missing_argument')
def test_override(self):
""" Из нескольких значений аргумента в запросе сохранится последнее переданное """
request = Request({'prop': 1}, {'prop': 2})
self.assertEqual(2, request.get('prop'))
request.set('prop', 3)
self.assertEqual(3, request.get('prop'))
request.update({'prop': 4})
self.assertEqual(4, request.get('prop'))
def test_ajax_type_detection(self):
""" Ajax запрос определяется по заголовку HTTP_X_REQUESTED_WITH """
request = Request(environ={"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"})
self.assertEqual(Request.Types.AJAX, request.type())
def test_pjax_type_detection(self):
""" Pjax запрос определяется по двум заголовкам HTTP_X_REQUESTED_WITH и HTTP_X_PJAX """
request = Request(environ={"HTTP_X_PJAX": True, "HTTP_X_REQUESTED_WITH": "XMLHttpRequest"})
self.assertEqual(Request.Types.PJAX, request.type())
def test_json_rpc_type_detection(self):
""" JsonRPC запрос определяется по наличию аргумента q в запросе и только по нему одному """
request = Request({"q": "{}"})
self.assertEqual(Request.Types.JSON_RPC, request.type())
request = Request({"q": "{}"}, environ={"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"})
self.assertEqual(Request.Types.JSON_RPC, request.type())
def test_static_type_detection(self):
""" Любой запрос не являющийся Ajax, Pjax, Json_RPC является STATIC """
request = Request()
self.assertEqual(Request.Types.STATIC, request.type())
