def test_csv_upload(self):
self.assertEqual(
[(i.name, i.category or u"") for i in Location.objects.all()],
[
(u"All locations", u""),
(u"factory 1", u""),
(u"factory 2", u""),
], # Test result is different in Enterprise Edition
)
try:
data = tempfile.NamedTemporaryFile(mode="w+b")
data.write(b"name,category\n")
data.write(b"factory 3,cat1\n")
data.write(b"factory 4,\n")
data.seek(0)
response = self.client.post("/data/input/location/", {"csv_file": data})
checkResponse(self, response)
finally:
data.close()
self.assertEqual(
[(i.name, i.category or u"") for i in Location.objects.order_by("name")],
[
(u"All locations", u""),
(u"factory 1", u""),
(u"factory 2", u""),
(u"factory 3", u"cat1"),
(u"factory 4", u""),
], # Test result is different in Enterprise Edition
)
def test_output_manufacturing_orders(self):
response = self.client.get("/operation/?format=json")
self.assertContains(response, '"records":0,')
self.assertEqual(response.status_code, 200)
response = self.client.get("/operation/?format=csvtable")
checkResponse(self, response)
self.assertTrue(
response.__getitem__("Content-Type").startswith(
"text/csv; charset="))
response = self.client.get("/operation/?format=spreadsheetlist")
checkResponse(self, response)
self.assertTrue(
response.__getitem__("Content-Type").startswith(
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
))
def test_output_demand(self):
response = self.client.get("/demand/")
self.assertContains(response, "Demand report")
self.assertEqual(response.status_code, 200)
response = self.client.get("/demand/?format=csvlist")
checkResponse(self, response)
self.assertTrue(
response.__getitem__("Content-Type").startswith(
"text/csv; charset="))
response = self.client.get("/demand/?format=spreadsheettable")
checkResponse(self, response)
self.assertTrue(
response.__getitem__("Content-Type").startswith(
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
))
def test_api_customer(self):
response = self.client.get("/api/input/customer/")
checkResponse(self, response)
recordsnumber = Customer.objects.count()
self.assertEqual(
Customer.objects.count(), 3
) # Different between Enterprise Edition and Community Edition
response = self.client.options("/api/input/customer/")
checkResponse(self, response)
data = {"name": "Customer near Area 51"}
response = self.client.post("/api/input/customer/", data)
self.assertEqual(response.status_code, 201)
self.assertEqual(Customer.objects.count(), recordsnumber + 1)
self.assertEqual(
Customer.objects.filter(name="Customer near Area 51").count(), 1
)
data = {"name": "Customer near Area 52"}
response = self.client.post("/api/input/customer/", data, format="json")
self.assertEqual(response.status_code, 201)
self.assertEqual(Customer.objects.count(), recordsnumber + 2)
self.assertEqual(
Customer.objects.filter(name="Customer near Area 52").count(), 1
)
data = [
{"name": "Customer near Area 99", "source": "TEST DELETE"},
{"name": "Customer near Area 100", "source": "TEST DELETE"},
]
response = self.client.post("/api/input/customer/", data, format="json")
self.assertEqual(response.status_code, 201)
self.assertEqual(Customer.objects.count(), recordsnumber + 4)
self.assertEqual(Customer.objects.filter(source="TEST DELETE").count(), 2)
# Customer GET MULTIPART
response = self.client.get("/api/input/customer/Customer near Area 51/")
checkResponse(self, response)
self.assertEqual(
Customer.objects.filter(name="Customer near Area 51").count(), 1
)
# Customer OPTIONS
response = self.client.options("/api/input/customer/Customer near Area 51/")
checkResponse(self, response)
# Customer GET JSON tests
response = self.client.get(
"/api/input/customer/Customer near Area 52/", format="json"
)
checkResponse(self, response)
self.assertEqual(
Customer.objects.filter(name="Customer near Area 52").count(), 1
)
# Customer PUT MULTIPART tests
data = {"name": "Customer near Area 51", "description": "Patch multipart"}
response = self.client.patch("/api/input/customer/Customer near Area 51/", data)
checkResponse(self, response)
self.assertEqual(Customer.objects.count(), recordsnumber + 4)
self.assertEqual(
Customer.objects.filter(description="Patch multipart").count(), 1
)
# Customer PUT JSON tests
data = {"name": "Customer near Area 52", "description": "Patch json"}
response = self.client.patch(
"/api/input/customer/Customer near Area 52/", data, format="json"
)
checkResponse(self, response)
self.assertEqual(Customer.objects.count(), recordsnumber + 4)
self.assertEqual(Customer.objects.filter(description="Patch json").count(), 1)
# Customer PUT FORM tests
data = {
"name": "Customer near Area 52",
"description": "Patch json",
"category": None,
"subcategory": None,
"source": "Put json",
"lastmodified": "2015-12-04T10:18:40.048861",
}
response = self.client.patch(
"/api/input/customer/Customer near Area 52/", data, format="json"
)
checkResponse(self, response)
self.assertEqual(Customer.objects.count(), recordsnumber + 4)
self.assertEqual(Customer.objects.filter(source="Put json").count(), 1)
# Customer bulk filtered GET test
response = self.client.get(
"/api/input/customer/?name__contains=Area", format="json"
)
checkResponse(self, response)
self.assertEqual(Customer.objects.filter(name__contains="Area").count(), 4)
# Customer DELETE tests
# Bulk "contains" filtered DELETE
response = self.client.delete(
"/api/input/customer/?name__contains=Area 5", format="form"
)
self.assertEqual(response.status_code, 204)
self.assertEqual(Customer.objects.filter(name__contains="Area").count(), 2)
# Single DELETE
response = self.client.delete(
"/api/input/customer/Customer near factory 1/", format="api"
)
self.assertEqual(response.status_code, 204)
# Bulk filtered DELETE
response = self.client.delete(
"/api/input/customer/?source=TEST DELETE", format="json"
)
self.assertEqual(response.status_code, 204)
self.assertEqual(Customer.objects.filter(source="TEST DELETE").count(), 0)
def test_api_demand(self):
response = self.client.get("/api/input/demand/")
checkResponse(self, response)
response = self.client.options("/api/input/demand/")
checkResponse(self, response)
recordsnumber = Demand.objects.count()
data = {
"name": "Order UFO 25",
"description": None,
"category": None,
"subcategory": None,
"item": "product",
"customer": "Customer near factory 1",
"location": "factory 1",
"due": "2013-12-01T00:00:00",
"status": "closed",
"operation": None,
"quantity": "110.0000",
"priority": 1,
"minshipment": None,
"maxlateness": None,
}
response = self.client.post("/api/input/demand/", data, format="json")
self.assertEqual(response.status_code, 201)
self.assertEqual(Demand.objects.count(), recordsnumber + 1)
self.assertEqual(Demand.objects.filter(name="Order UFO 25").count(), 1)
data = {
"name": "Order UFO 26",
"description": None,
"category": None,
"subcategory": None,
"item": "product",
"customer": "Customer near factory 1",
"location": "factory 1",
"due": "2013-12-01T00:00:00",
"status": "closed",
"operation": None,
"quantity": "220.0000",
"priority": 1,
"minshipment": None,
"maxlateness": None,
}
response = self.client.post("/api/input/demand/", data, format="json")
self.assertEqual(response.status_code, 201)
self.assertEqual(Demand.objects.count(), recordsnumber + 2)
self.assertEqual(Demand.objects.filter(name="Order UFO 26").count(), 1)
data = [
{
"name": "Order UFO 27",
"description": None,
"category": "TEST DELETE",
"subcategory": None,
"item": "product",
"location": "factory 1",
"customer": "Customer near factory 1",
"due": "2013-12-01T00:00:00",
"status": "closed",
"operation": None,
"quantity": "220.0000",
"priority": 1,
"minshipment": None,
"maxlateness": None,
},
{
"name": "Order UFO 28",
"description": None,
"category": "TEST DELETE",
"subcategory": None,
"item": "product",
"customer": "Customer near factory 1",
"location": "factory 1",
"due": "2013-12-01T00:00:00",
"status": "closed",
"operation": None,
"quantity": "220.0000",
"priority": 1,
"minshipment": None,
"maxlateness": None,
},
]
response = self.client.post("/api/input/demand/", data, format="json")
self.assertEqual(response.status_code, 201)
self.assertEqual(Demand.objects.count(), recordsnumber + 4)
self.assertEqual(Demand.objects.filter(category="TEST DELETE").count(), 2)
# Demand GET MULTIPART
response = self.client.get("/api/input/demand/Order UFO 25/")
checkResponse(self, response)
self.assertEqual(Demand.objects.filter(name="Order UFO 25").count(), 1)
# Demand OPTIONS
response = self.client.options("/api/input/demand/Order UFO 25/")
checkResponse(self, response)
# Demand GET JSON tests
response = self.client.get("/api/input/demand/Order UFO 26/", format="json")
checkResponse(self, response)
self.assertEqual(Demand.objects.filter(name="Order UFO 26").count(), 1)
# Demand PUT MULTIPART tests
data = {
"name": "Order UFO 25",
"description": "Put multipart",
"category": None,
"subcategory": None,
"item": "product",
"customer": "Customer near factory 1",
"location": "factory 1",
"due": "2013-12-01T00:00:00",
"status": "closed",
"operation": None,
"quantity": "110.0000",
"priority": 1,
"minshipment": None,
"maxlateness": None,
}
response = self.client.put(
"/api/input/demand/Order UFO 25/", data, format="json"
)
checkResponse(self, response)
self.assertEqual(Demand.objects.count(), 18)
self.assertEqual(Demand.objects.filter(description="Put multipart").count(), 1)
# Demand PUT JSON tests
data = {
"name": "Order UFO 26",
"description": "Put json",
"category": None,
"subcategory": None,
"item": "product",
"customer": "Customer near factory 1",
"location": "factory 1",
"due": "2013-12-01T00:00:00",
"status": "closed",
"operation": None,
"quantity": "110.0000",
"priority": 1,
"minshipment": None,
"maxlateness": None,
}
response = self.client.put(
"/api/input/demand/Order UFO 26/", data, format="json"
)
checkResponse(self, response)
self.assertEqual(Demand.objects.count(), recordsnumber + 4)
self.assertEqual(Demand.objects.filter(description="Put json").count(), 1)
# Demand PUT FORM tests
data = {
"name": "Order UFO 26",
"description": "Put form",
"category": None,
"subcategory": None,
"item": "product",
"customer": "Customer near factory 1",
"location": "factory 1",
"due": "2013-12-01T00:00:00",
"status": "closed",
"operation": None,
"quantity": "110.0000",
"priority": 1,
"minshipment": None,
"maxlateness": None,
}
response = self.client.put(
"/api/input/demand/Order UFO 26/", data, format="json"
)
checkResponse(self, response)
self.assertEqual(Demand.objects.count(), recordsnumber + 4)
self.assertEqual(Demand.objects.filter(description="Put form").count(), 1)
# Demand DELETE tests
response = self.client.delete("/api/input/demand/Order UFO 26/", format="form")
self.assertEqual(response.status_code, 204)
response = self.client.delete("/api/input/demand/Order UFO 25/", format="json")
self.assertEqual(response.status_code, 204)
response = self.client.delete("/api/input/demand/Demand 01/", format="api")
self.assertEqual(response.status_code, 204)
response = self.client.delete(
"/api/input/demand/?category=TEST DELETE", format="api"
)
self.assertEqual(response.status_code, 204)
self.assertEqual(Customer.objects.filter(category="TEST DELETE").count(), 0)
def test_api_listpages_getapi(self):
response = self.client.get("/api/")
checkResponse(self, response)
response = self.client.get("/api/input/demand/")
checkResponse(self, response)
response = self.client.get("/api/input/item/")
checkResponse(self, response)
response = self.client.get("/api/input/customer/")
checkResponse(self, response)
response = self.client.get("/api/input/location/")
checkResponse(self, response)
response = self.client.get("/api/input/buffer/")
checkResponse(self, response)
response = self.client.get("/api/input/resource/")
checkResponse(self, response)
response = self.client.get("/api/input/skill/")
checkResponse(self, response)
response = self.client.get("/api/input/resourceskill/")
checkResponse(self, response)
response = self.client.get("/api/input/setupmatrix/")
checkResponse(self, response)
response = self.client.get("/api/input/purchaseorder/")
checkResponse(self, response)
response = self.client.get("/api/input/supplier/")
checkResponse(self, response)
response = self.client.get("/api/input/itemsupplier/")
checkResponse(self, response)
response = self.client.get("/api/input/distributionorder/")
checkResponse(self, response)
response = self.client.get("/api/input/itemdistribution/")
checkResponse(self, response)
response = self.client.get("/api/input/manufacturingorder/")
checkResponse(self, response)
response = self.client.get("/api/input/calendar/")
checkResponse(self, response)
response = self.client.get("/api/input/calendarbucket/")
checkResponse(self, response)
response = self.client.get("/api/input/operation/")
checkResponse(self, response)
response = self.client.get("/api/input/operationmaterial/")
checkResponse(self, response)
response = self.client.get("/api/input/operationresource/")
checkResponse(self, response)
response = self.client.get("/api/input/suboperation/")
checkResponse(self, response)
response = self.client.get("/api/common/parameter/")
checkResponse(self, response)
response = self.client.get("/api/common/bucket/")
checkResponse(self, response)
response = self.client.get("/api/common/bucketdetail/")
checkResponse(self, response)
def run_workbook(self, language):
# Change the language preference
self.client.post(
"/preferences/", {"pagesize": 100, "language": language, "theme": "orange"}
)
# Initial size
countBuffer = Buffer.objects.count()
countCalendarBucket = CalendarBucket.objects.count()
countCalendar = Calendar.objects.count()
countCustomer = Customer.objects.count()
countDemand = Demand.objects.count()
countOperationMaterial = OperationMaterial.objects.count()
countItem = Item.objects.count()
countItemSupplier = ItemSupplier.objects.count()
countItemDistribution = ItemDistribution.objects.count()
countOperationResource = OperationResource.objects.count()
countLocation = Location.objects.count()
countPurchaseOrder = PurchaseOrder.objects.count()
countDistributionOrder = DistributionOrder.objects.count()
countManufacturingOrder = ManufacturingOrder.objects.count()
countOperation = Operation.objects.count()
countResourceSkill = ResourceSkill.objects.count()
countResource = Resource.objects.count()
countSetupMatrix = SetupMatrix.objects.count()
countSkill = Skill.objects.count()
countSubOperation = SubOperation.objects.count()
countSupplier = Supplier.objects.count()
countBucket = Bucket.objects.count()
countBucketDetail = BucketDetail.objects.count()
countParameter = Parameter.objects.count()
self.assertTrue(countDemand > 0)
# Export workbook
response = self.client.post(
"/execute/launch/exportworkbook/",
{
"entities": [
"input.demand",
"input.item",
"input.customer",
"input.location",
"input.buffer",
"input.resource",
"input.skill",
"input.resourceskill",
"input.setupmatrix",
"input.purchaseorder",
"input.supplier",
"input.itemsupplier",
"input.distributionorder",
"input.itemdistribution",
"input.operationmaterial",
"input.manufacturingorder",
"input.calendar",
"input.calendarbucket",
"input.operation",
"input.operationplanmaterial",
"input.operationresource",
"input.suboperation",
"common.parameter",
"common.bucket",
"common.bucketdetail",
]
},
)
with open("workbook.xlsx", "wb") as f:
f.write(response.content)
# Erase the database
management.call_command("empty")
self.assertEqual(Buffer.objects.count(), 0)
self.assertEqual(CalendarBucket.objects.count(), 0)
self.assertEqual(Calendar.objects.count(), 0)
self.assertEqual(Customer.objects.count(), 0)
self.assertEqual(Demand.objects.count(), 0)
self.assertEqual(OperationMaterial.objects.count(), 0)
self.assertEqual(Item.objects.count(), 0)
self.assertEqual(ItemDistribution.objects.count(), 0)
self.assertEqual(ItemSupplier.objects.count(), 0)
self.assertEqual(OperationResource.objects.count(), 0)
self.assertEqual(Location.objects.count(), 0)
self.assertEqual(PurchaseOrder.objects.count(), 0)
self.assertEqual(DistributionOrder.objects.count(), 0)
self.assertEqual(ManufacturingOrder.objects.count(), 0)
self.assertEqual(OperationPlanResource.objects.count(), 0)
self.assertEqual(OperationPlanMaterial.objects.count(), 0)
self.assertEqual(Operation.objects.count(), 0)
self.assertEqual(ResourceSkill.objects.count(), 0)
self.assertEqual(Resource.objects.count(), 0)
self.assertEqual(SetupMatrix.objects.count(), 0)
self.assertEqual(Skill.objects.count(), 0)
self.assertEqual(SubOperation.objects.count(), 0)
self.assertEqual(Supplier.objects.count(), 0)
self.assertEqual(Bucket.objects.count(), 0)
self.assertEqual(BucketDetail.objects.count(), 0)
self.assertEqual(Parameter.objects.count(), 0)
# Import the same workbook again
with open("workbook.xlsx", "rb") as f:
response = self.client.post(
"/execute/launch/importworkbook/", {"spreadsheet": f}
)
if not isinstance(response, StreamingHttpResponse):
raise Exception("expected a streaming response")
checkResponse(self, response)
# Verify the new content is identical
self.assertEqual(Buffer.objects.count(), countBuffer)
self.assertEqual(CalendarBucket.objects.count(), countCalendarBucket)
self.assertEqual(Calendar.objects.count(), countCalendar)
self.assertEqual(Customer.objects.count(), countCustomer)
self.assertEqual(Demand.objects.count(), countDemand)
self.assertEqual(OperationMaterial.objects.count(), countOperationMaterial)
self.assertEqual(Item.objects.count(), countItem)
self.assertEqual(ItemDistribution.objects.count(), countItemDistribution)
self.assertEqual(ItemSupplier.objects.count(), countItemSupplier)
self.assertEqual(OperationResource.objects.count(), countOperationResource)
self.assertEqual(Location.objects.count(), countLocation)
self.assertEqual(PurchaseOrder.objects.count(), countPurchaseOrder)
self.assertEqual(DistributionOrder.objects.count(), countDistributionOrder)
self.assertEqual(ManufacturingOrder.objects.count(), countManufacturingOrder)
self.assertEqual(Operation.objects.count(), countOperation)
self.assertEqual(ResourceSkill.objects.count(), countResourceSkill)
self.assertEqual(Resource.objects.count(), countResource)
self.assertEqual(SetupMatrix.objects.count(), countSetupMatrix)
self.assertEqual(Skill.objects.count(), countSkill)
self.assertEqual(SubOperation.objects.count(), countSubOperation)
self.assertEqual(Supplier.objects.count(), countSupplier)
self.assertEqual(Bucket.objects.count(), countBucket)
self.assertEqual(BucketDetail.objects.count(), countBucketDetail)
self.assertEqual(Parameter.objects.count(), countParameter)
def test_create_and_edit(self):
# Create a report
self.assertEqual(SQLReport.objects.all().count(), 0)
response = self.client.get("/reportmanager/schema/")
checkResponse(self, response)
response = self.client.post(
"/reportmanager/",
{
"sql": "select name, cost, description from item",
"save": "true",
"name": "test report",
"public": "false",
"description": "my description",
},
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
)
checkResponse(self, response)
self.assertEqual(SQLReport.objects.all().count(), 1)
self.assertEqual(SQLColumn.objects.all().count(), 3)
report = SQLReport.objects.all()[0]
self.assertEqual(report.name, "test report")
self.assertEqual(report.sql,
"select name, cost, description from item")
self.assertEqual(report.description, "my description")
self.assertEqual(report.public, False)
# Retrieve report data
response = self.client.get("/reportmanager/%s/" % report.id)
checkResponse(self, response)
response = self.client.get("/reportmanager/%s/?format=json" %
report.id)
self.assertContains(response, '"records":7,')
response = self.client.get("/reportmanager/%s/?format=csv" % report.id)
checkResponse(self, response)
response = self.client.get("/reportmanager/%s/?format=spreadsheet" %
report.id)
checkResponse(self, response)
# Retrieve filtered and sorted report data
response = self.client.get("/reportmanager/%s/" % report.id)
checkResponse(self, response)
fltr = quote(
json.dumps({
"groupOp": "AND",
"rules": [{
"field": "name",
"op": "cn",
"data": "e"
}],
}))
response = self.client.get(
"/reportmanager/%s/?format=json&_search=true&filters=%s&searchField=&searchString=&searchOper="
% (report.id, fltr))
self.assertContains(response, '"records":1,')
response = self.client.get("/reportmanager/%s/?format=csv&name__cn=a" %
(report.id))
cnt = 0
for _ in response:
cnt += 1
self.assertEqual(cnt, 5)
# Edit report
response = self.client.post(
"/reportmanager/%s/" % report.id,
{
"id": report.id,
"save": "true",
"sql":
"select name, category, subcategory, cost, description from item",
"name": report.name,
"public": report.public,
},
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
)
answer = json.loads(response.content.decode("utf-8"))
self.assertEqual(answer["status"], "ok")
response = self.client.post(
"/reportmanager/%s/" % report.id,
{
"id": report.id,
"save": "true",
"sql": "a very bad SQL statement",
"name": report.name,
"public": report.public,
},
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
)
answer = json.loads(response.content.decode("utf-8"))
self.assertNotEqual(answer["status"], "ok")
# Delete a report
response = self.client.post(
"/reportmanager/",
{
"id": report.id,
"delete": "true"
},
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
)
checkResponse(self, response)
self.assertEqual(SQLReport.objects.all().count(), 0)
self.assertEqual(SQLColumn.objects.all().count(), 0)
def test_output_pegging(self):
response = self.client.get("/demandpegging/Demand%2001/?format=json")
self.assertContains(response, '"records":1,')
checkResponse(self, response)
