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)