API接口自动化之2 处理http请求的返回体，对返回体做校验

举例一个接口测试的常见流程

1）发送接口请求
2）断言接口响应状态是不是200 OK
3）断言接口的响应时间低于某一个值（看情况，不是必选）
4）断言响应数据是否正确，一般的做法是判断某一个值是否相等或者包含关系

我主要接触的都是json格式返回体

只要加一个JSONObject即可，通过对返回体中的值和预期值做断言，

若断言全部通过，则用例pass

若断言有一个未通过，则用例失败

https://github.com/JasmineQian/API_JSON_Java.git

补充一下testNG中断言的用法

Assert.assertEquals 各种数据格式类型

public static void assertEquals(int actual, int expected, String message) {
assertEquals((Object)actual, (Object)expected, message);
}
public static void assertEquals(int actual, int expected) {
assertEquals((int)actual, (int)expected, (String)null);
}

源码如下

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
 
package org.testng;
 
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import org.testng.collections.Lists;
import org.testng.internal.EclipseInterface;
 
public class Assert {
    protected Assert() {
    }
 
    public static void assertTrue(boolean condition, String message) {
        if (!condition) {
            failNotEquals(condition, Boolean.TRUE, message);
        }
 
    }
 
    public static void assertTrue(boolean condition) {
        assertTrue(condition, (String)null);
    }
 
    public static void assertFalse(boolean condition, String message) {
        if (condition) {
            failNotEquals(condition, Boolean.FALSE, message);
        }
 
    }
 
    public static void assertFalse(boolean condition) {
        assertFalse(condition, (String)null);
    }
 
    public static void fail(String message, Throwable realCause) {
        AssertionError ae = new AssertionError(message);
        ae.initCause(realCause);
        throw ae;
    }
 
    public static void fail(String message) {
        throw new AssertionError(message);
    }
 
    public static void fail() {
        fail((String)null);
    }
 
    public static void assertEquals(Object actual, Object expected, String message) {
        if (expected != null || actual != null) {
            if (expected != null) {
                if (expected.getClass().isArray()) {
                    assertArrayEquals(actual, expected, message);
                    return;
                }
 
                if (expected.equals(actual)) {
                    return;
                }
            }
 
            failNotEquals(actual, expected, message);
        }
    }
 
    private static void assertArrayEquals(Object actual, Object expected, String message) {
        if (actual.getClass().isArray()) {
            int expectedLength = Array.getLength(expected);
            if (expectedLength == Array.getLength(actual)) {
                for(int i = 0; i < expectedLength; ++i) {
                    Object _actual = Array.get(actual, i);
                    Object _expected = Array.get(expected, i);
 
                    try {
                        assertEquals(_actual, _expected);
                    } catch (AssertionError var8) {
                        failNotEquals(actual, expected, message == null ? "" : message + " (values as index " + i + " are not the same)");
                    }
                }
 
                return;
            }
 
            failNotEquals(Array.getLength(actual), expectedLength, message == null ? "" : message + " (Array lengths are not the same)");
        }
 
        failNotEquals(actual, expected, message);
    }
 
    public static void assertEquals(Object actual, Object expected) {
        assertEquals((Object)actual, (Object)expected, (String)null);
    }
 
    public static void assertEquals(String actual, String expected, String message) {
        assertEquals((Object)actual, (Object)expected, message);
    }
 
    public static void assertEquals(String actual, String expected) {
        assertEquals((String)actual, (String)expected, (String)null);
    }
 
    public static void assertEquals(double actual, double expected, double delta, String message) {
        if (Double.isInfinite(expected)) {
            if (expected != actual) {
                failNotEquals(new Double(actual), new Double(expected), message);
            }
        } else if (Math.abs(expected - actual) > delta) {
            failNotEquals(new Double(actual), new Double(expected), message);
        }
 
    }
 
    public static void assertEquals(double actual, double expected, double delta) {
        assertEquals(actual, expected, delta, (String)null);
    }
 
