diff --git a/erpnext/stock/doctype/material_request/tests/test_material_request_type_manufacture.js b/erpnext/stock/doctype/material_request/tests/test_material_request_type_manufacture.js
new file mode 100644
index 0000000..91b47ba
--- /dev/null
+++ b/erpnext/stock/doctype/material_request/tests/test_material_request_type_manufacture.js
@@ -0,0 +1,30 @@
+QUnit.module('Stock');
+
+QUnit.test("test material request", function(assert) {
+	assert.expect(1);
+	let done = assert.async();
+	frappe.run_serially([
+		() => {
+			return frappe.tests.make('Material Request', [
+				{material_request_type:'Manufacture'},
+				{items: [
+					[
+						{'schedule_date':  frappe.datetime.add_days(frappe.datetime.nowdate(), 5)},
+						{'qty': 5},
+						{'item_code': 'Test Product 1'},
+					]
+				]},
+			]);
+		},
+		() => cur_frm.save(),
+		() => {
+			// get_item_details
+			assert.ok(cur_frm.doc.items[0].item_name=='Test Product 1', "Item name correct");
+		},
+		() => frappe.tests.click_button('Submit'),
+		() => frappe.tests.click_button('Yes'),
+		() => frappe.timeout(0.3),
+		() => done()
+	]);
+});
+
diff --git a/erpnext/stock/doctype/material_request/tests/test_material_request_type_material_issue.js b/erpnext/stock/doctype/material_request/tests/test_material_request_type_material_issue.js
new file mode 100644
index 0000000..050e0f0
--- /dev/null
+++ b/erpnext/stock/doctype/material_request/tests/test_material_request_type_material_issue.js
@@ -0,0 +1,30 @@
+QUnit.module('Stock');
+
+QUnit.test("test material request for issue", function(assert) {
+	assert.expect(1);
+	let done = assert.async();
+	frappe.run_serially([
+		() => {
+			return frappe.tests.make('Material Request', [
+				{material_request_type:'Material Issue'},
+				{items: [
+					[
+						{'schedule_date':  frappe.datetime.add_days(frappe.datetime.nowdate(), 5)},
+						{'qty': 5},
+						{'item_code': 'Test Product 1'},
+					]
+				]},
+			]);
+		},
+		() => cur_frm.save(),
+		() => {
+			// get_item_details
+			assert.ok(cur_frm.doc.items[0].item_name=='Test Product 1', "Item name correct");
+		},
+		() => frappe.tests.click_button('Submit'),
+		() => frappe.tests.click_button('Yes'),
+		() => frappe.timeout(0.3),
+		() => done()
+	]);
+});
+
diff --git a/erpnext/stock/doctype/material_request/tests/test_material_request_type_material_transfer.js b/erpnext/stock/doctype/material_request/tests/test_material_request_type_material_transfer.js
new file mode 100644
index 0000000..d6f9b66
--- /dev/null
+++ b/erpnext/stock/doctype/material_request/tests/test_material_request_type_material_transfer.js
@@ -0,0 +1,30 @@
+QUnit.module('Stock');
+
+QUnit.test("test material request for transfer", function(assert) {
+	assert.expect(1);
+	let done = assert.async();
+	frappe.run_serially([
+		() => {
+			return frappe.tests.make('Material Request', [
+				{material_request_type:'Manufacture'},
+				{items: [
+					[
+						{'schedule_date':  frappe.datetime.add_days(frappe.datetime.nowdate(), 5)},
+						{'qty': 5},
+						{'item_code': 'Test Product 1'},
+					]
+				]},
+			]);
+		},
+		() => cur_frm.save(),
+		() => {
+			// get_item_details
+			assert.ok(cur_frm.doc.items[0].item_name=='Test Product 1', "Item name correct");
+		},
+		() => frappe.tests.click_button('Submit'),
+		() => frappe.tests.click_button('Yes'),
+		() => frappe.timeout(0.3),
+		() => done()
+	]);
+});
+
diff --git a/erpnext/tests/ui/tests.txt b/erpnext/tests/ui/tests.txt
index 6a50745..96e23e4 100644
--- a/erpnext/tests/ui/tests.txt
+++ b/erpnext/tests/ui/tests.txt
@@ -52,6 +52,9 @@
 erpnext/accounts/page/pos/test_pos.js
 erpnext/selling/doctype/product_bundle/test_product_bundle.js
 erpnext/stock/doctype/material_request/tests/test_material_request.js
+erpnext/stock/doctype/material_request/tests/test_material_request_type_material_issue.js
+erpnext/stock/doctype/material_request/tests/test_material_request_type_material_transfer.js
+erpnext/stock/doctype/material_request/tests/test_material_request_type_manufacture.js
 erpnext/schools/doctype/grading_scale/test_grading_scale.js
 erpnext/schools/doctype/assessment_criteria_group/test_assessment_criteria_group.js
 erpnext/schools/doctype/assessment_criteria/test_assessment_criteria.js
