def test_update_sales_order_status_not_allowed(self):
from psi.app.models import EnumValues
def test_logic():
fixture.login_as_admin(self.test_client)
user, password = object_faker.user(role_names=[
'franchise_sales_order_create',
'franchise_sales_order_view',
'franchise_sales_order_edit',
'product_view'
])
sales_order = object_faker.sales_order(creator=user,
number_of_line=1)
shipped_status = EnumValues.get(SO_SHIPPED_STATUS_KEY)
sales_order.status = shipped_status
db_util.save_objects_commit(sales_order, user)
so_id = sales_order.id
fixture.login_user(self.test_client, user.email, password)
rv = self.test_client.put('/api/sales_order/' + str(so_id),
follow_redirects=True,
data=dict(status_id=shipped_status.id))
self.assertEqual(rv.status_code, 201)
self.assertIn(b'message', rv.data)
self.assertIn(b'Status update not allowed', rv.data)
run_as_admin(self.test_client, test_logic)
def test_update_sales_order_shipped_status_success(self):
from psi.app.models import EnumValues, SalesOrder
def test_logic():
fixture.login_as_admin(self.test_client)
user, password = object_faker.user(role_names=[
'franchise_sales_order_create',
'franchise_sales_order_view',
'franchise_sales_order_edit',
'product_view'
])
franchise_so_type = EnumValues.get(FRANCHISE_SO_TYPE_KEY)
sales_order = object_faker.sales_order(creator=user,
number_of_line=1,
type=franchise_so_type)
db_util.save_objects_commit(sales_order, user)
so_id = sales_order.id
shipped_status = EnumValues.get(SO_SHIPPED_STATUS_KEY)
fixture.login_user(self.test_client, user.email, password)
rv = self.test_client.put('/api/sales_order/' + str(so_id),
follow_redirects=True,
data=dict(status_id=shipped_status.id))
self.assertIn(b'message', rv.data)
self.assertIn(b'Status update successfully', rv.data)
self.assertEqual(rv.status_code, 200)
so_from_db = Info.get_db().session.query(SalesOrder).get(so_id)
self.assertIsNotNone(so_from_db)
self.assertEquals(SO_SHIPPED_STATUS_KEY, so_from_db.status.code)
run_as_admin(self.test_client, test_logic)
def test_update_sales_order_status_not_allowed(self):
from psi.app.models import EnumValues
def test_logic():
fixture.login_as_admin(self.test_client)
user, password = object_faker.user(role_names=[
'franchise_sales_order_create',
'franchise_sales_order_view',
'franchise_sales_order_edit',
'product_view'
])
sales_order = object_faker.sales_order(creator=user,
number_of_line=1)
shipped_status = EnumValues.get(SO_SHIPPED_STATUS_KEY)
sales_order.status = shipped_status
db_util.save_objects_commit(sales_order, user)
so_id = sales_order.id
fixture.login_user(self.test_client, user.email, password)
rv = self.test_client.put('/api/sales_order/' + str(so_id),
follow_redirects=True,
data=dict(status_id=shipped_status.id))
self.assertEqual(rv.status_code, 201)
self.assertIn('message', rv.data)
self.assertIn('Status update not allowed', rv.data)
run_as_admin(self.test_client, test_logic)
def test_direct_purchase_order_pages(self):
from psi.app.models.enum_values import EnumValues
def test_logic():
supplier = object_faker.supplier()
db_util.save_objects_commit(supplier)
self.assertPageRendered(endpoint=url_for('dpo.index_view'))
self.assertPageRendered(endpoint=url_for('dpo.create_view'))
draft_status = EnumValues.get(const.PO_DRAFT_STATUS_KEY)
order_date = object_faker.faker.date_time_this_year()
logistic_amount = random.randint(0, 100)
remark = object_faker.faker.text(max_nb_chars=50)
expect_content = [
supplier.name, draft_status.display,
str(logistic_amount),
order_date.strftime("%Y-%m-%d"), remark
]
self.assertPageRendered(method=self.test_client.post,
data=dict(supplier=supplier.id,
status=draft_status.id,
order_date=order_date,
logistic_amount=logistic_amount,
remark=remark),
endpoint=self.create_endpoint(view='dpo'),
expect_contents=expect_content)
self.assertPageRendered(expect_contents=expect_content,
endpoint=self.edit_endpoint(view='dpo'))
new_remark = object_faker.faker.text(max_nb_chars=50)
new_logistic_amount = random.randint(0, 100)
new_order_date = object_faker.faker.date_time_this_year()
new_expect_content = [
supplier.name, draft_status.display,
str(new_logistic_amount),
new_order_date.strftime("%Y-%m-%d"), new_remark
]
self.assertPageRendered(method=self.test_client.post,
endpoint=self.edit_endpoint(view='dpo'),
data=dict(
supplier=supplier.id,
status=draft_status.id,
order_date=new_order_date,
logistic_amount=new_logistic_amount,
remark=new_remark),
expect_contents=new_expect_content)
rv = self.assertPageRendered(method=self.test_client.post,
endpoint=url_for('dpo.delete_view'),
data=dict(
url=url_for('dpo.index_view'),
id='1'))
self.assertNotIn(supplier.name.encode('utf-8'), rv.data)
self.assertNotIn(draft_status.display.encode('utf-8'), rv.data)
self.assertNotIn(
new_order_date.strftime("%Y-%m-%d").encode('utf-8'), rv.data)
self.assertNotIn(new_remark.encode('utf-8'), rv.data)
run_as_admin(self.test_client, test_logic)
def test_update_sales_order_shipped_status_success(self):
from psi.app.models import EnumValues, SalesOrder
def test_logic():
fixture.login_as_admin(self.test_client)
user, password = object_faker.user(role_names=[
'franchise_sales_order_create', 'franchise_sales_order_view',
'franchise_sales_order_edit', 'product_view'
])
franchise_so_type = EnumValues.get(FRANCHISE_SO_TYPE_KEY)
sales_order = object_faker.sales_order(creator=user,
number_of_line=1,
type=franchise_so_type)
db_util.save_objects_commit(sales_order, user)
so_id = sales_order.id
shipped_status = EnumValues.get(SO_SHIPPED_STATUS_KEY)
fixture.login_user(self.test_client, user.email, password)
rv = self.test_client.put('/api/sales_order/' + str(so_id),
follow_redirects=True,
data=dict(status_id=shipped_status.id))
self.assertIn(b'message', rv.data)
self.assertIn(b'Status update successfully', rv.data)
self.assertEqual(rv.status_code, 200)
so_from_db = Info.get_db().session.query(SalesOrder).get(so_id)
self.assertIsNotNone(so_from_db)
self.assertEquals(SO_SHIPPED_STATUS_KEY, so_from_db.status.code)
run_as_admin(self.test_client, test_logic)
def test_open_dashboard(self):
def test_logic():
rv = self.test_client.get('/admin')
self.assertEqual(301, rv.status_code)
rv = self.test_client.get('/admin/')
self.assertAlmostEquals('utf-8', rv.charset)
self.assertEqual(200, rv.status_code)
run_as_admin(self.test_client, test_logic)
def test_purchase_price_show_and_hidden_detail_page(self):
from tests.fixture import run_as_admin
user, password = object_faker.user(role_names=[
'purchase_price_view', 'direct_purchase_order_view', 'product_view'
])
po = object_faker.purchase_order(number_of_line=1, creator=user)
po_url = url_for('dpo.details_view', id=po.id)
product_url = url_for('product.details_view', id=po.lines[0].product.id)
run_as_admin(self.test_client, self.logic_for_detail_edit_page, user, password, po, po_url, product_url)
def test_delete_completed_receiving_not_allowed(self):
from psi.app.models.enum_values import EnumValues
from psi.app.utils import db_util
def test_logic():
type = EnumValues.get(DIRECT_PO_TYPE_KEY)
status = EnumValues.get(PO_ISSUED_STATUS_KEY)
draft_status = EnumValues.get(RECEIVING_DRAFT_STATUS_KEY)
date = object_faker.faker.date_time_this_year()
po = object_faker.purchase_order(number_of_line=2,
type=type,
status=status)
db_util.save_objects_commit(po)
remark = object_faker.faker.text(max_nb_chars=50)
# Crete new receiving
self.assertPageRendered(
method=self.test_client.post,
data=dict(purchase_order=po.id,
status=draft_status.id,
create_lines='y',
date=date,
remark=remark),
endpoint=self.create_endpoint(view='receiving'),
)
# Change status to complete
new_remark = object_faker.faker.text(max_nb_chars=50)
new_receive_date = object_faker.faker.date_time_this_year()
complete_status = EnumValues.get(RECEIVING_COMPLETE_STATUS_KEY)
self.assertPageRendered(
method=self.test_client.post,
endpoint=self.edit_endpoint(view='receiving'),
data=dict(date=new_receive_date,
status=complete_status.id,
remark=new_remark),
)
# Should not delete existing receiving with complete status
endpoint = url_for('receiving.delete_view', id='1')
data = dict(url=url_for('receiving.index_view'), id='1')
rv = self.assertPageRendered(method=self.test_client.post,
endpoint=endpoint,
data=data)
self.assertIn(complete_status.display, rv.data)
self.assertIn(new_receive_date.strftime("%Y-%m-%d"), rv.data)
self.assertIn(new_remark, rv.data)
self.assertIn(po.supplier.name, rv.data)
self.assertIn(po.order_date.strftime("%Y-%m-%d"), rv.data)
self.assertIn(po.remark, rv.data)
self.assertIn(
'Receiving document can not be update nor delete on complete status',
rv.data)
run_as_admin(self.test_client, test_logic)
def test_open_dashboard(self):
def test_logic():
rv = self.test_client.get('/admin')
self.assertEqual(301, rv.status_code)
rv = self.test_client.get('/admin/')
self.assertAlmostEquals('utf-8', rv.charset)
self.assertEqual(200, rv.status_code)
run_as_admin(self.test_client, test_logic)
def test_receiving_pages(self):
from psi.app.models.enum_values import EnumValues
from psi.app.utils import db_util
def test_logic():
type = EnumValues.get(DIRECT_PO_TYPE_KEY)
status = EnumValues.get(PO_ISSUED_STATUS_KEY)
receiving_status = EnumValues.get(RECEIVING_DRAFT_STATUS_KEY)
date = object_faker.faker.date_time_this_year()
po = object_faker.purchase_order(number_of_line=2, type=type, status=status)
db_util.save_objects_commit(po)
remark = object_faker.faker.text(max_nb_chars=50)
list_expect = [receiving_status.display, date.strftime("%Y-%m-%d"), remark,
po.supplier.name, po.order_date.strftime("%Y-%m-%d"),
po.remark]
edit_expect = [receiving_status.display, date.strftime("%Y-%m-%d"), remark,]
# Crete new receiving
self.assertPageRendered(method=self.test_client.post,
data=dict(purchase_order=po.id,
status=receiving_status.id,
create_lines='y',
date=date, remark=remark),
endpoint=self.create_endpoint(view='receiving'),
expect_contents=list_expect)
self.assertPageRendered(expect_contents=edit_expect,
endpoint=self.edit_endpoint(view='receiving'))
# Edit existing receiving
new_remark = object_faker.faker.text(max_nb_chars=50)
new_receive_date = object_faker.faker.date_time_this_year()
complete_status = EnumValues.get(RECEIVING_COMPLETE_STATUS_KEY)
new_expected = [complete_status.display, new_receive_date.strftime("%Y-%m-%d"),
new_remark, po.supplier.name, po.order_date.strftime("%Y-%m-%d"),
po.remark]
self.assertPageRendered(method=self.test_client.post,
endpoint=self.edit_endpoint(view='receiving'),
data=dict(date=new_receive_date,
status=complete_status.id,
remark=new_remark),
expect_contents=new_expected)
# Detail page
self.assertPageRendered(method=self.test_client.get,
endpoint=self.details_endpoint(view='receiving'),
expect_contents=new_expected)
run_as_admin(self.test_client, test_logic)
def test_delete_complete_receiving_not_allowed(self):
def test_logic():
from psi.app.models import Receiving, EnumValues
from psi.app.views import ReceivingAdmin
from psi.app.service import Info
receiving = Receiving()
complete_status = EnumValues.get(RECEIVING_COMPLETE_STATUS_KEY)
receiving.status = complete_status
db_session = Info.get_db().session
receiving_admin = ReceivingAdmin(Receiving, db_session, name=lazy_gettext("Receiving"),
category=lazy_gettext('Purchase'), menu_icon_type=ICON_TYPE_GLYPH,
menu_icon_value='glyphicon-import')
self.assertRaises(ValidationError, receiving_admin.on_model_delete, receiving)
run_as_admin(self.test_client, test_logic)
def test_delete_completed_receiving_not_allowed(self):
from psi.app.models.enum_values import EnumValues
from psi.app.utils import db_util
def test_logic():
type = EnumValues.get(DIRECT_PO_TYPE_KEY)
status = EnumValues.get(PO_ISSUED_STATUS_KEY)
draft_status = EnumValues.get(RECEIVING_DRAFT_STATUS_KEY)
date = object_faker.faker.date_time_this_year()
po = object_faker.purchase_order(number_of_line=2, type=type,
status=status)
db_util.save_objects_commit(po)
remark = object_faker.faker.text(max_nb_chars=50)
# Crete new receiving
self.assertPageRendered(method=self.test_client.post,
data=dict(purchase_order=po.id,
status=draft_status.id,
create_lines='y',
date=date, remark=remark),
endpoint=self.create_endpoint(view='receiving'),)
# Change status to complete
new_remark = object_faker.faker.text(max_nb_chars=50)
new_receive_date = object_faker.faker.date_time_this_year()
complete_status = EnumValues.get(RECEIVING_COMPLETE_STATUS_KEY)
self.assertPageRendered(method=self.test_client.post,
endpoint=self.edit_endpoint(view='receiving'),
data=dict(date=new_receive_date,
status=complete_status.id,
remark=new_remark),)
# Should not delete existing receiving with complete status
endpoint = url_for('receiving.delete_view', id='1')
data = dict(url=url_for('receiving.index_view'), id='1')
rv = self.assertPageRendered(method=self.test_client.post,
endpoint=endpoint, data=data)
self.assertIn(complete_status.display.encode('utf-8'), rv.data)
self.assertIn(new_receive_date.strftime("%Y-%m-%d").encode('utf-8'), rv.data)
self.assertIn(new_remark.encode('utf-8'), rv.data)
self.assertIn(po.supplier.name.encode('utf-8'), rv.data)
self.assertIn(po.order_date.strftime("%Y-%m-%d").encode('utf-8'),rv.data)
self.assertIn(po.remark.encode('utf-8'), rv.data)
self.assertIn(b'You are not allowed to delete this object', rv.data)
run_as_admin(self.test_client, test_logic)
def test_status_filter(self):
from psi.app.models import PurchaseOrder
def test_logic():
po1, po2 = of.purchase_order(), of.purchase_order()
from psi.app.models import EnumValues
po1.status = EnumValues.get(const.PO_DRAFT_STATUS_KEY)
po2.status = EnumValues.get(const.PO_ISSUED_STATUS_KEY)
db_util.save_objects_commit(po1, po2)
po3 = PurchaseOrder.status_filter((const.PO_DRAFT_STATUS_KEY,)).all()[0]
self.assertIsNotNone(po3)
self.assertEqual(po1, po3)
po4 = PurchaseOrder.status_filter((const.PO_ISSUED_STATUS_KEY,)).all()[0]
self.assertIsNotNone(po4)
self.assertEqual(po2, po4)
from tests.fixture import run_as_admin
run_as_admin(self.test_client, test_logic)
def test_status_filter(self):
from psi.app.models import PurchaseOrder
def test_logic():
po1, po2 = of.purchase_order(), of.purchase_order()
from psi.app.models import EnumValues
po1.status = EnumValues.get(const.PO_DRAFT_STATUS_KEY)
po2.status = EnumValues.get(const.PO_ISSUED_STATUS_KEY)
db_util.save_objects_commit(po1, po2)
po3 = PurchaseOrder.status_filter(
(const.PO_DRAFT_STATUS_KEY, )).all()[0]
self.assertIsNotNone(po3)
self.assertEqual(po1, po3)
po4 = PurchaseOrder.status_filter(
(const.PO_ISSUED_STATUS_KEY, )).all()[0]
self.assertIsNotNone(po4)
self.assertEqual(po2, po4)
from tests.fixture import run_as_admin
run_as_admin(self.test_client, test_logic)
def test_update_sales_order_status_invalid(self):
def test_logic():
fixture.login_as_admin(self.test_client)
user, password = object_faker.user(role_names=[
'franchise_sales_order_create', 'franchise_sales_order_view',
'franchise_sales_order_edit', 'product_view'
])
sales_order = object_faker.sales_order(creator=user,
number_of_line=1)
db_util.save_objects_commit(sales_order, user)
so_id = sales_order.id
fixture.login_user(self.test_client, user.email, password)
rv = self.test_client.put('/api/sales_order/' + str(so_id),
follow_redirects=True,
data=dict(status_id=5000))
self.assertEqual(rv.status_code, 201)
self.assertIn(b'message', rv.data)
self.assertIn(b'Invalid sales order status parameter', rv.data)
run_as_admin(self.test_client, test_logic)
def test_create_draft_recv_from_po(self):
from psi.app.models.receiving import Receiving
from tests.object_faker import object_faker
import psi.app.const as const
def test_logic():
po = object_faker.purchase_order(number_of_line=2)
receiving = Receiving.create_draft_recv_from_po(po)
self.assertEquals(po, receiving.purchase_order)
self.assertEquals(len(po.lines), len(receiving.lines))
self.assertEquals(len(po.lines),
len(receiving.inventory_transaction.lines))
self.assertEquals(po.order_date, receiving.date)
self.assertEquals(receiving.status.code,
const.RECEIVING_DRAFT_STATUS_KEY)
self.assertEquals(po.supplier, receiving.supplier)
self.assertEquals(receiving.inventory_transaction.date,
po.order_date)
self.assertEquals(receiving.inventory_transaction.type.code,
const.PURCHASE_IN_INV_TRANS_KEY)
self.assertIsNotNone(receiving.inventory_transaction)
for line in receiving.lines:
self.assertIsNotNone(line)
self.assertIsNotNone(line.purchase_order_line)
self.assertIsNotNone(line.inventory_transaction_line)
self.assertEquals(line.quantity,
line.purchase_order_line.quantity)
self.assertEquals(line.price,
line.purchase_order_line.unit_price)
self.assertEquals(line.product,
line.purchase_order_line.product)
self.assertEquals(
line.inventory_transaction_line.in_transit_quantity,
line.quantity)
self.assertEquals(line.inventory_transaction_line.product,
line.product)
self.assertEquals(line.inventory_transaction_line.price,
line.price)
from tests.fixture import run_as_admin
run_as_admin(self.test_client, test_logic)
def test_update_sales_order_has_no_role(self):
from psi.app.models import EnumValues
def test_logic():
fixture.login_as_admin(self.test_client)
user, password = object_faker.user(role_names=[
'franchise_sales_order_create',
'franchise_sales_order_view',
'product_view'
])
sales_order = object_faker.sales_order(creator=user,
number_of_line=1)
db_util.save_objects_commit(sales_order, user)
so_id = sales_order.id
delivered_status = EnumValues.get(SO_DELIVERED_STATUS_KEY)
fixture.login_user(self.test_client, user.email, password)
rv = self.test_client.put('/api/sales_order/' + str(so_id),
follow_redirects=True,
data=dict(status_id=delivered_status.id))
self.assertEqual(rv.status_code, 403)
run_as_admin(self.test_client, test_logic)
def test_update_sales_order_status_invalid(self):
def test_logic():
fixture.login_as_admin(self.test_client)
user, password = object_faker.user(role_names=[
'franchise_sales_order_create',
'franchise_sales_order_view',
'franchise_sales_order_edit',
'product_view'
])
sales_order = object_faker.sales_order(creator=user,
number_of_line=1)
db_util.save_objects_commit(sales_order, user)
so_id = sales_order.id
fixture.login_user(self.test_client, user.email, password)
rv = self.test_client.put('/api/sales_order/' + str(so_id),
follow_redirects=True,
data=dict(status_id=5000))
self.assertEqual(rv.status_code, 201)
self.assertIn(b'message', rv.data)
self.assertIn(b'Invalid sales order status parameter', rv.data)
run_as_admin(self.test_client, test_logic)
def test_update_sales_order_has_no_role(self):
from psi.app.models import EnumValues
def test_logic():
fixture.login_as_admin(self.test_client)
user, password = object_faker.user(role_names=[
'franchise_sales_order_create', 'franchise_sales_order_view',
'product_view'
])
sales_order = object_faker.sales_order(creator=user,
number_of_line=1)
db_util.save_objects_commit(sales_order, user)
so_id = sales_order.id
delivered_status = EnumValues.get(SO_DELIVERED_STATUS_KEY)
fixture.login_user(self.test_client, user.email, password)
rv = self.test_client.put('/api/sales_order/' + str(so_id),
follow_redirects=True,
data=dict(status_id=delivered_status.id))
self.assertEqual(rv.status_code, 403)
run_as_admin(self.test_client, test_logic)
def test_delete_complete_receiving_not_allowed(self):
def test_logic():
from psi.app.models import Receiving, EnumValues
from psi.app.views import ReceivingAdmin
from psi.app.service import Info
receiving = Receiving()
complete_status = EnumValues.get(RECEIVING_COMPLETE_STATUS_KEY)
receiving.status = complete_status
db_session = Info.get_db().session
receiving_admin = ReceivingAdmin(
Receiving,
db_session,
name=lazy_gettext("Receiving"),
category=lazy_gettext('Purchase'),
menu_icon_type=ICON_TYPE_GLYPH,
menu_icon_value='glyphicon-import')
self.assertRaises(ValidationError, receiving_admin.on_model_delete,
receiving)
run_as_admin(self.test_client, test_logic)
def test_get_by_po_id(self):
from psi.app.models.receiving import Receiving
from psi.app.models.enum_values import EnumValues
from psi.app.service import Info
from tests.object_faker import object_faker
def test_logic():
po = object_faker.purchase_order()
po.status = EnumValues.get(const.PO_RECEIVED_STATUS_KEY)
receiving = Receiving()
receiving.purchase_order = po
receiving.date = datetime.now()
receiving.status = EnumValues.get(const.RECEIVING_DRAFT_STATUS_KEY)
db = Info.get_db()
db.session.add(po)
db.session.add(receiving)
db.session.commit()
receiving_returned = receiving.filter_by_po_id(1)[0]
self.assertEqual(receiving, receiving_returned)
from tests.fixture import run_as_admin
run_as_admin(self.test_client, test_logic)
def test_create_so_from_po(self):
def test_login():
from psi.app.models import EnumValues
f_type = EnumValues.get(const.FRANCHISE_PO_TYPE_KEY)
po = object_faker.purchase_order(number_of_line=random.randint(
1, 10),
type=f_type)
db_util.save_objects_commit(po)
from psi.app.views import FranchisePurchaseOrderAdmin
sales_order, incoming, expense = FranchisePurchaseOrderAdmin.create_so_from_fpo(
po)
self.assertEquals(len(po.lines), len(sales_order.lines))
self.assertEqual(sales_order.order_date, po.order_date)
self.assertEquals(sales_order.type,
EnumValues.get(const.FRANCHISE_SO_TYPE_KEY))
self.assertEquals(sales_order.status,
EnumValues.get(const.SO_CREATED_STATUS_KEY))
self.assertEquals(sales_order.organization, po.to_organization)
# There's no expense associated with the PO when creating PO for the franchise organization.
# That's done on after_model_change in BasePurchaseOrderAdmin class
self.assertEquals(sales_order.actual_amount, incoming.amount)
self.assertIsNone(expense)
run_as_admin(self.test_client, test_login)
def test_receiving_pages(self):
from psi.app.models.enum_values import EnumValues
from psi.app.utils import db_util
def test_logic():
type = EnumValues.get(DIRECT_PO_TYPE_KEY)
status = EnumValues.get(PO_ISSUED_STATUS_KEY)
receiving_status = EnumValues.get(RECEIVING_DRAFT_STATUS_KEY)
date = object_faker.faker.date_time_this_year()
po = object_faker.purchase_order(number_of_line=2,
type=type,
status=status)
db_util.save_objects_commit(po)
remark = object_faker.faker.text(max_nb_chars=50)
list_expect = [
receiving_status.display,
date.strftime("%Y-%m-%d"), remark, po.supplier.name,
po.order_date.strftime("%Y-%m-%d"), po.remark
]
edit_expect = [
receiving_status.display,
date.strftime("%Y-%m-%d"),
remark,
]
# Crete new receiving
self.assertPageRendered(
method=self.test_client.post,
data=dict(purchase_order=po.id,
status=receiving_status.id,
create_lines='y',
date=date,
remark=remark),
endpoint=self.create_endpoint(view='receiving'),
expect_contents=list_expect)
self.assertPageRendered(
expect_contents=edit_expect,
endpoint=self.edit_endpoint(view='receiving'))
# Edit existing receiving
new_remark = object_faker.faker.text(max_nb_chars=50)
new_receive_date = object_faker.faker.date_time_this_year()
complete_status = EnumValues.get(RECEIVING_COMPLETE_STATUS_KEY)
new_expected = [
complete_status.display,
new_receive_date.strftime("%Y-%m-%d"), new_remark,
po.supplier.name,
po.order_date.strftime("%Y-%m-%d"), po.remark
]
self.assertPageRendered(
method=self.test_client.post,
endpoint=self.edit_endpoint(view='receiving'),
data=dict(date=new_receive_date,
status=complete_status.id,
remark=new_remark),
expect_contents=new_expected)
# Detail page
self.assertPageRendered(
method=self.test_client.get,
endpoint=self.details_endpoint(view='receiving'),
expect_contents=new_expected)
run_as_admin(self.test_client, test_logic)
def test_direct_purchase_order_pages(self):
from psi.app.models.enum_values import EnumValues
def test_logic():
supplier = object_faker.supplier()
db_util.save_objects_commit(supplier)
self.assertPageRendered(endpoint=url_for('dpo.index_view'))
self.assertPageRendered(endpoint=url_for('dpo.create_view'))
draft_status = EnumValues.get(const.PO_DRAFT_STATUS_KEY)
order_date = object_faker.faker.date_time_this_year()
logistic_amount = random.randint(0, 100)
remark = object_faker.faker.text(max_nb_chars=50)
expect_content = [
supplier.name, draft_status.display,
str(logistic_amount),
order_date.strftime("%Y-%m-%d"), remark
]
self.assertPageRendered(
method=self.test_client.post,
data=dict(
supplier=supplier.id,
status=draft_status.id,
order_date=order_date,
logistic_amount=logistic_amount,
remark=remark),
endpoint=self.create_endpoint(view='dpo'),
expect_contents=expect_content)
self.assertPageRendered(
expect_contents=expect_content,
endpoint=self.edit_endpoint(view='dpo'))
new_remark = object_faker.faker.text(max_nb_chars=50)
new_logistic_amount = random.randint(0, 100)
new_order_date = object_faker.faker.date_time_this_year()
new_expect_content = [
supplier.name, draft_status.display,
str(new_logistic_amount),
new_order_date.strftime("%Y-%m-%d"), new_remark
]
self.assertPageRendered(
method=self.test_client.post,
endpoint=self.edit_endpoint(view='dpo'),
data=dict(
supplier=supplier.id,
status=draft_status.id,
order_date=new_order_date,
logistic_amount=new_logistic_amount,
remark=new_remark),
expect_contents=new_expect_content)
rv = self.assertPageRendered(
method=self.test_client.post,
endpoint=url_for('dpo.delete_view'),
data=dict(url=url_for('dpo.index_view'), id='1'))
self.assertNotIn(supplier.name.encode('utf-8'), rv.data)
self.assertNotIn(draft_status.display.encode('utf-8'), rv.data)
self.assertNotIn(new_order_date.strftime("%Y-%m-%d").encode('utf-8'), rv.data)
self.assertNotIn(new_remark.encode('utf-8'), rv.data)
run_as_admin(self.test_client, test_logic)
