How to write a postman test to compare the response json against another json?

Question

I have the below json response after running a postMan test of a Rest API:

    {
    "glossary": {
        "title": "example glossary",
        "GlossDiv": {
            "title": "S",
            "GlossList": {
                "GlossEntry": {
                    "ID": "SGML",
                    "SortAs": "SGML",
                    "GlossTerm": "Standard Generalized Markup Language",
                    "Acronym": "SGML",
                    "Abbrev": "ISO 8879:1986",
                    "GlossDef": {
                        "para": "A meta-markup language, used to create markup languages such as DocBook.",
                        "GlossSeeAlso": ["GML", "XML"]
                    },
                    "GlossSee": "markup"
                }
            }
        }
    }
}

Now I would like to compare the above json against a predefined json. Say, its the same as above.

How can I compare two jsons via the Postman test?

Praveesh, you should accept one of the answers below is they solve you problem. — Mike, May 25 '20 at 12:57
This was an old project I did long back. Dropped it in between. I will try out if I get time. — Praveesh P, May 25 '20 at 14:37

Mike · Answer 1 · 2019-05-15T15:13:49.127

I had a similar problem to solve except that my JSON also contained an array of objects. I used the following technique that can be modified to deal with the simple array of strings in your question.I created an array of global functions called "assert", which contained helper functions such as "areEqual" and "areArraysOfObjectsEqual" and saved these under the "Tests" tab at a top folder level of my tests.

assert = {
    areEqual: (actual, expected, objectName) => {
        pm.test(`Actual ${objectName} '` + actual + `' matches Expected ${objectName} '` + expected + `'`, () => {
            pm.expect(_.isEqual(actual, expected)).to.be.true;
        });
    },
    areArraysOfObjectsEqual: (actual, expected, objectName) => {
        if (!_.isEqual(actual, expected)) {

            // Arrays are not equal so report what the differences are
            for (var indexItem = 0; indexItem < expected.length; indexItem++) {
                assert.compareArrayObject(actual[indexItem], expected[indexItem], objectName);
            }
        }
        else
        {
            // This fake test will always pass and is just here for displaying output to highlight that the array has been verified as part of the test run
            pm.test(`actual '${objectName}' array matches expected '${objectName}' array`);
        }
    },
    compareArrayObject: (actualObject, expectedObject, objectName) => {
        for (var key in expectedObject) {
            if (expectedObject.hasOwnProperty(key)) {
                assert.areEqual(expectedObject[key], actualObject[key], objectName + " - " + key);
            }
        }
    }
};

Your "Pre-request Script" for a test would set your expected object

 const expectedResponse =
    {
        "id": "3726b0d7-b449-4088-8dd0-74ece139f2bf",
        "array": [
            {
                "item": "ABC",
                "value": 1
            },
            {
                "item": "XYZ",
                "value": 2
            }
        ]
    };

    pm.globals.set("expectedResponse", expectedResponse);

Your Test would test each item individually or at the array level like so:

const actualResponse = JSON.parse(responseBody);
const expectedResponse = pm.globals.get("expectedResponse");

assert.areEqual(
    actualResponse.id,
    expectedResponse.id,
    "id");

assert.areArraysOfObjectsEqual(
    actualResponse.myArray,
    expectedResponse.myArray,
    "myArrayName");

This technique will give nice "property name actual value matches expected value" output and works with arrays of objects being part of the JSON being compared.

Update: To test your array of strings "GlossSeeAlso", simply call the supplied global helper method in any of your tests like so:

assert.compareArrayObject(
    actualResponse.glossary.GlossDiv.GlossList.GlossEntry.GlossDef.GlossSeeAlso,       
    expectedResponse.glossary.GlossDiv.GlossList.GlossEntry.GlossDef.GlossSeeAlso,
    "glossary.GlossDiv.GlossList.GlossEntry.GlossDef.GlossSeeAlso");

Primitive types in JSON key value pairs can be tested like so:

assert.areEqual(
    actualResponse.glossary.title,
    expectedResponse.glossary.title,
    "glossary.title");

Luat Vu Dinh · Answer 2 · 2019-11-01T08:34:48.777

3

I got it after a while. Add test into your request and use Runner to run all your requests in the collection.

Postman info: Version 7.10.0 for Mac.

Test scripts:

pm.test("Your test name", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData).to.eql({
        "key1": "value1",
        "key2": 100
    });
});

edited Nov 01 '19 at 08:34

answered Nov 01 '19 at 07:57

Luat Vu Dinh

460
6
10

Yogen Darji · Answer 3 · 2020-07-01T13:58:01.340

2

You can write javascript code inside Tests tab of Postman. Just write simple code to compare and check result in Tests.

