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_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())