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

后端 未结 6 1393
闹比i
闹比i 2021-01-06 12:41

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

    {
    \"glossary\": {
        \"title\": \"example glossary\",
        \"Gloss         


        
相关标签:
6条回答
  • 2021-01-06 13:21

    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;
    
    0 讨论(0)
  • 2021-01-06 13:27

    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
        });
    });
    
    0 讨论(0)
  • 2021-01-06 13:27

    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.

    0 讨论(0)
  • 2021-01-06 13:32

    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.

    0 讨论(0)
  • 2021-01-06 13:37

    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");
    
    0 讨论(0)
  • 2021-01-06 13:38

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

    Click Here

    0 讨论(0)
提交回复
热议问题