    public static void assertEquals(float actual, float expected, float delta, String message) {
        if (Float.isInfinite(expected)) {
            if (expected != actual) {
                failNotEquals(new Float(actual), new Float(expected), message);
            }
        } else if (Math.abs(expected - actual) > delta) {
            failNotEquals(new Float(actual), new Float(expected), message);
        }
 
    }
 
    public static void assertEquals(float actual, float expected, float delta) {
        assertEquals(actual, expected, delta, (String)null);
    }
 
    public static void assertEquals(long actual, long expected, String message) {
        assertEquals((Object)actual, (Object)expected, message);
    }
 
    public static void assertEquals(long actual, long expected) {
        assertEquals(actual, expected, (String)null);
    }
 
    public static void assertEquals(boolean actual, boolean expected, String message) {
        assertEquals((Object)actual, (Object)expected, message);
    }
 
    public static void assertEquals(boolean actual, boolean expected) {
        assertEquals(actual, expected, (String)null);
    }
 
    public static void assertEquals(byte actual, byte expected, String message) {
        assertEquals((Object)actual, (Object)expected, message);
    }
 
    public static void assertEquals(byte actual, byte expected) {
        assertEquals((byte)actual, (byte)expected, (String)null);
    }
 
    public static void assertEquals(char actual, char expected, String message) {
        assertEquals((Object)actual, (Object)expected, message);
    }
 
    public static void assertEquals(char actual, char expected) {
        assertEquals((char)actual, (char)expected, (String)null);
    }
 
    public static void assertEquals(short actual, short expected, String message) {
        assertEquals((Object)actual, (Object)expected, message);
    }
 
    public static void assertEquals(short actual, short expected) {
        assertEquals((short)actual, (short)expected, (String)null);
    }
 
    public static void assertEquals(int actual, int expected, String message) {
        assertEquals((Object)actual, (Object)expected, message);
    }
 
    public static void assertEquals(int actual, int expected) {
        assertEquals((int)actual, (int)expected, (String)null);
    }
 
    public static void assertNotNull(Object object) {
        assertNotNull(object, (String)null);
    }
 
    public static void assertNotNull(Object object, String message) {
        if (object == null) {
            String formatted = "";
            if (message != null) {
                formatted = message + " ";
            }
 
            fail(formatted + "expected object to not be null");
        }
 
        assertTrue(object != null, message);
    }
 
    public static void assertNull(Object object) {
        assertNull(object, (String)null);
    }
 
    public static void assertNull(Object object, String message) {
        if (object != null) {
            failNotSame(object, (Object)null, message);
        }
 
    }
 
    public static void assertSame(Object actual, Object expected, String message) {
        if (expected != actual) {
            failNotSame(actual, expected, message);
        }
    }
 
    public static void assertSame(Object actual, Object expected) {
        assertSame(actual, expected, (String)null);
    }
 
    public static void assertNotSame(Object actual, Object expected, String message) {
        if (expected == actual) {
            failSame(actual, expected, message);
        }
 
    }
 
    public static void assertNotSame(Object actual, Object expected) {
        assertNotSame(actual, expected, (String)null);
    }
 
    private static void failSame(Object actual, Object expected, String message) {
        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }
 
