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