async def v1_play(request, socket): await socket.send(dumps({'type': 'authorization-request'})) response = Document(loads(await socket.recv())) if not response.event.type == 'authorization-response': await socket.close() if not response.data: await socket.close() if not response.data.token and isinstance(response.data.token, str): await socket.close() token = Document(jwt.decode(response.data.token, secret=PS.secret)) Connections.set_socket_by_character_id(socket, token.data.character.id) socket = Connections.socket_by_character_id(token.data.character.id) socket.disconnect = PS.disconnect Connections.on('reconnect', PS.reconnect) Connections.on('login', PS.login) Connections.on('logout', PS.logout) Connections.on('player-set-location', PS.player_location) Connections.on('player-request-stats', PS.player_request_stats)
async def test_create_type_mismatch(self): #response = await Mixin._create(Document({ # 'json': { # 'data': { # 'type': 'invalid' # } # } #})) decorator = Mixin._check_create(None) response = await decorator(Document({ 'json': { 'data': { 'type': 'invalid' } } })) response = decode(response) self.assertEqual(response.errors[0].detail, 'Provided type does not match resource type.') await Mixin.drop()
async def test_no_data(self): response = await WebToken._post(Document({'json': {}})) response = decode(response) self.assertEqual(response.errors[0].detail, 'No data provided.')
async def test_create_type_missing(self): #response = await Mixin._create(Document({ # 'json': { # 'data': { # 'test': 'ing' # } # } #})) decorator = Mixin._check_create(None) response = await decorator(Document({ 'json': { 'data': { 'test': 'ing' } } })) response = decode(response) self.assertEqual(response.errors[0].detail, 'Type is missing.') await Mixin.drop()
async def test_update_id_mismatch(self): #response = await Mixin._update(Document({ # 'json': { # 'data': { # 'type': 'mixins', # 'id': 'alpha' # } # } #}), 'beta') decorator = Mixin._check_update(None) response = await decorator(Document({ 'json': { 'data': { 'type': 'mixins', 'id': 'alpha' } } }), 'beta') response = decode(response) self.assertEqual(response.errors[0].detail, 'ID provided does not match ID in the URL.')
async def test_read_multiple_no_data_found(self): response = await Mixin._read(Document({ 'args': { } })) response = decode(response) self.assertEqual(len(response.data), 0)
async def test_read_by_id_no_data_found(self): response = await Mixin._read(Document({ 'args': { } }), 'aabbccddeeffaabbccddeeff') response = decode(response) self.assertEqual(response.errors[0].detail, 'No data found.')
async def test_data_not_a_dict(self): response = await WebToken._post(Document({'json': { 'data': 'invalid' }})) response = decode(response) self.assertEqual(response.errors[0].detail, 'Data is not a JSON object.')
async def test_no_password(self): response = await WebToken._post( Document({'json': { 'data': { 'attributes': { 'username': '******' } } }})) response = decode(response) self.assertEqual(response.errors[0].detail, 'Missing password.')
async def test_read_by_id(self): test = Mixin() await test.save() response = await Mixin._read(Document({ 'args': { } }), test.id) response = decode(response) self.assertEqual(response.data.id, test.id) await Mixin.drop()
async def test_no_username(self): response = await WebToken._post( Document( {'json': { 'data': { 'attributes': { 'non-existent': 'value' } } }})) response = decode(response) self.assertEqual(response.errors[0].detail, 'Missing username.')
async def test_read_multiple_query(self): await Mixin.add({ 'field': 'value' }) response = await Mixin._read(Document({ 'args': { 'query': '{ "field": "value" }' } })) response = decode(response) self.assertEqual(response.data[0].attributes.field, 'value') await Mixin.drop()
async def test_read_multiple(self): await Mixin.add([ { }, { }, { } ]) response = await Mixin._read(Document({ 'args': { } })) response = decode(response) self.assertEqual(len(response.data), 3) await Mixin.drop()
async def test_delete_id_missing(self): test = Mixin() await test.save() response = await Mixin._delete(Document({ 'json': { } }), test.id) response = decode(response) self.assertDictEqual(response, { 'data': { 'id': test.id } })
async def test_create_from_json_exception(self): response = await Mixin._create(Document({ 'json': { 'data': { 'type': 'mixins', 'attributes': { 'undefined_field': 'invalid' } } } })) response = decode(response) self.assertEqual(response.errors[0].detail, 'Mixin has undefined fields: undefined_field') await Mixin.drop()
async def test_web_token(self): class Model(MemoryModel): username = Field() password = Field() @classmethod async def find_one(cls, query): for id in cls.db: data = cls.db[id].copy() del data['id'] if data == query: return cls(cls.db[id]) return None class Authentication(WebToken): @classmethod async def payload(cls, username, password): user = await Model.find_one({ 'username': username, 'password': password }) return user.serialize() await Model.add({'username': '******', 'password': '******'}) response = await Authentication._post( Document({ 'json': { 'data': { 'attributes': { 'username': '******', 'password': '******' } } } })) response = decode(response) self.assertTrue(response.data.attributes.token)
async def test_read_multiple_offset(self): await Mixin.add([ { 'field': '1' }, { 'field': '2' }, { 'field': '3'} ]) response = await Mixin._read(Document({ 'args': { 'page[limit]': 1, 'page[offset]': 1, 'sort': 'field' } })) response = decode(response) self.assertEqual(response.data[0].attributes.field, '2') await Mixin.drop()
async def test_read_multiple_sort_descending(self): await Mixin.add([ { 'field': '2' }, { 'field': '1' }, { 'field': '3' } ]) response = await Mixin._read(Document({ 'args': { 'sort': '-field' } })) response = decode(response) count = 3 for data in response.data: self.assertEqual(data.attributes.field, str(count)) count -= 1 await Mixin.drop()
async def test_read_multiple_sort_missing(self): await Mixin.add([ { 'field': '2' }, { 'field': '1' }, { 'field': '3' } ]) response = await Mixin._read(Document({ 'args': { } })) response = decode(response) count = 0 results = [ '2', '1', '3' ] for data in response.data: self.assertEqual(data.attributes.field, results[count]) count += 1 await Mixin.drop()
async def test_update_type_missing(self): #response = await Mixin._update(Document({ # 'json': { # 'data': { # 'non-existent': 'value' # } # } #})) decorator = Mixin._check_update(None) response = await decorator(Document({ 'json': { 'data': { 'non-existent': 'value' } } })) response = decode(response) self.assertEqual(response.errors[0].detail, 'Type is missing.')
async def test_create_id_already_exists(self): test = Mixin() await test.save() response = await Mixin._create(Document({ 'json': { 'data': { 'type': 'mixins', 'id': test.id, 'attributes': { 'field': 'value' } } } })) response = decode(response) self.assertTrue(response.errors[0].detail.endswith('already exists.')) await Mixin.drop()
async def test_update_type_mismatch(self): #response = await Mixin._update(Document({ # 'json': { # 'data': { # 'type': 'invalid' # } # } #})) decorator = Mixin._check_update(None) response = await decorator(Document({ 'json': { 'data': { 'type': 'invalid' } } })) response = decode(response) self.assertEqual(response.errors[0].detail, 'Type in payload does not match collection type.')
async def test_update_id_missing(self): #response = await Mixin._update(Document({ # 'json': { # 'data': { # 'type': 'mixins' # } # } #})) decorator = Mixin._check_update(None) response = await decorator(Document({ 'json': { 'data': { 'type': 'mixins' } } })) response = decode(response) self.assertEqual(response.errors[0].detail, 'ID is missing.')
class TestDocument(TestCase): test_data = { 'alpha': 'a', 'beta': 'b', 'gamma': 'g', 'delta': { 'epsilon': 'e', 'zeta': 'z', }, } def setUp(self): self.doc = Document(self.test_data) def test_getattribute(self): self.assertEqual(self.doc.alpha, 'a') def test_getattribute_nested(self): self.assertEqual(self.doc.delta.zeta, 'z') def test_getattribute_default(self): self.assertIsNone(self.doc.iota) def test_setattr(self): self.doc.theta = 't' self.assertEqual(self.doc.theta, 't') self.assertEqual(self.doc.get('theta'), 't') def test_fromkeys(self): doc = Document.fromkeys(['test', 'ing'], 'value') self.assertDictEqual(doc, {'test': 'value', 'ing': 'value'}) self.assertTrue(isinstance(doc, Document)) def test_get(self): value = self.doc.get('alpha') self.assertEqual(value, self.test_data['alpha']) value = self.doc.get('nonexistent', 'test') self.assertEqual(value, 'test') value = self.doc.get('nonexistent') self.assertIsNone(value) def test_items(self): items = self.doc.items() self.assertEqual(items, [('alpha', 'a'), ('beta', 'b'), ('gamma', 'g'), ('delta', { 'epsilon': 'e', 'zeta': 'z' })]) def test_values(self): values = self.doc.values() self.assertEqual(values, ['a', 'b', 'g', { 'epsilon': 'e', 'zeta': 'z' }]) def test_iteritems(self): iteritems = self.doc.iteritems() self.assertTrue(isgenerator(iteritems)) def test_itervalues(self): itervalues = self.doc.itervalues() self.assertTrue(isgenerator(itervalues)) def test_pop(self): value = self.doc.pop('alpha') self.assertEqual(value, self.test_data['alpha']) value = self.doc.pop('nonexistent', 'test') self.assertEqual(value, 'test') value = self.doc.pop('nonexistent') self.assertIsNone(value) def test_popitem(self): k, v = self.doc.popitem() self.assertIsNotNone(k) self.assertIsNotNone(v) @skip('not tested') def test_viewitems(self): pass @skip('not tested') def test_viewvalues(self): pass
def test_fromkeys(self): doc = Document.fromkeys(['test', 'ing'], 'value') self.assertDictEqual(doc, {'test': 'value', 'ing': 'value'}) self.assertTrue(isinstance(doc, Document))
def setUp(self): self.doc = Document(self.test_data)
def decode(response): return Document(json.loads(response.body.decode()))
async def create(request, token): if not token: error = Error(title='Create Character Error', detail='You are not logged in.', status=403) return jsonapi({"errors": [error.serialize()]}, status=403) token = Document(token) data = request.json.get('data') attributes = data.get('attributes') character = await Character.find_one({'profile': token.data.id}) if character: error = Error(title='Create Character Error', detail='You already have a character.', status=403) return jsonapi({"errors": [error.serialize()]}, status=403) try: character = Character(attributes) except: error = Error(title='Create Character Error', detail='Invalid attributes.', status=403) return jsonapi({"errors": [error.serialize()]}, status=403) character.profile = token.data.id if not character.race in WorldCache.races: error = Error(title='Create Character Error', detail='Invalid race.', status=403) return jsonapi({"errors": [error.serialize()]}, status=403) if not len(character.name.first) > 5: error = Error(title='Create Character Error', detail='Invalid first name.', status=403) return jsonapi({"errors": [error.serialize()]}, status=403) character.level = {'current': 1, 'experience': 0, 'next': 1000} character.attributes = WorldCache.races[character.race]['attributes'] character.health = 0 character.state = { 'target': None, 'hostile': False, 'retaliate': False, 'dead': False, 'casting': False } await character.save() return jsonapi({ 'data': { 'attributes': { 'message': 'Character created.', 'url': f'/v1/characters/{character.id}' } } })