def test_success_with_nodes(self): origin = mommy.save_one(Node) destination = mommy.save_one(Node) CreateUniqueArcExample(origin, destination)() has_arc_cmd = HasArcExample(origin, destination) self.assertIsNotNone(has_arc_cmd())
def test_save_payment_arcs_command_mocked(self): command_with_item_forms = Mock() items = [ PagSegItem(description='Python Birds', price=Decimal('18.99'), quantity=3), PagSegItem(description='Objetos Pythônicos', price=Decimal('24.99'), quantity=2, reference=ndb.Key(PagSegItem, 10)) ] command_with_item_forms.items = items ndb.put_multi(items) payment = mommy.save_one(PagSegPayment) command_with_item_forms.result = payment payment_owner = mommy.save_one(Node) save_payment_arcs_cmd = SavePaymentArcsCmd(payment_owner) CommandSequential(command_with_item_forms, save_payment_arcs_cmd).execute() self.assertEqual(payment, pagseguro_facade.search_payments(payment_owner)()[0]) logs = SearchLogs(payment)() self.assertEqual(1, len(logs)) self.assertEqual(STATUS_CREATED, logs[0].status) self.assertListEqual(items, SearchItems(payment)())
def test_create_single_arc_for_second_time_error(self): destination = mommy.save_one(Node) origin = mommy.save_one(Node) cmd = CreateSingleArcExample(origin, destination) self.assert_arc_creation(cmd, origin, destination) cmd = CreateSingleArcExample(origin, destination) self.assertRaises(CommandExecutionException, cmd)
def test_success(self): mommy.save_one(Evento) mommy.save_one(Evento) json_response = rest.index() context = json_response.context self.assertEqual(2, len(context)) evento_dct = context[0] self.assertSetEqual(set(['id', 'creation', 'start', 'end', 'description', 'title']), set(evento_dct.iterkeys())) self.assert_can_serialize_as_json(json_response)
def test_success(self): mommy.save_one(Profile) mommy.save_one(Profile) json_response = rest.index() context = json_response.context self.assertEqual(2, len(context)) profile_dct = context[0] self.assertSetEqual(set(['id', 'creation', 'user', 'tipo']), set(profile_dct.iterkeys())) self.assert_can_serialize_as_json(json_response)
def test_success(self): mommy.save_one(Produto) mommy.save_one(Produto) json_response = rest.index() context = json_response.context self.assertEqual(2, len(context)) produto_dct = context[0] self.assertSetEqual(set(['id', 'creation', ]), set(produto_dct.iterkeys())) self.assert_can_serialize_as_json(json_response)
def test_success(self): mommy.save_one(Categoria) mommy.save_one(Categoria) json_response = rest.index() context = json_response.context self.assertEqual(2, len(context)) categoria_dct = context[0] self.assertSetEqual(set(['id', 'creation', 'codigo', 'nome']), set(categoria_dct.iterkeys())) self.assert_can_serialize_as_json(json_response)
def test_success(self): mommy.save_one(Noticia) mommy.save_one(Noticia) json_response = rest.index() context = json_response.context self.assertEqual(2, len(context)) noticia_dct = context[0] self.assertSetEqual(set(['id', 'creation', 'content', 'link', 'title']), set(noticia_dct.iterkeys())) self.assert_can_serialize_as_json(json_response)
def test_success(self): mommy.save_one(Membro) mommy.save_one(Membro) json_response = rest.index() context = json_response.context self.assertEqual(2, len(context)) membro_dct = context[0] self.assertSetEqual(set(['id', 'creation', 'cargo', 'nome', 'cpf', 'rg', 'telefone', 'endereco', 'data']), set(membro_dct.iterkeys())) self.assert_can_serialize_as_json(json_response)
def test_success(self): mommy.save_one(Licao) mommy.save_one(Licao) json_response = rest.index() context = json_response.context self.assertEqual(2, len(context)) licao_dct = context[0] self.assertSetEqual(set(['id', 'creation', 'titulo', 'descricao', 'tema']), set(licao_dct.iterkeys())) self.assert_can_serialize_as_json(json_response)
def test_success(self): mommy.save_one(User) mommy.save_one(User) json_response = rest.index() context = json_response.context self.assertEqual(2, len(context)) user_dct = context[0] self.assertSetEqual(set(['id', 'creation', 'password']), set(user_dct.iterkeys())) self.assert_can_serialize_as_json(json_response)
def test_success(self): mommy.save_one(Formacao) mommy.save_one(Formacao) json_response = rest.index() context = json_response.context self.assertEqual(2, len(context)) formacao_dct = context[0] self.assertSetEqual(set(['id', 'creation', 'titulo', 'data', 'conteudo']), set(formacao_dct.iterkeys())) self.assert_can_serialize_as_json(json_response)
def test_success(self): mommy.save_one(Jogo) mommy.save_one(Jogo) json_response = rest.index() context = json_response.context self.assertEqual(2, len(context)) jogo_dct = context[0] self.assertSetEqual(set(['id', 'creation', 'foto', 'tmp', 'map', 'qtd', 'tit', 'grp']), set(jogo_dct.iterkeys())) self.assert_can_serialize_as_json(json_response)
def test_success(self): mommy.save_one(Venda) mommy.save_one(Venda) json_response = rest.index() context = json_response.context self.assertEqual(2, len(context)) venda_dct = context[0] self.assertSetEqual(set(['id', 'creation', 'preco','status']), set(venda_dct.iterkeys())) self.assert_can_serialize_as_json(json_response)
def test_only_destination_has_arc(self): origin = mommy.save_one(Node) destination = mommy.save_one(Node) another_origin = mommy.save_one(Node) arc = CreateArcExample(origin, destination)() self.assertEqual(arc.key, HasArcExample(origin=origin)()) self.assertEqual(arc.key, HasArcExample(destination=destination)()) self.assertEqual(arc.key, HasArcExample(origin, destination)()) self.assertIsNone(HasArcExample(another_origin, destination)())
def test_success(self): mommy.save_one(Lesson) mommy.save_one(Lesson) json_response = lessons.index() context = json_response.context self.assertEqual(2, len(context)) lesson_dct = context[0] self.assertSetEqual(set(['id', 'creation', 'description', 'title']), set(lesson_dct.iterkeys())) self.assert_can_serialize_as_json(json_response)
def test_delete(self): model = mommy.save_one(ModelStub) self.assertIsNotNone(model.key.get()) DeleteCommand(model.key).execute() self.assertIsNone(model.key.get()) models = [mommy.save_one(ModelStub) for i in range(3)] model_keys = [m.key for m in models] self.assertListEqual(models, ndb.get_multi(model_keys)) DeleteCommand(*model_keys).execute() self.assertListEqual([None, None, None], ndb.get_multi(model_keys))
def setup_call_stat(self, LoginClassMock): login_obj = Login(None, None, None, None) main_user = mommy.save_one(MainUser, email='*****@*****.**') login_obj.result = main_user login_obj.set_up = Mock() login_obj.do_business = Mock() login_obj.commit = lambda: None LoginClassMock.return_value = login_obj external_user = mommy.save_one(GoogleUser) pending_key = PendingExternalToMainUser(external_user=external_user.key, main_user=main_user.key).put() return external_user, main_user, pending_key
def test_create_arc_with_commands(self): destination = mommy.save_one(Node) origin = mommy.save_one(Node) cmd = CreateArcExample(NodeSearch(origin), destination) self.assert_arc_creation(cmd, origin, destination) cmd = CreateArcExample(origin, NodeSearch(destination)) self.assert_arc_creation(cmd, origin, destination) cmd = CreateArcExample(NodeSearch(origin), NodeSearch(destination)) self.assert_arc_creation(cmd, origin, destination)
def test_has_arc(self): origin = mommy.save_one(Node) destination = mommy.save_one(Node) arc = CreateArcExample(origin, destination)() has_arc_cmd = HasArcExample(origin=origin) self.assertEqual(arc.key, has_arc_cmd()) has_arc_cmd = HasArcExample(destination=destination) self.assertEqual(arc.key, has_arc_cmd()) has_arc_cmd = HasArcExample(origin, destination) self.assertEqual(arc.key, has_arc_cmd())
def test_success_with_nodes(self): origin = mommy.save_one(Node) destination = mommy.save_one(Node) CreateSingleOriginArcExample(origin, destination)() has_arc_command = HasArcExample(origin, destination) self.assertIsNotNone(has_arc_command()) another_origin = mommy.save_one(Node) create_single_origin_cmd = CreateSingleOriginArcExample(another_origin, destination) self.assertRaises(CommandExecutionException, create_single_origin_cmd) has_arc_command = HasArcExample(another_origin, destination) self.assertIsNone(has_arc_command())
def test_detail(self): resp = Mock() user = permission_facade.save_user_cmd('*****@*****.**', 'Renzo')() site = mommy.save_one(Site, domain='pswdless.appspost.com') login = mommy.save_one(Login, status=LOGIN_CLICK, hook='https://pswdless.appspost.com') CreateLoginArc(login, user)() response = rest.detail(resp, app_id=site.key.id(), token=site.token, ticket=login.key.id()) status = login.key.get().status self.assertEqual(LOGIN_DETAIL, status) self.assertNotEqual(400, resp.status_code) self.assert_can_serialize_as_json(response)
def test_another_node_deletion(self): not_another_node = mommy.save_one(Node) cmd = DeleteNodeExample(not_another_node) self.assertRaises(CommandExecutionException, cmd.execute) self.assertDictEqual({'node_error': "%s should be AnotherNode instance" % not_another_node.key}, cmd.errors) self.assertIsNotNone(not_another_node.key.get())
def test_delete_node_creating_node_key(self): nodes = [mommy.save_one(NodeStub) for i in range(3)] node_keys = [n.key for n in nodes] self.assertListEqual(node_keys, DeleteNode(*node_keys).model_keys) self.assertListEqual(node_keys, DeleteNode(*[k.id() for k in node_keys]).model_keys) self.assertListEqual(node_keys, DeleteNode(*[unicode(k.id()) for k in node_keys]).model_keys) self.assertListEqual(node_keys, DeleteNode(*nodes).model_keys)
def test_success(self, UrlFetchClassMock): # Pre conditions pagseguro_facade.create_or_update_access_data_cmd( '*****@*****.**', 'abc123')() payment = mommy.save_one(PagSegPayment, code=None, net_amount=None, status=STATUS_SENT_TO_PAGSEGURO) # Mocking fetch fetch_cmd_obj = Mock() fetch_cmd_obj.result.content = generate_xml(payment.key.id(), '2', '18.99') UrlFetchClassMock.return_value = fetch_cmd_obj # Command execution cmd = FetchNotificationDetail('12345') cmd() # Assertions UrlFetchClassMock.assert_called_once_with( 'https://ws.pagseguro.uol.com.br/v3/transactions/notifications/12345?token=abc123&email=foo%40bar.com' ) self.assertEqual(cmd.result, str(payment.key.id())) self.assertEqual(cmd.code, CODE) self.assertEqual(cmd.net_amount, '18.99') self.assertEqual( cmd.status, STATUS_ANALYSIS) # status respective to number 2 coming from xml
def test_relations(self): node = mommy.save_one(Node) destinations = [mommy.save_one(Node) for i in range(3)] for d in destinations: CreateArcStub(node, d).execute() single = mommy.save_one(Node) CreateArcStub(single, node).execute() result = NodeSearchWithRelations(node)() self.assertRaises(AttributeError, lambda: result.destinations) self.assertRaises(AttributeError, lambda: result.single) result = NodeSearchWithRelations(node, relations=['destinations'])() self.assertEqual(destinations, result.destinations) self.assertRaises(AttributeError, lambda: result.single) result = NodeSearchWithRelations(node, relations=['destinations', 'single'])() self.assertEqual(destinations, result.destinations) self.assertEqual(single, result.single)
def test_save_item_arcs_command(self): command_with_item_forms = Mock() access_data = CreateOrUpdateAccessData('*****@*****.**', 'abc1234')() items = [PagSegItem(description='Python Birds', price=Decimal('18.99'), quantity=3), PagSegItem(description='Objetos Pythônicos', price=Decimal('24.99'), quantity=2, reference=ndb.Key(PagSegItem, 10))] command_with_item_forms.items = items address_form_mock = Mock() client_form_mock = Mock() command_with_item_forms.address_form = address_form_mock command_with_item_forms.client_form = client_form_mock command_with_item_forms.access_data = access_data ndb.put_multi(items) payment = mommy.save_one(PagSegPayment) command_with_item_forms.result = payment save_payment_to_items_arcs_cmd = SavePaymentToItemsArcs() CommandSequential(command_with_item_forms, save_payment_to_items_arcs_cmd).execute() self.assertListEqual(items, SearchItems(payment)()) self.assertListEqual(items, save_payment_to_items_arcs_cmd.items) # Data used for sequential commands self.assertEqual('*****@*****.**', save_payment_to_items_arcs_cmd.access_data.email) self.assertEqual('abc1234', save_payment_to_items_arcs_cmd.access_data.token) self.assertEqual(save_payment_to_items_arcs_cmd.address_form, address_form_mock) self.assertEqual(save_payment_to_items_arcs_cmd.client_form, client_form_mock)
def test_success_with_passwordless_user(self, fetch_command_cls, write_cookie): app, fetch_cmd_obj, response = self.setup_base_mock(fetch_command_cls) main_user_on_db = mommy.save_one(MainUser, email="*****@*****.**") p_user_on_db = mommy.save_one(PasswordlessUser, external_id="654321") ExternalToMainUser(origin=p_user_on_db.key, destination=main_user_on_db.key).put() main_user = facade.login_passwordless('0123', response, 'https://pswdless.appspot.com/rest/detail').execute().result self.assertEqual(main_user_on_db, main_user) p_user = PasswordlessUser.query().get() self.assertEqual(p_user_on_db, p_user) self.assert_base_execution(app, fetch_cmd_obj, fetch_command_cls, main_user, p_user, write_cookie, response)
def test_non_profile_deletion(self): non_profile = mommy.save_one(Node) response = Mock() json_response = rest.delete(response, non_profile.key.id()) self.assertIsNotNone(non_profile.key.get()) self.assertEqual(500, response.status_code) self.assert_can_serialize_as_json(json_response)
def test_non_jogo_deletion(self): non_jogo = mommy.save_one(Node) mock_resp = Mock() json_response = rest.delete(mock_resp, non_jogo.key.id()) self.assertIsNotNone(non_jogo.key.get()) self.assertEqual(500, mock_resp.status_code) self.assert_can_serialize_as_json(json_response)
def test_query_email_starts_with(self): users_ordered_by_unicode = [mommy.save_one(MainUser, email='*****@*****.**' % b) for b in 'a b c'.split(' ')] db_users = MainUser.query_email_starts_with().fetch() self.assertListEqual(users_ordered_by_unicode, db_users) db_users = MainUser.query_email_starts_with('a').fetch() self.assertListEqual(users_ordered_by_unicode[:1], db_users) db_users = MainUser.query_email_starts_with('aa@').fetch() self.assertListEqual([], db_users) abc_user = mommy.save_one(MainUser, email='*****@*****.**') db_users = MainUser.query_email_starts_with('aa').fetch() self.assertListEqual([], db_users) db_users = MainUser.query_email_starts_with('ab').fetch() self.assertListEqual([abc_user], db_users)
def test_non_course_deletion(self): non_course = mommy.save_one(Node) response = Mock() json_response = rest.delete(response, non_course.key.id()) self.assertIsNotNone(non_course.key.get()) self.assertEqual(500, response.status_code) self.assert_can_serialize_as_json(json_response)
def test_admin_group(self): @permissions('ADMIN') def adm(): self.executed_adm = True user = mommy.save_one(MainUser) self.assertFalse(has_permission(user, adm)) user = mommy.save_one(MainUser, groups=['MANAGER']) self.assertFalse(has_permission(user, adm)) user = mommy.save_one(MainUser, groups=['ADMIN']) self.assertTrue(has_permission(user, adm)) user = mommy.save_one(MainUser, groups=['ADMIN', 'MANAGER']) self.assertTrue(has_permission(user, adm))
def test_error(self): book = mommy.save_one(Book) old_properties = book.to_dict() template_response = save(book.key.id()) errors = template_response.context['errors'] self.assertSetEqual(set([]), set(errors.keys())) self.assertEqual(old_properties, book.key.get().to_dict()) self.assert_can_render(template_response)
def test_success(self): book = mommy.save_one(Book) old_properties = book.to_dict() redirect_response = save(book.key.id(), ) self.assertIsInstance(redirect_response, RedirectResponse) edited_book = book.key.get() self.assertNotEqual(old_properties, edited_book.to_dict())
def test_error(self): categoria = mommy.save_one(Categoria) old_properties = categoria.to_dict() template_response = save(categoria.key.id()) errors = template_response.context['errors'] self.assertSetEqual(set(['codigo', 'nome']), set(errors.keys())) self.assertEqual(old_properties, categoria.key.get().to_dict()) self.assert_can_render(template_response)
def test_success(self): servico = mommy.save_one(Servico) old_properties = servico.to_dict() redirect_response = save(servico.key.id(), ) self.assertIsInstance(redirect_response, RedirectResponse) edited_servico = servico.key.get() self.assertNotEqual(old_properties, edited_servico.to_dict())
def test_error(self): produto = mommy.save_one(Produto) old_properties = produto.to_dict() template_response = save(produto.key.id()) errors = template_response.context['errors'] self.assertSetEqual(set([]), set(errors.keys())) self.assertEqual(old_properties, produto.key.get().to_dict()) self.assert_can_render(template_response)
def test_success(self): peca = mommy.save_one(Peca) old_properties = peca.to_dict() json_response = rest.edit(None, peca.key.id(), titulo='titulo_string') db_peca = peca.key.get() self.assertEquals('titulo_string', db_peca.titulo) self.assertNotEqual(old_properties, db_peca.to_dict()) self.assert_can_serialize_as_json(json_response)
def test_success(self): course = mommy.save_one(Course) old_properties = course.to_dict() json_response = rest.edit(None, course.key.id(), nome='nome_string') db_course = course.key.get() self.assertEquals('nome_string', db_course.nome) self.assertNotEqual(old_properties, db_course.to_dict()) self.assert_can_serialize_as_json(json_response)
def test_success(self): produto = mommy.save_one(Produto) old_properties = produto.to_dict() json_response = rest.edit(None, produto.key.id(), ) db_produto = produto.key.get() self.assertNotEqual(old_properties, db_produto.to_dict()) self.assert_can_serialize_as_json(json_response)
def test_success(self): peca = mommy.save_one(Peca) old_properties = peca.to_dict() redirect_response = save(peca.key.id(), titulo='titulo_string') self.assertIsInstance(redirect_response, RedirectResponse) edited_peca = peca.key.get() self.assertEquals('titulo_string', edited_peca.titulo) self.assertNotEqual(old_properties, edited_peca.to_dict())
def test_success(self): course = mommy.save_one(Course) old_properties = course.to_dict() redirect_response = save(course.key.id(), nome='nome_string') self.assertIsInstance(redirect_response, RedirectResponse) edited_course = course.key.get() self.assertEquals('nome_string', edited_course.nome) self.assertNotEqual(old_properties, edited_course.to_dict())
def test_error(self): course = mommy.save_one(Course) old_properties = course.to_dict() template_response = save(course.key.id()) errors = template_response.context['errors'] self.assertSetEqual(set(['nome']), set(errors.keys())) self.assertEqual(old_properties, course.key.get().to_dict()) self.assert_can_render(template_response)
def test_error(self): profile = mommy.save_one(Profile) old_properties = profile.to_dict() template_response = save(profile.key.id()) errors = template_response.context['errors'] self.assertSetEqual(set(['user', 'tipo']), set(errors.keys())) self.assertEqual(old_properties, profile.key.get().to_dict()) self.assert_can_render(template_response)
def test_error(self): peca = mommy.save_one(Peca) old_properties = peca.to_dict() template_response = save(peca.key.id()) errors = template_response.context['errors'] self.assertSetEqual(set(['titulo']), set(errors.keys())) self.assertEqual(old_properties, peca.key.get().to_dict()) self.assert_can_render(template_response)
def test_error(self): lesson = mommy.save_one(Lesson) old_properties = lesson.to_dict() template_response = save(lesson.key.id()) errors = template_response.context['errors'] self.assertSetEqual(set(['description', 'title']), set(errors.keys())) self.assertEqual(old_properties, lesson.key.get().to_dict()) self.assert_can_render(template_response)
def test_success(self): categoria = mommy.save_one(Categoria) old_properties = categoria.to_dict() redirect_response = save(categoria.key.id(), codigo='1', nome='nome_string') self.assertIsInstance(redirect_response, RedirectResponse) edited_categoria = categoria.key.get() self.assertEquals(1, edited_categoria.codigo) self.assertEquals('nome_string', edited_categoria.nome) self.assertNotEqual(old_properties, edited_categoria.to_dict())
def test_user_arc_creation(self): # Payment creation user = mommy.save_one(MainUser, email='*****@*****.**') cmd = pagseguro_facade.procces_external_payment_cmd( generate_xml('non particular id', '1', '18.99')) cmd() payments = pagseguro_facade.search_all_payments(relations=['owner'])() self.assertEqual(1, len(payments)) self.assertEqual(user, payments[0].owner)
def test_error(self): licao = mommy.save_one(Licao) old_properties = licao.to_dict() template_response = save(licao.key.id()) errors = template_response.context['errors'] self.assertSetEqual(set(['titulo', 'descricao', 'tema']), set(errors.keys())) self.assertEqual(old_properties, licao.key.get().to_dict()) self.assert_can_render(template_response)
def teste_com_erros_validacao(self): usuario = mommy.save_one(MainUser) salvar_cmd = pecas_facade.save_peca_cmd() self.assertRaises(CommandExecutionException, salvar_cmd) erros = salvar_cmd.errors self.assertIn('title', erros) self.assertIn('price', erros) self.assertIn('amount', erros)
def test_error(self): licao = mommy.save_one(Licao) old_properties = licao.to_dict() resp = Mock() json_response = rest.edit(resp, licao.key.id()) errors = json_response.context self.assertEqual(500, resp.status_code) self.assertSetEqual(set(['titulo', 'descricao', 'tema']), set(errors.keys())) self.assertEqual(old_properties, licao.key.get().to_dict()) self.assert_can_serialize_as_json(json_response)
def test_error(self): course = mommy.save_one(Course) old_properties = course.to_dict() resp = Mock() json_response = rest.edit(resp, course.key.id()) errors = json_response.context self.assertEqual(500, resp.status_code) self.assertSetEqual(set(['nome']), set(errors.keys())) self.assertEqual(old_properties, course.key.get().to_dict()) self.assert_can_serialize_as_json(json_response)
def test_error(self): membro = mommy.save_one(Membro) old_properties = membro.to_dict() template_response = save(membro.key.id()) errors = template_response.context['errors'] self.assertSetEqual( set(['cargo', 'nome', 'cpf', 'rg', 'telefone', 'endereco', 'data']), set(errors.keys())) self.assertEqual(old_properties, membro.key.get().to_dict()) self.assert_can_render(template_response)
def test_success(self): licao = mommy.save_one(Licao) old_properties = licao.to_dict() json_response = rest.edit(None, licao.key.id(), titulo='titulo_string', descricao='descricao_string', tema='tema_string') db_licao = licao.key.get() self.assertEquals('titulo_string', db_licao.titulo) self.assertEquals('descricao_string', db_licao.descricao) self.assertEquals('tema_string', db_licao.tema) self.assertNotEqual(old_properties, db_licao.to_dict()) self.assert_can_serialize_as_json(json_response)