        fail(formatted + EclipseInterface.ASSERT_LEFT2 + expected + EclipseInterface.ASSERT_MIDDLE + actual + EclipseInterface.ASSERT_RIGHT);
    }
 
    private static void failNotSame(Object actual, Object expected, String message) {
        String formatted = "";
        if (message != null) {
            formatted = message + " ";
        }
 
        fail(formatted + EclipseInterface.ASSERT_LEFT + expected + EclipseInterface.ASSERT_MIDDLE + actual + EclipseInterface.ASSERT_RIGHT);
    }
 
    private static void failNotEquals(Object actual, Object expected, String message) {
        fail(format(actual, expected, message));
    }
 
    static String format(Object actual, Object expected, String message) {
        String formatted = "";
        if (null != message) {
            formatted = message + " ";
        }
 
        return formatted + EclipseInterface.ASSERT_LEFT + expected + EclipseInterface.ASSERT_MIDDLE + actual + EclipseInterface.ASSERT_RIGHT;
    }
 
    public static void assertEquals(Collection<?> actual, Collection<?> expected) {
        assertEquals((Collection)actual, (Collection)expected, (String)null);
    }
 
    public static void assertEquals(Collection<?> actual, Collection<?> expected, String message) {
        if (actual != expected) {
            if (actual == null || expected == null) {
                if (message != null) {
                    fail(message);
                } else {
                    fail("Collections not equal: expected: " + expected + " and actual: " + actual);
                }
            }
 
            assertEquals(actual.size(), expected.size(), message + ": lists don't have the same size");
            Iterator<?> actIt = actual.iterator();
            Iterator<?> expIt = expected.iterator();
            int i = -1;
 
            while(actIt.hasNext() && expIt.hasNext()) {
                ++i;
                Object e = expIt.next();
                Object a = actIt.next();
                String explanation = "Lists differ at element [" + i + "]: " + e + " != " + a;
                String errorMessage = message == null ? explanation : message + ": " + explanation;
                assertEquals(a, e, errorMessage);
            }
 
        }
    }
 
    public static void assertEquals(Iterator<?> actual, Iterator<?> expected) {
        assertEquals((Iterator)actual, (Iterator)expected, (String)null);
    }
 
    public static void assertEquals(Iterator<?> actual, Iterator<?> expected, String message) {
        if (actual != expected) {
            if (actual == null || expected == null) {
                if (message != null) {
                    fail(message);
                } else {
                    fail("Iterators not equal: expected: " + expected + " and actual: " + actual);
                }
            }
 
            int i = -1;
 
            while(actual.hasNext() && expected.hasNext()) {
                ++i;
                Object e = expected.next();
                Object a = actual.next();
                String explanation = "Iterators differ at element [" + i + "]: " + e + " != " + a;
                String errorMessage = message == null ? explanation : message + ": " + explanation;
                assertEquals(a, e, errorMessage);
            }
 
            String explanation;
            String errorMessage;
            if (actual.hasNext()) {
                explanation = "Actual iterator returned more elements than the expected iterator.";
                errorMessage = message == null ? explanation : message + ": " + explanation;
                fail(errorMessage);
            } else if (expected.hasNext()) {
                explanation = "Expected iterator returned more elements than the actual iterator.";
                errorMessage = message == null ? explanation : message + ": " + explanation;
                fail(errorMessage);
            }
 
        }
    }
 
    public static void assertEquals(Iterable<?> actual, Iterable<?> expected) {
        assertEquals((Iterable)actual, (Iterable)expected, (String)null);
    }
 
    public static void assertEquals(Iterable<?> actual, Iterable<?> expected, String message) {
        if (actual != expected) {
            if (actual == null || expected == null) {
                if (message != null) {
                    fail(message);
                } else {
                    fail("Iterables not equal: expected: " + expected + " and actual: " + actual);
                }
            }
 
            Iterator<?> actIt = actual.iterator();
            Iterator<?> expIt = expected.iterator();
            assertEquals(actIt, expIt, message);
        }
    }
 
    public static void assertEquals(Object[] actual, Object[] expected, String message) {
        if (actual != expected) {
            if (actual == null && expected != null || actual != null && expected == null) {
                if (message != null) {
                    fail(message);
                } else {
                    fail("Arrays not equal: " + Arrays.toString(expected) + " and " + Arrays.toString(actual));
                }
            }
 
            assertEquals((Collection)Arrays.asList(actual), (Collection)Arrays.asList(expected), message);
        }
    }
 
    public static void assertEqualsNoOrder(Object[] actual, Object[] expected, String message) {
        if (actual != expected) {
            if (actual == null && expected != null || actual != null && expected == null) {
                failAssertNoEqual("Arrays not equal: " + Arrays.toString(expected) + " and " + Arrays.toString(actual), message);
            }
 
            if (actual.length != expected.length) {
                failAssertNoEqual("Arrays do not have the same size:" + actual.length + " != " + expected.length, message);
            }
 
            List<Object> actualCollection = Lists.newArrayList();
            Object[] arr$ = actual;
            int len$ = actual.length;
 
            int i$;
            Object o;
            for(i$ = 0; i$ < len$; ++i$) {
                o = arr$[i$];
                actualCollection.add(o);
            }
 
            arr$ = expected;
            len$ = expected.length;
 
            for(i$ = 0; i$ < len$; ++i$) {
                o = arr$[i$];
                actualCollection.remove(o);
            }
 
            if (actualCollection.size() != 0) {
                failAssertNoEqual("Arrays not equal: " + Arrays.toString(expected) + " and " + Arrays.toString(actual), message);
            }
 
        }
    }
 
    private static void failAssertNoEqual(String defaultMessage, String message) {
        if (message != null) {
            fail(message);
        } else {
            fail(defaultMessage);
        }
 
    }
 
    public static void assertEquals(Object[] actual, Object[] expected) {
        assertEquals((Object[])actual, (Object[])expected, (String)null);
    }
 
    public static void assertEqualsNoOrder(Object[] actual, Object[] expected) {
        assertEqualsNoOrder(actual, expected, (String)null);
    }
 
    public static void assertEquals(byte[] actual, byte[] expected) {
        assertEquals(actual, expected, "");
    }
 
    public static void assertEquals(byte[] actual, byte[] expected, String message) {
        if (expected != actual) {
            if (null == expected) {
                fail("expected a null array, but not null found. " + message);
            }
 
            if (null == actual) {
                fail("expected not null array, but null found. " + message);
            }
 
            assertEquals(actual.length, expected.length, "arrays don't have the same size. " + message);
 
            for(int i = 0; i < expected.length; ++i) {
                if (expected[i] != actual[i]) {
                    fail("arrays differ firstly at element [" + i + "]; " + "expected value is <" + expected[i] + "> but was <" + actual[i] + ">. " + message);
                }
            }
 
        }
    }
 
    public static void assertEquals(Set<?> actual, Set<?> expected) {
        assertEquals((Set)actual, (Set)expected, (String)null);
    }
 
    public static void assertEquals(Set<?> actual, Set<?> expected, String message) {
        if (actual != expected) {
            if (actual == null || expected == null) {
                if (message == null) {
                    fail("Sets not equal: expected: " + expected + " and actual: " + actual);
                } else {
                    failNotEquals(actual, expected, message);
                }
            }
 
            if (!actual.equals(expected)) {
                if (message == null) {
                    fail("Sets differ: expected " + expected + " but got " + actual);
                } else {
                    failNotEquals(actual, expected, message);
                }
            }
 
        }
    }
 
    public static void assertEquals(Map<?, ?> actual, Map<?, ?> expected) {
        if (actual != expected) {
            if (actual == null || expected == null) {
                fail("Maps not equal: expected: " + expected + " and actual: " + actual);
            }
 
            if (actual.size() != expected.size()) {
                fail("Maps do not have the same size:" + actual.size() + " != " + expected.size());
            }
 
            Set<?> entrySet = actual.entrySet();
            Iterator iterator = entrySet.iterator();
 
            while(iterator.hasNext()) {
                Entry<?, ?> entry = (Entry)iterator.next();
                Object key = entry.getKey();
                Object value = entry.getValue();
                Object expectedValue = expected.get(key);
                assertEquals(value, expectedValue, "Maps do not match for key:" + key + " actual:" + value + " expected:" + expectedValue);
            }
 
        }
    }
 
    public static void assertNotEquals(Object actual1, Object actual2, String message) {
        boolean fail = false;
 
        try {
            assertEquals(actual1, actual2);
            fail = true;
        } catch (AssertionError var5) {
            ;
        }
 
        if (fail) {
            fail(message);
        }
 
    }
 
    public static void assertNotEquals(Object actual1, Object actual2) {
        assertNotEquals((Object)actual1, (Object)actual2, (String)null);
    }
 
    static void assertNotEquals(String actual1, String actual2, String message) {
        assertNotEquals((Object)actual1, (Object)actual2, message);
    }
 
    static void assertNotEquals(String actual1, String actual2) {
        assertNotEquals((String)actual1, (String)actual2, (String)null);
    }
 
    static void assertNotEquals(long actual1, long actual2, String message) {
        assertNotEquals((Object)actual1, (Object)actual2, message);
    }
 
    static void assertNotEquals(long actual1, long actual2) {
        assertNotEquals(actual1, actual2, (String)null);
    }
 
    static void assertNotEquals(boolean actual1, boolean actual2, String message) {
        assertNotEquals((Object)actual1, (Object)actual2, message);
    }
 
    static void assertNotEquals(boolean actual1, boolean actual2) {
        assertNotEquals(actual1, actual2, (String)null);
    }
 
    static void assertNotEquals(byte actual1, byte actual2, String message) {
        assertNotEquals((Object)actual1, (Object)actual2, message);
    }
 
    static void assertNotEquals(byte actual1, byte actual2) {
        assertNotEquals((byte)actual1, (byte)actual2, (String)null);
    }
 
    static void assertNotEquals(char actual1, char actual2, String message) {
        assertNotEquals((Object)actual1, (Object)actual2, message);
    }
 
    static void assertNotEquals(char actual1, char actual2) {
        assertNotEquals((char)actual1, (char)actual2, (String)null);
    }
 
    static void assertNotEquals(short actual1, short actual2, String message) {
        assertNotEquals((Object)actual1, (Object)actual2, message);
    }
 
    static void assertNotEquals(short actual1, short actual2) {
        assertNotEquals((short)actual1, (short)actual2, (String)null);
    }
 
    static void assertNotEquals(int actual1, int actual2, String message) {
        assertNotEquals((Object)actual1, (Object)actual2, message);
    }
 
    static void assertNotEquals(int actual1, int actual2) {
        assertNotEquals((int)actual1, (int)actual2, (String)null);
    }
 
    public static void assertNotEquals(float actual1, float actual2, float delta, String message) {
        boolean fail = false;
 
        try {
            assertEquals(actual1, actual2, delta, message);
            fail = true;
        } catch (AssertionError var6) {
            ;
        }
 
        if (fail) {
            fail(message);
        }
 
    }
 
    public static void assertNotEquals(float actual1, float actual2, float delta) {
        assertNotEquals(actual1, actual2, delta, (String)null);
    }
 
    public static void assertNotEquals(double actual1, double actual2, double delta, String message) {
        boolean fail = false;
 
        try {
            assertEquals(actual1, actual2, delta, message);
            fail = true;
        } catch (AssertionError var9) {
            ;
        }
 
        if (fail) {
            fail(message);
        }
 
    }
 
    public static void assertNotEquals(double actual1, double actual2, double delta) {
        assertNotEquals(actual1, actual2, delta, (String)null);
    }
}

