Raw body (text, XML) in Postman - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Postman test script?

You send a POST request with raw XML body:

<note>
  <to>Alice</to>
  <from>Bob</from>
  <message>Hello</message>
</note>

In the Tests tab, you run this script:

const xml = pm.request.body.raw;
pm.test('Contains <to> tag', () => {
  pm.expect(xml).to.include('<to>Alice</to>');
});

What will be the test result?

Postman

const xml = pm.request.body.raw;
pm.test('Contains <to> tag', () => {
  pm.expect(xml).to.include('<to>Alice</to>');
});

A Test fails because the XML tags are case-sensitive and '<to>' is lowercase.

B Test fails because pm.request.body.raw is undefined in Postman scripts.

C Test passes because the raw XML contains the exact string '<to>Alice</to>'.

D Test throws a syntax error due to incorrect use of pm.expect.

💡 Hint

pm.request.body.raw contains the raw request body as a string.

The raw body string includes the exact substring 'Alice', so the assertion pm.expect(xml).to.include(...) passes.

❓ assertion

intermediate

Which assertion correctly verifies the raw XML body contains the tag with 'Hello'?

You want to check that the raw XML body sent in a POST request contains the tag <message>Hello</message>.
Which Postman test assertion is correct?

A pm.expect(pm.request.body.text).to.have.string('<message>Hello</message>');

B pm.expect(pm.response.text()).to.include('<message>Hello</message>');

C pm.expect(pm.request.body.raw).to.equal('<message>Hello</message>');

D pm.expect(pm.request.body.raw).to.include('<message>Hello</message>');

💡 Hint

pm.request.body.raw holds the raw request body as a string.

Option D correctly checks if the raw request body string includes the exact substring 'Hello'. Option D checks response, not request. Option D requires exact match, which is unlikely. Option D uses a wrong property 'body.text'.

🔧 Debug

advanced

Why does this Postman test fail with 'TypeError: Cannot read property "raw" of undefined'?

You wrote this test script:

const xml = pm.request.body.raw;
pm.test('Check XML', () => {
  pm.expect(xml).to.include('<to>Alice</to>');
});

But when you run it, you get:

TypeError: Cannot read property "raw" of undefined

What is the most likely cause?

Postman

const xml = pm.request.body.raw;
pm.test('Check XML', () => {
  pm.expect(xml).to.include('<to>Alice</to>');
});

A pm.request.body.raw is only available in pre-request scripts, not test scripts.

B The request body is not set or is empty, so pm.request.body is undefined.

C You must parse the XML before accessing pm.request.body.raw.

D Postman does not support raw XML bodies in requests.

💡 Hint

Check if the request body is configured in the request.

If the request body is not set or is empty, pm.request.body is undefined, causing the error when accessing .raw.

🧠 Conceptual

advanced

What is the best way to validate the structure of a raw XML body in Postman tests?

You want to verify that the raw XML body sent in a POST request has a specific structure, for example, it contains a <note> root with <to> and <from> child tags.
Which approach is best in Postman test scripts?

A Parse the raw XML string using a DOM parser library and check the presence of tags programmatically.

B Use pm.expect(pm.request.body.raw).to.include() with multiple string checks for each tag.

C Convert the XML to JSON using an external tool before sending the request and test JSON instead.

D Use regex matching on pm.request.body.raw to find the required tags.

💡 Hint

Postman test scripts can use JavaScript libraries to parse XML.

Parsing XML with a DOM parser allows precise validation of structure and content, better than fragile string includes or regex.

❓ framework

expert

How to automate testing of raw XML request bodies in a CI pipeline using Postman/Newman?

You have Postman collections with requests sending raw XML bodies. You want to run automated tests in a CI pipeline using Newman.
Which practice ensures reliable validation of raw XML bodies in this setup?

A Include test scripts that parse pm.request.body.raw XML and assert structure/content using JavaScript XML parsers, then run Newman in CI.

B Only check HTTP status codes in Newman tests, ignoring raw XML body validation to avoid complexity.

C Convert XML bodies to JSON before sending requests, so Newman can validate JSON easily.

D Use Newman environment variables to store XML strings and compare them as plain text in tests.

💡 Hint

Automated tests should validate XML content programmatically for reliability.

Parsing XML in test scripts and asserting structure/content is the most reliable way to validate raw XML bodies in automated CI runs with Newman.