var serverData = JSON.parse(responseBody);
var JSONtoCompare = {}; //set your predefined JSON here.
tests["Body is correct"] = serverData === JSONtoCompare;

edited Jul 01 '20 at 13:58

answered Aug 10 '17 at 14:18

Yogen Darji

3,230
16
31

1

Hi @yogen darji, I tried this, but the test fails with a "Body is incorrect" message. – Praveesh P Aug 11 '17 at 04:32
@PraveeshP Did you get 400 Bad request or 200 OK as response? – Yogen Darji Aug 11 '17 at 05:44
@PraveeshP If find found answer useful then please mark as a answer :) – Yogen Darji Aug 11 '17 at 06:52
Its not working. I meant to say that my first test was just to check for 200 response code and it worked. But the second one was to compare json that is failing. – Praveesh P Aug 11 '17 at 09:56
This isn't a scalable solution if your `JSONtoCompare` is a massive object, spanning hundreds of lines. – The Unknown Dev Oct 18 '18 at 19:23

score 2 · Answer 4 · answered Aug 30 '18 at 21:41

You can paste this code into your collection or single request tests tab.

What this code do is to save the request into a global variable with a key for that request. You can change your enviroment and hit the same request and if the response are different the test will fail.

const responseKey = [pm.info.requestName, 'response'].join('/');
let res = '';
try {
    res = JSON.stringify(pm.response.json());
} catch(e) {
    res = pm.response.text();
}

if (!pm.globals.has(responseKey)) {
    pm.globals.set(responseKey, res);
} else {    
    pm.test(responseKey, function () {
        const response = pm.globals.get(responseKey);
        pm.globals.unset(responseKey);
        try {
            const data = pm.response.json();
            pm.expect(JSON.stringify(data)).to.eql(response);
        } catch(e) {
            const data = pm.response.text();
            pm.expect(data).to.eql(response);
        }
    });
}

Hope this help.

This is really smart @Anthony. I hope we will see more answers from you on SO. — AutomatedChaos, Oct 30 '18 at 07:02

score 1 · Answer 5 · edited May 03 '18 at 03:17

1

Looks like the same question asked at POSTMAN: Comparing object Environment variable with response's object which also lists a solution that works, which is to use JSON.stringify() to turn the objects into strings and then compare the strings.

edited May 03 '18 at 03:17

4b0

21,981
30
95
142

answered May 01 '18 at 17:25

Steve Meierhofer

123
1
8

It is worthwhile to read the comment under the proposed solution: the order of objects matter when comparing two stringified JSONs which can lead to false mismatches. Postman supports a comprehensive assertion framework that allows you to compare JSONs on an object level and not as a string representation. I would rather use one of the solutions that uses the object representation than to go for the `JSON.stringify()` route. – AutomatedChaos Oct 30 '18 at 06:59

Jonathan Turnock · Answer 6 · 2021-12-10T22:26:49.400

Came across this issue when migrating from a legacy API to a new one and wanting to assert the new API is exactly the same as the old under different scenarios

For context this clones params of the original get request to the legacy endpoint and validates both match up

LEGACY_API_URL should be defined in the environment and the Request is going to the new API

const { Url } = require('postman-collection');

// Setup the URL for the Legacy API
const legacyRequestUrl = new Url({ host: pm.variables.replaceIn("http://{{LEGACY_API_HOST}}/blah")});

// Add All Parameters From the Source Query
legacyRequestUrl.addQueryParams(pm.request.url.query.all());

// Log out the URL For Debugging Purposes
console.log("URL", legacyRequestUrl.toString());

pm.sendRequest(legacyRequestUrl.toString(), function (err, response) {
    pm.test('New API Response Matches Legacy API Response', function () {

        // Log Out Responses for Debugging Purposes
        console.log("New API Response", pm.response.json())
        console.log("Legacy API Response", response.json())

        // Assert Both Responses are Equal
        pm.expect(_.isEqual(pm.response.json(), response.json())).to.be.true
    });
});

Link to an example collection

https://www.getpostman.com/collections/4ff9953237c0ab1bce99

score -3 · Answer 7 · answered Aug 14 '17 at 10:18

-3

Write JavaScript code under 'Tests' section. Refer below link for more info.

Click Here

answered Aug 14 '17 at 10:18

Vyasaraj

23
3

4

First, don't just tell people to blindly follow a link. Include the useful information in your answer in case the link goes down. Second, if you want to advertise your own site in an answer the least you can do is disclose that and point them to the exact spot that answers the question. – The Unknown Dev Oct 18 '18 at 19:20

How to write a postman test to compare the response json against another json?

7 Answers7

Linked