API接口自动化之2 处理http请求的返回体，对返回体做校验的更多相关文章

python接口自动化（十）--post请求四种传送正文方式（详解）
简介 post请求我在python接口自动化(八)--发送post请求的接口(详解)已经讲过一部分了,主要是发送一些较长的数据,还有就是数据比较安全等.我们要知道post请求四种传送正文方式首先需要先 ...
python+pytest接口自动化(4)-requests发送get请求
python中用于请求http接口的有自带的urllib和第三方库requests,但 urllib 写法稍微有点繁琐,所以在进行接口自动化测试过程中,一般使用更为简洁且功能强大的 requests ...
API接口自动化之1 常见的http请求
常见的HTTP请求就我所想到的,目前如果想做http/https请求接口自动户化,要处理的一些区别 get请求post请求 httphttps 单个值键值对键值对的搭配方式 POST请求体,后续讲一 ...
API接口自动化之3 同一个war包中多个接口做自动化测试
同一个war包中多个接口做自动化测试一个接口用一个测试类,每个测试用例如下,比如下面是4个测试用例,每个详细的测试用例中含有请求入参,返回体校验,以此来判断每条测试用例是否通过一个war包中,若含 ...
python接口自动化一（发送get请求）
一.环境安装 1.用pip安装requests模块 >>pip install requests 二.get请求 1.导入requests后,用get方法就能直接访问url地址,如:htt ...
Python接口自动化【requests处理Token请求】
首先说一下使用python模拟登录或注册时,对于带token的页面怎么登录注册模拟的思路: 1.对于带token的页面,需要先从最开始的页面获取合法token 2.然后使用获取到的合法token进行后 ...
python接口自动化-发xml格式post请求
前言 post请求相对于get请求多一个body部分,body部分常见的数据类型有以下四种(注意是常见的,并不是只有4种) application/x-www-form-urlencoded appl ...
Jenkins 对项目持续集成的配置之二 API接口自动化 Ant+Jmeter
先介绍一下Ant+Jmeter 略我的另一篇文章有讲在linux上部署ant + jmeter以满足CI持续化集成 https://www.cnblogs.com/qianjinyan/p/9067 ...
REST API 自动化测试利器Rest Assured（API接口自动化测试框架体系）
现在,越来越多的 Web 应用转向了 RESTful 的架构,很多产品和应用暴露给用户的往往就是一组 REST API,这样有一个好处,用户可以根据需要,调用不同的 API,整合出自己的应用出来.从这 ...

