diff --git a/apps/yms/app/src/test/resources/ychTestResourceFiles/configrootnameOperationType.xml b/apps/yms/app/src/test/resources/ychTestResourceFiles/configrootnameOperationType.xml
new file mode 100644
index 0000000..6cecea49
--- /dev/null
+++ b/apps/yms/app/src/test/resources/ychTestResourceFiles/configrootnameOperationType.xml
@@ -0,0 +1,20 @@
+<rpc message-id="101"
+     xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
+    <edit-config>
+        <target>
+            <running/>
+        </target>
+        <config xmlns:xc="urn:ietf:params:xml:ns:netconf:base:1.0">
+            <Logistics-manager xmlns="ydt.root">
+                <Customs-supervisor>abc</Customs-supervisor>
+                <Purchasing-supervisor xmlns="ydt.root" operation="delete">
+                    <purchasing-specialist>bcd</purchasing-specialist>
+                    <support>cde</support>
+                </Purchasing-supervisor>
+            </Logistics-manager>
+            <merchandisersupervisor xmlns="ydt.Merchandiser-supervisor">
+                <supervisor>abc</supervisor>
+            </merchandisersupervisor>
+        </config>
+    </edit-config>
+</rpc>
\ No newline at end of file
