def test_can_remove(self):
product = self.create_product()
test = ProductQualityTest(store=self.store, product=product)
# Test has never been used
self.assertTrue(test.can_remove())
order = self.create_production_order()
user = self.create_user()
item = ProductionProducedItem(product=product,
order=order,
produced_by=user,
produced_date=localtoday().date(),
serial_number=1,
store=self.store)
self.assertTrue(test.can_remove())
# Test has been used in a production
ProductionItemQualityResult(produced_item=item,
quality_test=test,
tested_by=user,
result_value=u'True',
test_passed=True,
store=self.store)
self.assertFalse(test.can_remove())
def test_can_remove(self):
product = self.create_product()
test = ProductQualityTest(store=self.store, product=product)
# Test has never been used
self.assertTrue(test.can_remove())
order = self.create_production_order()
user = self.create_user()
item = ProductionProducedItem(product=product,
order=order,
produced_by=user,
produced_date=datetime.date.today(),
serial_number=1,
store=self.store)
self.assertTrue(test.can_remove())
# Test has been used in a production
ProductionItemQualityResult(produced_item=item,
quality_test=test,
tested_by=user,
result_value=u'True',
test_passed=True,
store=self.store)
self.assertFalse(test.can_remove())
def test_quality_tests(self):
product = self.create_product()
Storable(product=product, store=self.store)
# There are still no tests for this product
self.assertEqual(product.quality_tests.count(), 0)
test1 = ProductQualityTest(store=self.store,
product=product,
test_type=ProductQualityTest.TYPE_BOOLEAN,
success_value=u'True')
# Now there sould be one
self.assertEqual(product.quality_tests.count(), 1)
# and it should be the one we created
self.assertTrue(test1 in product.quality_tests)
# Different product
product2 = self.create_product()
Storable(product=product2, store=self.store)
# With different test
test2 = ProductQualityTest(store=self.store,
product=product2,
test_type=ProductQualityTest.TYPE_BOOLEAN,
success_value=u'True')
# First product still should have only one
self.assertEqual(product.quality_tests.count(), 1)
# And it should not be the second test.
self.assertTrue(test2 not in product.quality_tests)
def _create_quality_tests(self, order):
from stoqlib.domain.product import ProductQualityTest
product = order.get_items()[0].product
ProductQualityTest(store=self.store, product=product,
test_type=ProductQualityTest.TYPE_BOOLEAN,
description=u'Boolean test',
success_value=u'True')
ProductQualityTest(store=self.store, product=product,
test_type=ProductQualityTest.TYPE_DECIMAL,
description=u'Decimal test',
success_value=u'2 - 3')
def test_is_completely_tested(self):
item = self.create_production_item(quantity=10)
order = item.order
self.assertTrue(order.is_completely_tested())
test1 = ProductQualityTest(store=self.store, product=item.product, test_type=ProductQualityTest.TYPE_BOOLEAN)
test1.set_boolean_value(True)
for material in item.order.get_material_items():
material.product.storable.increase_stock(10, item.order.branch, StockTransactionHistory.TYPE_INITIAL, None)
order.start_production()
user = self.create_user()
item.produce(1, produced_by=user, serials=[1])
produced_item = order.produced_items.any()
produced_item.test_passed = False
self.assertFalse(order.is_completely_tested())
produced_item.test_passed = True
self.assertTrue(order.is_completely_tested())
def test_is_completely_tested(self):
item = self.create_production_item(quantity=10)
order = item.order
self.assertTrue(order.is_completely_tested())
test1 = ProductQualityTest(store=self.store,
product=item.product,
test_type=ProductQualityTest.TYPE_BOOLEAN)
test1.set_boolean_value(True)
for material in item.order.get_material_items():
material.product.storable.increase_stock(
10, item.order.branch, StockTransactionHistory.TYPE_INITIAL,
None, self.current_user)
order.start_production(self.current_user)
user = self.create_user()
item.produce(user, 1, serials=[1])
produced_item = order.produced_items.any()
produced_item.test_passed = False
self.assertFalse(order.is_completely_tested())
produced_item.test_passed = True
self.assertTrue(order.is_completely_tested())
def test_production_quality_complete_process(self):
# Order with one product to produce 4 units
order = self.create_production_order()
item = self.create_production_item(quantity=4, order=order)
for material in item.order.get_material_items():
storable = material.product.storable
storable.increase_stock(4, order.branch,
StockTransactionHistory.TYPE_INITIAL, None)
test1 = ProductQualityTest(store=self.store, product=item.product,
test_type=ProductQualityTest.TYPE_BOOLEAN)
test1.set_boolean_value(True)
test2 = ProductQualityTest(store=self.store, product=item.product,
test_type=ProductQualityTest.TYPE_DECIMAL)
test2.set_range_value(10, 20)
order.start_production()
self.assertEqual(order.status, ProductionOrder.ORDER_PRODUCING)
# Since the item has tests, we cant produce anonimously
self.assertRaises(AssertionError, item.produce, 1)
user = self.create_user()
# We still dont have any stock for this product
storable = item.product.storable
self.assertEqual(storable.get_balance_for_branch(order.branch), 0)
self.assertEqual(order.produced_items.count(), 0)
item.produce(1, user, [123456])
self.assertEqual(order.produced_items.count(), 1)
self.assertEqual(list(order.produced_items)[0].serial_number, 123456)
self.assertEqual(order.status, ProductionOrder.ORDER_PRODUCING)
# Produce the rest
item.produce(3, user, [123457, 123458, 1234569])
self.assertEqual(order.status, ProductionOrder.ORDER_QA)
# For a produced item, initially, the tests should be empty
p_item = list(order.produced_items.order_by(u'id'))[0]
self.assertEqual(p_item.get_test_result(test1), None)
self.assertEqual(p_item.get_test_result(test2), None)
self.assertEqual(p_item.test_passed, False)
# Add a first, faild test
result = p_item.set_test_result_value(test1, False, user)
self.assertEqual(p_item.get_test_result(test1), result)
self.assertEqual(p_item.get_test_result(test2), None)
self.assertEqual(result.get_boolean_value(), False)
self.assertEqual(result.test_passed, False)
# Set it to success
p_item.set_test_result_value(test1, True, user)
self.assertEqual(result.get_boolean_value(), True)
self.assertEqual(result.test_passed, True)
# Since the product has two tests, the produced item havent passed all
# tests yet
self.assertEqual(p_item.test_passed, False)
# Add a result for the second test (failing)
result = p_item.set_test_result_value(test2, Decimal(5), user)
self.assertEqual(p_item.get_test_result(test2), result)
self.assertEqual(result.get_decimal_value(), 5)
self.assertEqual(result.test_passed, False)
self.assertEqual(p_item.test_passed, False)
# Now set the second test as a success
p_item.set_test_result_value(test2, Decimal(15), user)
self.assertEqual(result.test_passed, True)
self.assertEqual(p_item.test_passed, True)
# Lets now set the results for all tests as sucessful
for p_item in order.produced_items.order_by(u'id'):
p_item.set_test_result_value(test1, True, user)
p_item.set_test_result_value(test2, Decimal(15), user)
# Order should be now CLOSED
self.assertEqual(order.status, ProductionOrder.ORDER_CLOSED)
# Items should have entered stock
for p_item in order.produced_items:
self.assertEqual(p_item.entered_stock, True)
storable = item.product.storable
self.assertEqual(storable.get_balance_for_branch(order.branch), 4)
def create_model(self, store):
return ProductQualityTest(product=self._product, store=store)
def test_get_description(self):
r = ProductionItemQualityResult(store=self.store)
r.quality_test = ProductQualityTest(store=self.store,
description=u'description')
self.assertEqual(r.get_description(), u'description')
def test_production_quality_complete_process(self):
# Order with one product to produce 4 units
order = self.create_production_order()
item = self.create_production_item(quantity=4, order=order)
for material in item.order.get_material_items():
storable = material.product.storable
storable.increase_stock(4, order.branch,
StockTransactionHistory.TYPE_INITIAL, None,
self.current_user)
test1 = ProductQualityTest(store=self.store,
product=item.product,
test_type=ProductQualityTest.TYPE_BOOLEAN)
test1.set_boolean_value(True)
test2 = ProductQualityTest(store=self.store,
product=item.product,
test_type=ProductQualityTest.TYPE_DECIMAL)
test2.set_range_value(10, 20)
order.start_production(self.current_user)
self.assertEqual(order.status, ProductionOrder.ORDER_PRODUCING)
# Since the item has tests, we cant produce anonimously
with self.assertRaises(AssertionError):
item.produce(self.current_user, 1)
user = self.create_user()
# We still dont have any stock for this product
storable = item.product.storable
self.assertEqual(storable.get_balance_for_branch(order.branch), 0)
self.assertEqual(order.produced_items.count(), 0)
item.produce(user, 1, [123456])
self.assertEqual(order.produced_items.count(), 1)
self.assertEqual(list(order.produced_items)[0].serial_number, 123456)
self.assertEqual(order.status, ProductionOrder.ORDER_PRODUCING)
# Produce the rest
item.produce(user, 3, [123457, 123458, 1234569])
self.assertEqual(order.status, ProductionOrder.ORDER_QA)
# For a produced item, initially, the tests should be empty
p_item = list(order.produced_items.order_by(u'id'))[0]
self.assertEqual(p_item.get_test_result(test1), None)
self.assertEqual(p_item.get_test_result(test2), None)
self.assertEqual(p_item.test_passed, False)
# Add a first, faild test
result = p_item.set_test_result_value(test1, False, user)
self.assertEqual(p_item.get_test_result(test1), result)
self.assertEqual(p_item.get_test_result(test2), None)
self.assertEqual(result.get_boolean_value(), False)
self.assertEqual(result.test_passed, False)
# Set it to success
p_item.set_test_result_value(test1, True, user)
self.assertEqual(result.get_boolean_value(), True)
self.assertEqual(result.test_passed, True)
# Since the product has two tests, the produced item havent passed all
# tests yet
self.assertEqual(p_item.test_passed, False)
# Add a result for the second test (failing)
result = p_item.set_test_result_value(test2, Decimal(5), user)
self.assertEqual(p_item.get_test_result(test2), result)
self.assertEqual(result.get_decimal_value(), 5)
self.assertEqual(result.test_passed, False)
self.assertEqual(p_item.test_passed, False)
# Now set the second test as a success
p_item.set_test_result_value(test2, Decimal(15), user)
self.assertEqual(result.test_passed, True)
self.assertEqual(p_item.test_passed, True)
# Lets now set the results for all tests as sucessful
for p_item in order.produced_items.order_by(u'id'):
p_item.set_test_result_value(test1, True, user)
p_item.set_test_result_value(test2, Decimal(15), user)
# Order should be now CLOSED
self.assertEqual(order.status, ProductionOrder.ORDER_CLOSED)
# Items should have entered stock
for p_item in order.produced_items:
self.assertEqual(p_item.entered_stock, True)
storable = item.product.storable
self.assertEqual(storable.get_balance_for_branch(order.branch), 4)
def test_decimal_value(self):
product = self.create_product()
test = ProductQualityTest(store=self.store, product=product,
test_type=ProductQualityTest.TYPE_DECIMAL)
test.set_range_value(Decimal(10), Decimal(20))
self.assertEqual(test.get_range_value(), (Decimal(10), Decimal(20)))
self.assertFalse(test.result_value_passes(Decimal('9.99')))
self.assertTrue(test.result_value_passes(Decimal(10)))
self.assertTrue(test.result_value_passes(Decimal(15)))
self.assertTrue(test.result_value_passes(Decimal(20)))
self.assertFalse(test.result_value_passes(Decimal('20.0001')))
self.assertFalse(test.result_value_passes(Decimal(30)))
test.set_range_value(Decimal(30), Decimal(40))
self.assertEqual(test.get_range_value(), (Decimal(30), Decimal(40)))
self.assertTrue(test.result_value_passes(Decimal(30)))
# Negative values
test.set_range_value(Decimal(-5), Decimal(5))
self.assertEqual(test.get_range_value(), (Decimal(-5), Decimal(5)))
self.assertRaises(AssertionError, test.get_boolean_value)
def test_boolean_value(self):
product = self.create_product()
bool_test = ProductQualityTest(store=self.store, product=product,
test_type=ProductQualityTest.TYPE_BOOLEAN)
bool_test.set_boolean_value(True)
self.assertEqual(bool_test.get_boolean_value(), True)
self.assertTrue(bool_test.result_value_passes(True))
self.assertFalse(bool_test.result_value_passes(False))
bool_test.set_boolean_value(False)
self.assertEqual(bool_test.get_boolean_value(), False)
self.assertTrue(bool_test.result_value_passes(False))
self.assertFalse(bool_test.result_value_passes(True))
self.assertRaises(AssertionError, bool_test.get_range_value)
def test_decimal_value(self):
product = self.create_product()
test = ProductQualityTest(store=self.store,
product=product,
test_type=ProductQualityTest.TYPE_DECIMAL)
test.set_range_value(Decimal(10), Decimal(20))
self.assertEqual(test.get_range_value(), (Decimal(10), Decimal(20)))
self.assertFalse(test.result_value_passes(Decimal('9.99')))
self.assertTrue(test.result_value_passes(Decimal(10)))
self.assertTrue(test.result_value_passes(Decimal(15)))
self.assertTrue(test.result_value_passes(Decimal(20)))
self.assertFalse(test.result_value_passes(Decimal('20.0001')))
self.assertFalse(test.result_value_passes(Decimal(30)))
test.set_range_value(Decimal(30), Decimal(40))
self.assertEqual(test.get_range_value(), (Decimal(30), Decimal(40)))
self.assertTrue(test.result_value_passes(Decimal(30)))
# Negative values
test.set_range_value(Decimal(-5), Decimal(5))
self.assertEqual(test.get_range_value(), (Decimal(-5), Decimal(5)))
self.assertRaises(AssertionError, test.get_boolean_value)
def test_boolean_value(self):
product = self.create_product()
bool_test = ProductQualityTest(
store=self.store,
product=product,
test_type=ProductQualityTest.TYPE_BOOLEAN)
bool_test.set_boolean_value(True)
self.assertEqual(bool_test.get_boolean_value(), True)
self.assertTrue(bool_test.result_value_passes(True))
self.assertFalse(bool_test.result_value_passes(False))
bool_test.set_boolean_value(False)
self.assertEqual(bool_test.get_boolean_value(), False)
self.assertTrue(bool_test.result_value_passes(False))
self.assertFalse(bool_test.result_value_passes(True))
self.assertRaises(AssertionError, bool_test.get_range_value)