随机推荐

SVM入门——线性分类器的求解，核函数
一.问题的描述从最一般的定义上说,一个求最小值的问题就是一个优化问题(也叫寻优问题,更文绉绉的叫法是规划——Programming),它同样由两部分组成,目标函数和约束条件,可以用下面的式子表示: ...
nodejs 将网上的图片下载到本地文件
var request = require('request'); var fs = require('fs'); var img_src = 'https://www.baidu.com/img/b ...
最新可靠好用的DNS服务器地址汇总
如果修改DNS服务器地址就可以访问google等服务,你还等什么?使用免费DNS解析服务除了去掉了运营商的各种广告,还有个最大的好处就是不会重定向或者过滤用户所访问的地址,这样就防止了很多网站被电信. ...
Linear Regression Using Least Squares Method 代码实现
1. 原理 2. Octave function theta = leastSquaresMethod(X, y) theta = pinv(X' * X) * X' * y; 3. Python # ...
codefirst configuration
codefirst 书写配置类,用于entity与数据库中表或view映射 1.对应表或视图都用this.ToTable("SimpleCompanyLoanView", &quo ...
JSON—序列化
表单数据的序列化用SerializeArray()将有效控件序列化为JSON对象数组? 包含name和value两个属性 SerializeArray()检测一组表单元素中的有效控件? 1.没有 ...
no-siteapp 和 no-transform
简单的说,是禁止转码 . 举个通俗的例子. 你建了一栋房子(网站),百度说我给你做个大门,但是大门上要有我的广告你不愿意,就建立了一条路叫no-transform 别人去你家走这条路就行了后来百度 ...
ORTP编译为静态库的问题
项目中需要用到ORTP,我采用的编译环境是 VC2013,当我在项目设置中将设置为静态库是,发现没有导出函数,比如在需要连接 oRTP.lib库时提示找不到 ORTP_init; 解决办法是 :在O ...
linux常用命令：ping 命令
Linux系统的ping 命令是常用的网络命令,它通常用来测试与目标主机的连通性,我们经常会说“ping一下某机器,看是不是开着”.不能打开网页时会说“你先ping网关地址192.168.1.1试试 ...
Linux基础命令---tune2fs
tune2fs tune2fs允许系统管理员在Linux ext2.ext3或ext4文件系统上调整各种可调的文件系统参数.这些选项的当前值可以使用-l选项显示,也可以通过使用dumpe2fs (8) ...

API接口自动化之2 处理http请求的返回体，对返回体做校验

API接口自动化之2 处理http请求的返回体，对返回体做校验的更多相关文章

随机推荐

热门专题