def test_set_email_notifications_no_products_in_order(self):
order = models.Order.query.first()
user_buyer = models.User(email=testing_constants.NEW_USER_EMAIL, name=testing_constants.NEW_USER_NAME)
order.user = user_buyer
user_shop_owner = models.User()
models.Customer(user=user_shop_owner)
shop = models.Shop(name=testing_constants.NEW_SHOP_NAME)
shop.owner = user_shop_owner
order.shop = shop
order.shipment_timestamp = date_parser.parse(testing_constants.ORDER_SHIPPED_AT).astimezone(pytz.utc).replace(tzinfo=None)
# The results from the asynchronous tasks are executed immediately
with self.assertRaises(DbException):
order.set_notifications()
def test_valid_user_return_the_user(self):
"""
Com:
- um usuário válido
Quando:
- cadastramos o novo usuário
- invocamos o método: load_user
Verifcamos:
- o retorno é o usuário cadastrado
"""
# with
data = {
'email': '*****@*****.**',
}
# when
new_user = models.User(**data)
dbsql.session.add(new_user)
dbsql.session.commit()
# then
user_from_db = dbsql.session.query(
models.User).filter_by(email=data['email']).first()
user_loaded = models.load_user(user_from_db.id)
self.assertEqual(user_from_db.email, user_loaded.email)
def test_create_user_with_valid_email_only_is_ok(self):
"""
Com:
- email válidos (sem senha)
Quando:
- tentamos criar um novo usuário
Verifcamos:
- que o novo usuário é criado com sucesso
- o campo email_confirmed é falso.
"""
# with
data = {
'email': '*****@*****.**',
}
# when
new_user = models.User(**data)
dbsql.session.add(new_user)
dbsql.session.commit()
# then
user_from_db = dbsql.session.query(
models.User).filter_by(email=data['email']).first()
self.assertIsNotNone(user_from_db)
self.assertEqual(data['email'], user_from_db.email)
self.assertIsNone(user_from_db.password)
self.assertFalse(user_from_db.email_confirmed)
def test_create_user_with_valid_email_and_password_and_confirm_email_is_ok(
self):
"""
Com:
- email e senha válidos
Quando:
- tentamos criar um novo usuário, indicando email_confirmed True
Verifcamos:
- que o novo usuário é criado com sucesso
- o campo email_confirmed é true.
"""
# with
data = {
'email': '*****@*****.**',
'_password': '******',
'email_confirmed': True,
}
# when
new_user = models.User(**data)
dbsql.session.add(new_user)
dbsql.session.commit()
# then
# pegamos o novo registro
user_from_db = dbsql.session.query(
models.User).filter_by(email=data['email']).first()
self.assertIsNotNone(user_from_db)
self.assertEqual(data['email'], user_from_db.email)
self.assertIsNotNone(user_from_db.password)
self.assertTrue(user_from_db.email_confirmed)
def test_set_email_notifications_no_shop(self):
order = models.Order.query.first()
product = models.Product(name=testing_constants.NEW_PRODUCT_NAME, platform_product_id=testing_constants.NEW_PRODUCT_PLATFORM_ID)
user_buyer = models.User(email=testing_constants.NEW_USER_EMAIL, name=testing_constants.NEW_USER_NAME)
order.user = user_buyer
user_shop_owner = models.User()
models.Customer(user=user_shop_owner)
shop = None
product.shop = shop
order.shop = shop
order.products.append(product)
order.shipment_timestamp = date_parser.parse(testing_constants.ORDER_SHIPPED_AT).astimezone(pytz.utc).replace(tzinfo=None)
# The results from the asynchronous tasks are executed immediately
with self.assertRaises(DbException):
order.set_notifications()
def test_get_order_by_id(self):
order = models.Order.query.first()
product = models.Product(name=testing_constants.NEW_PRODUCT_NAME, platform_product_id=testing_constants.NEW_PRODUCT_PLATFORM_ID)
user_buyer = models.User(email=testing_constants.NEW_USER_EMAIL, name=testing_constants.NEW_USER_NAME)
order.user = user_buyer
user_shop_owner = models.User()
models.Customer(user=user_shop_owner)
shop = models.Shop(name=testing_constants.NEW_SHOP_NAME)
shop.owner = user_shop_owner
product.shop = shop
order.shop = shop
order.products.append(product)
order.shipment_timestamp = date_parser.parse(testing_constants.ORDER_SHIPPED_AT).astimezone(pytz.utc).replace(tzinfo=None)
order_id = order.id
db.session.add(order)
db.session.commit()
retrieved_order = models.Order.get_by_id(order_id=order_id)
self.assertTrue(retrieved_order is not None)
self.assertTrue(isinstance(retrieved_order, models.Order))
def test_get_user_by_email(self):
user_buyer = models.User(email=testing_constants.NEW_USER_EMAIL, name=testing_constants.NEW_USER_NAME)
db.session.add(user_buyer)
db.session.commit()
user = models.User.get_by_email(email=testing_constants.NEW_USER_EMAIL)
self.assertEquals(user_buyer.email, user.email)
self.assertEquals(user_buyer.id, user.id)
self.assertEquals(user_buyer.name, user.name)
db.session.delete(user)
db.session.commit()
def pre_post_question(data, *args, **kwargs):
if current_user and current_user.is_authenticated():
data['user_id'] = current_user.id
else:
temp_user_id = data.get('temp_user_id') or session.get('temp_user_id')
if not temp_user_id:
user = models.User()
db.session.add(user)
db.session.commit()
temp_user_id = user.id
session['temp_user_id'] = temp_user_id
data['user_id'] = temp_user_id
def initdb():
#db.drop_all(bind=None)
#db.create_all(bind=None)
user = Models.User()
user.user_name = 'a-ruge'
user.password = '******'
user.type = 'admin'
user.active = True
db.session.add(user)
db.session.commit()
def test_create_review_request(self):
user_buyer = models.User(email=testing_constants.NEW_USER_EMAIL, name=testing_constants.NEW_USER_NAME)
user_shop_owner = models.User(is_shop_owner=True)
order = models.Order()
product = models.Product(name=testing_constants.NEW_PRODUCT_NAME, platform_product_id=testing_constants.NEW_PRODUCT_PLATFORM_ID)
order.user = user_buyer
customer = models.Customer(user=user_shop_owner)
shop = models.Shop(name=testing_constants.NEW_SHOP_NAME)
shop.owner = user_shop_owner
product.shop = shop
order.shop = shop
order.products.append(product)
#creates a review request and returns a token associated with it
review_request_token = models.ReviewRequest.create(to_user=user_buyer, from_customer=customer,
for_product=product, for_shop=shop, for_order=order)
review_request = models.ReviewRequest.query.filter_by(token=review_request_token).first()
self.assertEqual(review_request.token, review_request_token)
self.assertEqual(review_request.for_shop.name, shop.name)
self.assertEqual(review_request.from_customer.user.is_shop_owner, user_shop_owner.is_shop_owner)
def setUpClass(cls):
cls.app = new_app
cls.app.app_context().push()
db.create_all()
cls.SHOP_OWNER_USER = models.User()
shop = models.Shop(owner=cls.SHOP_OWNER_USER)
shop_not_owned = models.Shop()
db.session.add(shop)
db.session.add(shop_not_owned)
db.session.commit()
cls.SHOP_ID = shop.id
cls.SHOP_NOT_OWNED_ID = shop_not_owned.id
def test_set_email_notifications(self):
# setup an order
order = models.Order.query.first()
product = models.Product(name=testing_constants.NEW_PRODUCT_NAME, platform_product_id=testing_constants.NEW_PRODUCT_PLATFORM_ID)
user_buyer = models.User(email=testing_constants.NEW_USER_EMAIL, name=testing_constants.NEW_USER_NAME)
order.user = user_buyer
user_shop_owner = models.User()
models.Customer(user=user_shop_owner)
shop = models.Shop(name=testing_constants.NEW_SHOP_NAME)
shop.owner = user_shop_owner
product.shop = shop
order.shop = shop
order.products.append(product)
order.shipment_timestamp = date_parser.parse(testing_constants.ORDER_SHIPPED_AT).astimezone(pytz.utc).replace(tzinfo=None)
# The results from the asynchronous tasks are executed immediately
order.set_notifications()
self.assertEquals(len(self.outbox), 1)
self.assertEquals(len(self.outbox[0].send_to), 1)
self.assertEquals(self.outbox[0].send_to.pop(), testing_constants.NEW_USER_EMAIL)
self.assertEquals(self.outbox[0].subject, Constants.DEFAULT_REVIEW_SUBJECT %(testing_constants.NEW_USER_NAME.split()[0],
testing_constants.NEW_SHOP_NAME))
self.assertTrue(testing_constants.NEW_USER_NAME.split()[0] in self.outbox[0].body)
self.assertTrue(testing_constants.NEW_PRODUCT_NAME in self.outbox[0].body)
self.assertTrue(testing_constants.NEW_SHOP_NAME in self.outbox[0].body)
order = models.Order.query.first()
expected_notification_ts = date_parser.parse(testing_constants.ORDER_SHIPPED_AT).astimezone(pytz.utc).replace(tzinfo=None) + \
datetime.timedelta(days=Constants.DIFF_SHIPMENT_NOTIFY)
self.assertEquals(order.status, Constants.ORDER_STATUS_NOTIFIED)
self.assertEquals(order.to_notify_timestamp,expected_notification_ts)
self.assertEquals(len(order.tasks), 2)
for task in order.tasks:
self.assertEquals(task.status, 'SUCCESS')
self.assertEquals(task.eta, date_parser.parse('2015-12-16 18:56:26'))
def create_user(user_email, user_password, user_email_confirmed):
"""
Cria um novo usuário, com acesso habilitado para acessar no admin.
O parâmetro: ``user_password`` deve ser a senha em texto plano,
que sera "hasheada" no momento de salvar o usuário.
"""
new_user = models.User(email=user_email,
_password=user_password,
email_confirmed=user_email_confirmed)
new_user.define_password(user_password)
webapp.dbsql.session.add(new_user)
webapp.dbsql.session.commit()
return new_user
def test_create_review_request_repeated_products(self):
order = models.Order.query.first()
user_shop_owner = models.User()
models.Customer(user=user_shop_owner)
shop = models.Shop(name=testing_constants.NEW_SHOP_NAME)
shop.owner = user_shop_owner
order.shop = shop
product1 = models.Product(platform_product_id=testing_constants.NEW_PRODUCT_PLATFORM_ID)
product2 = models.Product(platform_product_id=testing_constants.NEW_PRODUCT_PLATFORM_ID_2)
# add the first product twice
order.products.append(product1)
order.products.append(product1) # not a typo!. << Good to know ;) -- T.
order.products.append(product2)
order.create_review_requests(order.id)
self.assertEquals(len(order.review_requests), 2)
def initdb():
db.drop_all(bind=None)
db.create_all(bind=None)
role = Models.Role()
role.name = 'Administratoren'
db.session.add(role)
db.session.commit()
user = Models.User()
user.first_name = 'Ernesto',
user.last_name = 'Ruge',
user.password = '******',
user.email = "*****@*****.**"
db.session.add(user)
db.session.commit()
def test_is_correct_password_when_user_has_no_password_return_false(self):
"""
Com:
- um usuário sem senha
Quando:
- invocamos o método: is_correct_password com alguma senha
Verifcamos:
- o retorno é true
"""
# with
data = {
'email': '*****@*****.**',
}
# when
new_user = models.User(**data)
# then
self.assertFalse(new_user.is_correct_password('xyz'))
def initdb():
db.drop_all(bind=None)
db.create_all(bind=None)
role = Models.Role()
role.name = 'Administrator'
db.session.add(role)
db.session.commit()
user = Models.User()
user.first_name = 'David'
user.last_name = 'Lackovic'
user.password = '******'
user.email = "*****@*****.**"
user.roles = "Administrator"
db.session.add(user)
db.session.commit()
def test_user_with_email_send_confirmation_email_works(self):
"""
Com:
- um usuário com email
Quando:
- invocamos o método: send_confirmation_email
Verifcamos:
- o retorno da função indica sucesso
"""
# with
data = {
'email': '*****@*****.**',
}
# when
new_user = models.User(**data)
# then
expected_response = (True, '')
self.assertEqual(expected_response, new_user.send_confirmation_email())
def test_user_without_email_send_reset_password_email_works(self):
"""
Com:
- um usuário sem email
Quando:
- invocamos o método: send_reset_password_email
Verifcamos:
- o metodo retorna ValueError
"""
# with
data = {
'email': None,
}
# when
new_user = models.User(**data)
# then
with self.assertRaises(ValueError):
self.assertFalse(new_user.send_reset_password_email())
def test_user_model_unicode_is_the_email(self):
"""
Com:
- email e senha válida
Quando:
- tentamos criar um novo usuário
Verifcamos:
- que o novo usuário tem como __unicode__ o seu email
"""
# with
data = {
'email': '*****@*****.**',
'_password': '******',
}
# when
new_user = models.User(**data)
# then
self.assertEqual(data['email'], new_user.email)
def test_create_user_with_valid_password_only_raise_error(self):
"""
Com:
- email e senha válidos
Quando:
- tentamos criar um novo usuário
Verifcamos:
- da error de integridade.
"""
# with
data = {
'_password': '******',
}
# when
new_user = models.User(**data)
dbsql.session.add(new_user)
# then
with self.assertRaises(IntegrityError):
dbsql.session.commit()
def test_create_user_with_invalid_email_raise_error(self):
"""
Com:
- email do usuário que já existe
Quando:
- tentamos criar um novo usuário
Verifcamos:
- da error de integridade.
"""
# with
data = {
'email': None,
}
# when
new_user = models.User(**data)
dbsql.session.add(new_user)
# then
with self.assertRaises(IntegrityError):
dbsql.session.commit()
def test_is_correct_password_using_different_password_return_false(self):
"""
Com:
- um usuário com email e senha
Quando:
- Criamos um novo usuário
- invocamos o método: is_correct_password com uma senha diferente
Verifcamos:
- o retorno é False
"""
# with
data = {
'email': '*****@*****.**',
'_password': '******',
}
# when
new_user = models.User(**data)
# then
self.assertFalse(new_user.is_correct_password('54321'))
def login_user(self, email=None, password=None, **kwargs):
if not email:
email = f'{random_name()}@{random_name()}.com'
if not password:
password = random_name()
data = dict(email=email, password=password, active=True)
user = models.User(**data)
db.session.add(user)
db.session.commit()
response = self.client.post('/login',
data={
'email': user.email,
'password': user.password
},
follow_redirects=True)
assert len(models.User.query.all()) == 1
user = models.User.query.first()
assert response._status_code == 200
assert flask_login.current_user.email == data['email']
return user
def test_is_correct_password_using_the_same_password_return_true(self):
"""
Com:
- um usuário com email e senha
Quando:
- Criamos um novo usuário
- invocamos o método: is_correct_password com a mesma senha
Verifcamos:
- o retorno é True
"""
# with
data = {
'email': '*****@*****.**',
'_password': '******',
}
# when
new_user = models.User(**data)
new_user.define_password(data['_password'])
# then
self.assertTrue(new_user.is_correct_password(data['_password']))
db.session.add(c2)
c3 = models.Customer.query.filter_by(id=27).first()
c3.stripe_customer_id = "cus_7zxDyPLgVmd09B"
db.session.add(c3)
c4 = models.Customer.query.filter_by(id=34).first()
c4.stripe_customer_id = "cus_7zxFZlJeoLHyE8"
db.session.add(c4)
c5 = models.Customer.query.filter_by(id=35).first()
c5.stripe_customer_id = "cus_7zxGaoutiZyLUX"
db.session.add(c5)
# Create 3 users:
madeline_u = models.User(email="*****@*****.**",
is_shop_owner=True)
madeline_c = models.Customer(user=madeline_u,
stripe_customer_id="cus_8EApEJLklCJFkw")
madeline_s = models.Subscription(customer=madeline_c)
db.session.add(madeline_s)
test_u = models.User(email="*****@*****.**", is_shop_owner=True)
test_c = models.Customer(user=test_u,
stripe_customer_id="cus_8EAt4P3noce59l")
test_s = models.Subscription(customer=test_c)
db.session.add(test_s)
now = datetime.datetime.utcnow()
started = datetime.datetime(2016, 3, 22, 10, 32)
osg_u = models.User(email="*****@*****.**",
is_shop_owner=True,
def test_user_name_valid(self):
user = models.User(name=self.USER_NAME)
review = models.Review.create_for_test(user=user)
self.assertEquals(review.user_name, self.USER_NAME)
