安卓自动化测试入门-3-网络请求的单元测试

最新推荐文章于 2024-09-07 17:06:25 发布
最新推荐文章于 2024-09-07 17:06:25 发布
阅读量2.8k 收藏 1
点赞数
分类专栏： Test 文章标签： android 自动化测试

安卓自动化测试入门-3-网络请求的单元测试

本文翻译自Riggaroo的《Introduction to Android Testing – Part 3》
注意：以下的测试特指“程序员编写的自动化代码测试”
水平有限，欢迎指教。如有错漏，多多包涵。
作者的项目地址：
https://github.com/riggaroo/GithubUsersSearchApp。
请注意：每个分支对应这一系列博客的每一篇文章。

在前面两篇文章中，我介绍了如何配置编写测试的先决条件并创建了一个范例APP。接下来我们会在这篇博客中继续开发并编写单元测试。如果你还没看前两篇博客，我建议你还是阅读一下：part 1 和 part 2。

译者注：原文的链接，Part 1 和 Part 2

在这篇博客中，我们将会从Github API获取一个用户列表，并为这个功能编写测试代码。我们将会从这个repo的这个节点开始。

创建网络服务访问

我们将使用Retrofit和RxJava来访问Github API。我不准备在这个系列介绍它们。如果你不熟悉RxJava，我建议阅读这些文章。如果之前你没用过Retrofit，我建议阅读这篇。

为了根据搜索条件获取用户列表，我们需要使用下面的访问点（我将每页数量设置为2是因为API访问有限制）：

https://api.github.com/search/users?per_page=2&q=rebecca

To get more user information (such as a user’s bio and location), we need to make a subsequent call:
为了获取用户更详细的信息（例如用户的简历和地理位置），我们需要在获取列表的请求后面进行另一个请求：

https://api.github.com/users/riggaroo

  1. 在访问服务之前，我们需要在项目里面创建服务返回的JSON对象。我一般使用这个线上工具生成。让我们生成下面的两个类：User 类和 UserList 类。

    package za.co.riggaroo.gus.data.remote.model;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;

public class User {
    @SerializedName("login")
    @Expose
    private String login;
    @SerializedName("id")
    @Expose
    private Integer id;
    @SerializedName("avatar_url")
    @Expose
    private String avatarUrl;
    @SerializedName("gravatar_id")
    @Expose
    private String gravatarId;
    @SerializedName("url")
    @Expose
    private String url;
    @SerializedName("html_url")
    @Expose
    private String htmlUrl;
    @SerializedName("followers_url")
    @Expose
    private String followersUrl;
    @SerializedName("following_url")
    @Expose
    private String followingUrl;
    @SerializedName("gists_url")
    @Expose
    private String gistsUrl;
    @SerializedName("starred_url")
    @Expose
    private String starredUrl;
    @SerializedName("subscriptions_url")
    @Expose
    private String subscriptionsUrl;
    @SerializedName("organizations_url")
    @Expose
    private String organizationsUrl;
    @SerializedName("repos_url")
    @Expose
    private String reposUrl;
    @SerializedName("events_url")
    @Expose
    private String eventsUrl;
    @SerializedName("received_events_url")
    @Expose
    private String receivedEventsUrl;
    @SerializedName("type")
    @Expose
    private String type;
    @SerializedName("site_admin")
    @Expose
    private Boolean siteAdmin;
    @SerializedName("name")
    @Expose
    private String name;
    @SerializedName("company")
    @Expose
    private Object company;
    @SerializedName("blog")
    @Expose
    private String blog;
    @SerializedName("location")
    @Expose
    private String location;
    @SerializedName("email")
    @Expose
    private Object email;
    @SerializedName("hireable")
    @Expose
    private Object hireable;
    @SerializedName("bio")
    @Expose
    private String bio;
    @SerializedName("public_repos")
    @Expose
    private Integer publicRepos;
    @SerializedName("public_gists")
    @Expose
    private Integer publicGists;
    @SerializedName("followers")
    @Expose
    private Integer followers;
    @SerializedName("following")
    @Expose
    private Integer following;
    @SerializedName("created_at")
    @Expose
    private String createdAt;
    @SerializedName("updated_at")
    @Expose
    private String updatedAt;
...
}

    点击查看User完整代码

    package za.co.riggaroo.gus.data.remote.model;
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;

import java.util.ArrayList;
import java.util.List;

public class UsersList {

    @SerializedName("total_count")
    @Expose
    private Integer totalCount;
    @SerializedName("incomplete_results")
    @Expose
    private Boolean incompleteResults;
    @SerializedName("items")
    @Expose
    private List<User> items = new ArrayList<User>();

    public UsersList(final List<User> githubUsers) {
        this.items = githubUsers;
    }

    /**
     * @return The totalCount
     */
    public Integer getTotalCount() {
        return totalCount;
    }


    /**
     * @return The incompleteResults
     */
    public Boolean getIncompleteResults() {
        return incompleteResults;
    }

    /**
     * @return The items
     */
    public List<User> getItems() {
        return items;
    }


}

    译者注：作者在remote包下面新建了model包，原本的顶层model包基本不再使用。

    当这些model被创建之后，导航到za.co.riggaroo.gus.data.remote的GithubUserRestService（如果没有请新建，后面一样）。这里就是我们创建Retrofit访问的地方。

    package za.co.riggaroo.gus.data.remote;
import retrofit2.http.GET;
import retrofit2.http.Path;
import retrofit2.http.Query;
import rx.Observable;
import za.co.riggaroo.gus.data.remote.model.User;
import za.co.riggaroo.gus.data.remote.model.UsersList;

public interface GithubUserRestService {

    @GET("/search/users?per_page=2")
    Observable<UsersList> searchGithubUsers(@Query("q") String searchTerm);

    @GET("/users/{username}")
    Observable<User> getUser(@Path("username") String username);
}

    第一个接口会进行用户列表的搜索，第二个接口可以拿到更详细的用户信息。

  2. 导航到za.co.riggaroo.gus.data的UserRepositoryImpl。（译者注：作者貌似忘了UserRepositoryImpl实现的接口UserRepository，可能还是觉得没必要贴源码，毕竟从实现类可以看出被实现的接口，请记得自己补上。）我们在这里将两个网络接口访问接口融合在一起，并将接口的返回转换成前台View需要使用的数据。先用RxJava根据搜索条件获取一个用户列表，再给列表里的每一个用户发送获取详细信息的接口（译者注：这样就是用户数+1个网络请求。）（如果你自己实现了这个API的调用，我会尝试只调用一个能获取所有数据的网络访问请求 - 正如我另一篇文章《关于减少移动数据使用率》里面说的那样）。

    UserRepository

    package za.co.riggaroo.gus.data;

import java.util.List;

import rx.Observable;
import za.co.riggaroo.gus.data.remote.model.User;

public interface UserRepository {

    Observable<List<User>> searchUsers(final String searchTerm);
}

    UserRepositoryImpl

    package za.co.riggaroo.gus.data;

import java.io.IOException;
import java.util.List;

import rx.Observable;
import za.co.riggaroo.gus.data.remote.GithubUserRestService;
import za.co.riggaroo.gus.data.remote.model.User;

public class UserRepositoryImpl implements UserRepository {

    private GithubUserRestService githubUserRestService;

    public UserRepositoryImpl(GithubUserRestService githubUserRestService) {
        this.githubUserRestService = githubUserRestService;
    }

    @Override
    public Observable<List<User>> searchUsers(final String searchTerm) {
        return Observable.defer(() -> githubUserRestService.searchGithubUsers(searchTerm).concatMap(
                usersList -> Observable.from(usersList.getItems()).concatMap(
                        user -> githubUserRestService.getUser(user.getLogin())).toList()))
                .retryWhen(observable -> observable.flatMap(o -> {
                    if (o instanceof IOException) {
                        return Observable.just(null);
                    }
                    return Observable.error(o);
                }));
    }
}

    译者注：如果项目没有添加Java8支持，会提示不支持Lambda表达式。请在build.gradle里面添加jack支持以及java8支持。在android{ defaultConfig{}}里面添加jackOptions {enabled true}。在android节点里面添加
    compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
    }
    如果对上面的代码阅读困难，请看下面的解释，或者大致理解为网络接口的调用即可，不必深究细节，因为本系列的重点是测试。

    在上面的代码，我用Observable.defer()创建了一个Observable，这意味着这些observables代码只在当它有了subscriber才会运行（不像Observable.create()，这个方法会在创建之后立即运行）。正如下面的已修正的评论所说的，Observable.create()是不安全的RxJava API，不应该使用它。（译者注：原文的评论讨论了这个问题）

    当Subscriber存在时，githubUserRestService会以searchTerm为参数被调用。在那里，我用concatMap获取用户列表，并给每一个User新建一个Observable，每个Observable调用githubUserRestService.getUser()。最后的observable会合并所有返回，并转换成一张用户列表。

    在这些网络访问中，我添加了重试的机制。当IOException抛出时，retryWhen()将会重新执行observable。当用户没有可用网络时，Retrofit会抛出IOException（也许你想给重试机制加上终止条件，例如重试了一定的次数之后就停止。）。

    你可能注意到我使用了lambda表达式，你可以在项目添加Jack编译链的支持后使用它。阅读这里了解在Android中激活Java 8的支持。
    现在我们有了一个repository和获取用户列表的两个网络请求。我们应该为刚刚写好的代码编写单元测试了！

单元测试 - Mockito是什么？

为了给repository对象写单元测试，我们准备使用Mockito。Mockito是什么？Mockito是MIT许可下的面向Java的一个开源测试框架。这个框架允许我们在自动化单元测试中创建很多的测试对象（mock 对象）。（译者注：就是一些桩对象，可以给这些对象设置它们的行为，例如传入某些参数到某个方法，就可以得到对应的返回值。详细请看后面的代码。）

Mockito可以让你控制方法调用并检查对象之间的交互行为。

当我们编写单元测试时，我们需要思考如何在一个隔离的环境下去测试一个确定的组件。我们不应该去测试超出被测试类职责的功能。Mockito帮助我们做到这种隔离。

Okay，让我们开始写测试吧！

给UserRepositoryImple写单元测试

  1. 选中UserRepositoryImpl类，按下“ALT+ENTER”。在弹出菜单中选择“Create Test”。这时会弹出一个对话框：Create-Test-Dialog

  2. 你可以选择生成方法，不过我一般会让选项留空。接下来会问你要将测试代码放到哪个目录下面。选择“app/src/test”目录，因为我们在编写的是JUnit测试，这种测试不需要Android Context。Select-Test-Directory-Automated-Testing-Android

  3. 现在我们完成编写单元测试的准备工作。新建一个UserRepository成员字段。我们还需要创建一个mock的GithubUserRestService实例，这是因为在这个测试中我们不准备直接调用API。这个测试只是为了确保UserRepository能正确地完成数据转换工作。以下代码是单元测试的配置：

    @Mock
GithubUserRestService githubUserRestService;

private UserRepository userRepository;

@Before
public void setUp() throws Exception {
    MockitoAnnotations.initMocks(this);
    userRepository = new UserRepositoryImpl(githubUserRestService);
}

    导包

    import org.junit.Before;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import za.co.riggaroo.gus.data.remote.GithubUserRestService;

import static org.junit.Assert.*;

    这个被@Before注解的方法会在任何单元测试之前运行，它确保Mock对象在被使用之前就配置好。我们在setUp()中调用MockitoAnnotations.initMocks()方法，这样就使用mock出来的github服务创建了一个UserRepository实例。

  4. 我们将要写的第一个测试是用来测试GithubUserRestService被使用正确的参数调用。同时可以测试它是否返回预期的结果。下面是我编写的例子：

    @Test
public void searchUsers_200OkResponse_InvokesCorrectApiCalls() {
    //Given
    when(githubUserRestService.searchGithubUsers(anyString())).thenReturn(Observable.just(githubUserList()));
    when(githubUserRestService.getUser(anyString()))
            .thenReturn(Observable.just(user1FullDetails()), Observable.just(user2FullDetails()));

    //When
    TestSubscriber<List<User>> subscriber = new TestSubscriber<>();
    userRepository.searchUsers(USER_LOGIN_RIGGAROO).subscribe(subscriber);

    //Then
    subscriber.awaitTerminalEvent();
    subscriber.assertNoErrors();

    List<List<User>> onNextEvents = subscriber.getOnNextEvents();
    List<User> users = onNextEvents.get(0);
    Assert.assertEquals(USER_LOGIN_RIGGAROO, users.get(0).getLogin());
    Assert.assertEquals(USER_LOGIN_2_REBECCA, users.get(1).getLogin());
    verify(githubUserRestService).searchGithubUsers(USER_LOGIN_RIGGAROO);
    verify(githubUserRestService).getUser(USER_LOGIN_RIGGAROO);
    verify(githubUserRestService).getUser(USER_LOGIN_2_REBECCA);
}

private UsersList githubUserList() {
    User user = new User();
    user.setLogin(USER_LOGIN_RIGGAROO);

    User user2 = new User();
    user2.setLogin(USER_LOGIN_2_REBECCA);

    List<User> githubUsers = new ArrayList<>();
    githubUsers.add(user);
    githubUsers.add(user2);
    UsersList usersList = new UsersList();
    usersList.setItems(githubUsers);
    return usersList;
}

private User user1FullDetails() {
    User user = new User();
    user.setLogin(USER_LOGIN_RIGGAROO);
    user.setName("Rigs Franks");
    user.setAvatarUrl("avatar_url");
    user.setBio("Bio1");
    return user;
}

private User user2FullDetails() {
    User user = new User();
    user.setLogin(USER_LOGIN_2_REBECCA);
    user.setName("Rebecca Franks");
    user.setAvatarUrl("avatar_url2");
    user.setBio("Bio2");
    return user;
}

    这个测试被分割成三个部分：given，when，then。我把我的测试切分成这样是因为这样可以确保写出来的测试是结构化的，并且可以促使你去思考你正在测试的确切功能。在这个测试，我在进行这些功能的测试：给予Github Service返回的确切用户列表，当我搜索用户时，应该返回之前给予的用户列表，并且格式应该正确。

    我发现测试的命名一样非常重要。我喜欢的命名规则如下：

    [Name of method under test]_[Conditions of test case]_[Expected Result]

    所以在这个测试，这个方法的名字是searchUsers_200OkResponse_InvokesCorrectApiCalls().在这个测试里面，一个TestSubscriber被添加为搜索查询的observable的订阅者。Assertions（断言）是作用在TestSubscriber上面，来确定它拥有期待的结果。

    译者补充：

    private static final String USER_LOGIN_RIGGAROO = "riggaroo";
private static final String USER_LOGIN_2_REBECCA = "rebecca";

    导包：

    import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.util.ArrayList;
import java.util.List;

import rx.Observable;
import rx.observers.TestSubscriber;
import za.co.riggaroo.gus.data.remote.GithubUserRestService;
import za.co.riggaroo.gus.data.remote.model.User;
import za.co.riggaroo.gus.data.remote.model.UsersList;

import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

    译者注：如果还有别的编译错误，请自行补充构造函数与set方法。

  5. 下一个单元测试将会测试如果有IOException被搜索service抛出，那么网络请求将重试。

    @Test
public void searchUsers_IOExceptionThenSuccess_SearchUsersRetried() {

    // Given
    when(githubUserRestService.searchGithubUsers(anyString())).thenReturn(getIOExceptionError(), Observable.just(githubUserList()));
    when(githubUserRestService.getUser(anyString())).thenReturn(Observable.just(user1FullDetails()), Observable.just(user2FullDetails()));

    // When
    TestSubscriber<List<User>> subscriber = new TestSubscriber<>();
    userRepository.searchUsers(USER_LOGIN_RIGGAROO).subscribe(subscriber);

    // Then
    subscriber.awaitTerminalEvent();
    subscriber.assertNoErrors();

    verify(githubUserRestService, times(2)).searchGithubUsers(USER_LOGIN_RIGGAROO);

    verify(githubUserRestService).getUser(USER_LOGIN_RIGGAROO);
    verify(githubUserRestService).getUser(USER_LOGIN_2_REBECCA);

}

private Observable getIOExceptionError() {
    return Observable.error(new IOException());
}

    在这个测试中，我们断言githubUserRestService.searchGithubUsers()被调用两次，而其它的网络请求只调用一次。我们还断言subscriber没有遇到终止性的错误。

UserRepositoryImpl的最终单元测试代码

我还添加了一些上面没有提到的测试。它们用来测试不同的情况，但是它们也遵循上面提到的相同的理念。下面是完整的UserRepositoryImpl的测试代码：

package za.co.riggaroo.gus.data;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import okhttp3.MediaType;
import okhttp3.ResponseBody;
import retrofit2.Response;
import retrofit2.adapter.rxjava.HttpException;
import rx.Observable;
import rx.observers.TestSubscriber;
import za.co.riggaroo.gus.data.remote.GithubUserRestService;
import za.co.riggaroo.gus.data.remote.model.User;
import za.co.riggaroo.gus.data.remote.model.UsersList;

import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

public class UserRepositoryImplTest {

    private static final String USER_LOGIN_RIGGAROO = "riggaroo";
    private static final String USER_LOGIN_2_REBECCA = "rebecca";
    @Mock
    GithubUserRestService githubUserRestService;

    private UserRepository userRepository;

    @Before
    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);
        userRepository = new UserRepositoryImpl(githubUserRestService);
    }

    @Test
    public void searchUsers_2000kResponse_InvokesCorrectApiCalls() {

        // Given
        when(githubUserRestService.searchGithubUsers(anyString())).thenReturn(Observable.just(githubUserList()));
        when(githubUserRestService.getUser(anyString())).thenReturn(Observable.just(user1FullDetails()), Observable.just(user2FullDetails()));

        // When
        TestSubscriber<List<User>> subscriber = new TestSubscriber<>();
        userRepository.searchUsers(USER_LOGIN_RIGGAROO).subscribe(subscriber);

        // Then
        subscriber.awaitTerminalEvent();
        subscriber.assertNoErrors();

        List<List<User>> onNextEvents = subscriber.getOnNextEvents();
        List<User> users = onNextEvents.get(0);
        Assert.assertEquals(USER_LOGIN_RIGGAROO, users.get(0).getLogin());
        Assert.assertEquals(USER_LOGIN_2_REBECCA, users.get(1).getLogin());
        verify(githubUserRestService).searchGithubUsers(USER_LOGIN_RIGGAROO);
        verify(githubUserRestService).getUser(USER_LOGIN_RIGGAROO);
        verify(githubUserRestService).getUser(USER_LOGIN_2_REBECCA);
    }

    @Test
    public void searchUsers_IOExceptionThenSuccess_SearchUsersRetried() {

        // Given
        when(githubUserRestService.searchGithubUsers(anyString())).thenReturn(getIOExceptionError(), Observable.just(githubUserList()));
        when(githubUserRestService.getUser(anyString())).thenReturn(Observable.just(user1FullDetails()), Observable.just(user2FullDetails()));

        // When
        TestSubscriber<List<User>> subscriber = new TestSubscriber<>();
        userRepository.searchUsers(USER_LOGIN_RIGGAROO).subscribe(subscriber);

        // Then
        subscriber.awaitTerminalEvent();
        subscriber.assertNoErrors();

        verify(githubUserRestService, times(2)).searchGithubUsers(USER_LOGIN_RIGGAROO);

        verify(githubUserRestService).getUser(USER_LOGIN_RIGGAROO);
        verify(githubUserRestService).getUser(USER_LOGIN_2_REBECCA);

    }

    @Test
    public void searchUsers_GetUserIOExceptionThenSuccess_SearchUsersRetried() {
        // Given
        when(githubUserRestService.searchGithubUsers(anyString())).thenReturn(Observable.just(githubUserList()));
        when(githubUserRestService.getUser(anyString())).thenReturn(getIOExceptionError(), Observable.just(user1FullDetails()), Observable.just(user2FullDetails()));

        // When
        TestSubscriber<List<User>> subscriber = new TestSubscriber<>();
        userRepository.searchUsers(USER_LOGIN_RIGGAROO).subscribe(subscriber);

        // Then
        subscriber.awaitTerminalEvent();
        subscriber.assertNoErrors();

        verify(githubUserRestService, times(2)).searchGithubUsers(USER_LOGIN_RIGGAROO);

        verify(githubUserRestService, times(2)).getUser(USER_LOGIN_RIGGAROO);
        verify(githubUserRestService).getUser(USER_LOGIN_2_REBECCA);
    }

    @Test
    public void searchUsers_OtherHttpError_SearchTerminatedWithError() {
        // Given
        when(githubUserRestService.searchGithubUsers(anyString())).thenReturn(get403ForbiddenError());

        // When
        TestSubscriber<List<User>> subscriber = new TestSubscriber<>();
        userRepository.searchUsers(USER_LOGIN_RIGGAROO).subscribe(subscriber);

        // Then
        subscriber.awaitTerminalEvent();
        subscriber.assertError(HttpException.class);

        verify(githubUserRestService).searchGithubUsers(USER_LOGIN_RIGGAROO);

        verify(githubUserRestService, never()).getUser(USER_LOGIN_RIGGAROO);
        verify(githubUserRestService, never()).getUser(USER_LOGIN_2_REBECCA);

    }

    private Observable get403ForbiddenError() {
        return Observable.error(new HttpException(
                Response.error(403, ResponseBody.create(MediaType.parse("application/json"), "Forbidden"))));
    }

    private Observable getIOExceptionError() {
        return Observable.error(new IOException());
    }

    private UsersList githubUserList() {
        User user = new User();
        user.setLogin(USER_LOGIN_RIGGAROO);

        User user2 = new User();
        user2.setLogin(USER_LOGIN_2_REBECCA);

        List<User> githubUsers = new ArrayList<>();
        githubUsers.add(user);
        githubUsers.add(user2);
        UsersList usersList = new UsersList();
        usersList.setItems(githubUsers);
        return usersList;
    }


    private User user1FullDetails() {
        User user = new User();
        user.setLogin(USER_LOGIN_RIGGAROO);
        user.setName("Rigs Franks");
        user.setAvatarUrl("avatar_url");
        user.setBio("Bio1");
        return user;
    }

    private User user2FullDetails() {
        User user = new User();
        user.setLogin(USER_LOGIN_2_REBECCA);
        user.setName("Rebecca Franks");
        user.setAvatarUrl("avatar_url2");
        user.setBio("Bio2");
        return user;
    }
}

运行单元测试

在编写完测试代码之后，我们需要来运行它们，看看它们是否通过并有多少的代码覆盖率。

  1. 想运行测试，你可以右键点击测试类的名字并在弹出菜单选择“Run UserRepositoryImplTest with Coverage”。Run-unit-tests-with-coverage

  2. 你将会看到测试结果出现在Android Studio的右手边。Code-Coverage-Report-Unit-test-Android-Studio

我们在UserRepositoryImpl这个类上面的代码覆盖率达到了100%~！

在下一篇博客，我们对UI进行实现，将搜索结果展现出来并为它编写更多的测试。

寻找广州Android开发工程师工作，邮箱hengzhechenjay@163.com 电话：13580579413 陈捷尉 2016.11.22

JayChen2011
关注
专栏目录
〖Python APP 自动化测试实战篇⑤〗- appium Capability详解
易编橙 · 终身成长社群，相遇已是上上签！
06-27 4万+
我们在 app 自动化测试和 web自动化测试之间，很大的一个区别就是启动方式上的不同。 Selenium 在启动 web自动化的时候只需要一个 driver 即可，但是 app 自动化的时候就需要很多的设备信息。（就像上一章节我们实现访问通讯录的案例一样，在访问通讯录之前，设定了很多的启动参数，其实这些就是 appium 启动的时候需要携带的 Capability 的设备信息。）.....................
android studio单元测试网络请求,Android单元测试（二）测试网络请求
weixin_32716541的博客
05-26 523
上次发了那篇文章之后，有人和我说网络请求那边无法进行单元测试。按照上一章的操作去执行肯定是跑不了网络请求模块的单元测试，平时如果对网络请求模块进行单元测试，能直接判断不同的入参会有那些结果，而不用运行程序，相对刚开始开发而言还是十分方便的。所以这章就是为了补充上一章，简单聊聊为什么单元测试无法测试网络请求，然后我又是怎么处理的。一.为什么单元测试无法测试网络请求相同的问题有，为什么单元测试网络请求...
Android单元测试网络请求问题
yxf0448的博客
08-28 595
Android通过单元测试网络请求问题 单元测试中想使用okhttp但是发现okhttp回调方法不执行，发现网络请求是异步请求原因，导致断点不能拦截， 解决办法需要调用okhttp的同步请求方式进行网络请求，然后单元测试时选择debug模式执行，运行速度相对慢一些，可以得到Response。 下面是示例： 代码比较老，用的是对okhttp进行封装的库： https://github.com/hongyangAndroid/okhttputils 这个库的同步请求和异步请求查看git中的文档，execute中
Android单元测试学习总结
最新发布
2401_86968743的博客
09-07 1283
Android单元测试主要分为以下两种(Junit Test)， 本地单元测试是纯java代码的测试，只运行在本地电脑的JVM环境上，不依赖于Android框架的任何api, 因此执行速度快，效率较高，但是无法测试Android相关的代码。(Android Test)，是针对Android相关代码的测试，需要运行在真机设备或模拟器上，运行速度较慢，但是可以测试UI的交互以及对设备信息的访问，得到接近真实的测试结果。在Android Studio中新建一个项目的时候，app的gradle。
android对网络请求做单元测试等不到callback的问题
The blog of CSDN in 杨天福
05-08 6960
在做单元测试的时候如果遇到了网络请求的测试，因为牵涉到异步，如果直接运行测试代码，就会发现，测试代码走完的时候，callback还在路上没有回来，这时候一回头，发现爸爸没有了，很尴尬，所以就永远拿不到回调数据，网络上也有很多办法解决，把异步请求改为同步测试，用CountDownLatch的方式，还有rxjava的方式，但是如果网络请求用的异步的execute进行请求，这些方式我都试过了，并没有什...
android 接口单元测试,Android单元测试和接口
weixin_36410567的博客
05-26 378
原来，问题是活动必须在实际的测试方法中得到。因此，例如，我的方法现在看起来像这样：public void testGetActivityResourceString() {Activity myActivity = this.getActivity();String myString = myActivity.getResources().getString(R.string.hello);Ass...
Android接口测试和单元测试配置指南
淡淡的宁静的博客
12-10 692
添加编译依赖项 配置编译变体 配置编译版本 Gradle 提示与诀窍 使用 Lint 检查改进您的代码 从命令行进行测试 Testing in Java & JVM projects 测试应用 Android | build.gradle Android Plugin DSL Reference Writing Build Scripts ...
测试入门--6软件测试工具
03-10
9. **移动设备测试工具**：像Appium和Xamarin Test Cloud，针对移动应用的测试，支持iOS和Android平台，实现跨平台自动化测试。 在实际工作中，选择合适的测试工具取决于项目需求、团队技能和预算等因素。了解和...
appium 移动端自动化测试入门
03-10
3. **Appium Android自动化框架** - **简介**：Appium是一个开源的移动应用自动化测试框架，适用于iOS和Android平台。它支持多种编程语言，如Java、Python、Ruby等，并且能够测试原生、混合以及Web应用。 - **特点...
推荐几个超实用的开源自动化测试框架
技术专家
03-06 1097
有什么好的开源自动化测试框架可以推荐？
Android进阶之路 - 网络请求中user-agent的使用
Android、前端、小程序、后端
09-05 7000
首次听到user-agent的概念，及时来恶补一下~
Android单元测试(五)：网络接口测试
nhb687096的博客
06-08 1977
温馨提示：如果你不太熟悉单元测试，可以先看下之前四篇基础框架使用。便于你更好的理解下面的内容。在平日的开发中，我们用后台写好给我们接口去获取数据。虽然我们有一些请求接口的工具，可以快速的拿到返回数据。但是在一些异常情况的处理上就不太方便了。我列出以下几个痛点：快速的查看返回数据与数据的处理。（一般我们都是将写好的代码跑到手机上，点击到对应页面的对应按钮）异常信息的返回与处理。比如一个接口返回一个列表数据，如果列表为空呢？（找后台给我们模拟数据）网速不好呢？（不知道怎么搞…）网络异常呢？（关闭网络）
android 接口单元测试,android – 单元测试使用Mockito进行改造api调用 – ArgumentCaptor...
weixin_39866874的博客
05-26 315
请原谅我,如果我的问题看起来重复,但我没有得到如何测试改造API调用.应用程序级别的build.gradledependencies {compile fileTree(dir: 'libs', include: ['*.jar'])androidTestCompile("com.android.support.test.espresso:espresso-core:$rootProject.ex...
Android单元测试
OnAndroidWay的博客
11-30 306
单元测试是编码工作的一部分，是开发中非常重要的一个环节。现在有一种TDD的开发模式很流行，TDD(Testing Driven Development)，以测试驱动开发，这足以说明单元测试对于开发的重要性，尤其对于互联网产品开发显得格外重要，因为互联网产品有一个特点是快速多迭代，正是这个特点，单元测试的价值就更加明显。
android sdk 接口测试
weixin_30699235的博客
05-16 1114
最近接触到了第一个安卓项目，是关于安卓的接口测试的。于是呼一通找资料，看了五花八门的文章、文档，但是并没有非常适合的。 现在决定把学习的过程写下来，如果能帮到一两个跟我一样情况的就很开心了，开始学着记录学习笔记。 Android提供了一系列强大的测试工具，它针对Android的环境，扩展了JUnit测试框架。允许你为应用程序的各个方面进行更为复杂的测试，包括单元层面及框架层面。 Andro...
android 单元测试
越努力越幸运
05-06 2542
序言 当程序业务逻辑也越来越复杂的时候，测试当中出了业务逻辑的bug是最难改了。如果说你有写单元测试的习惯，通过业务逻辑的单元测试可以很容易找到出错的代码块，然后解决掉。今天来给大家介绍下android中的单元测试基本使用 What android的单元测试可以干些什么事 android的framework中提供有关单元测试的api，首先我们先来看一下api的架构体系图 由此可以见系统已经支
android studio单元测试网络请求,Android单元测试（单个Activity单元测试，网络请求单元测试，单个类单元测试）在AndroidStudio编写...
weixin_42299756的博客
05-26 354
基础配置：Module:app中增加相关配置defaultConfig中增加配置testInstrumentationRunner配置： 在Android目录下配置： 在Dependencies目录下配置： 单个类单元测试单个类的单元测试比较简单，在类中右击选择Go To--->Testpublic class JUnitBean {public int sum(int a, int b) ...
Android测试教程11--Mock之mockito，异步测试
Sanjay的专栏
12-04 5975
1. mockito是干什么的？Mock框架之一，其余的还有EasyMock，PowerMock等。 Mock说白了就是打桩（Stub）或则模拟，当你调用一个不好在测试中创建的对象时， Mock框架为你模拟一个和真实对象类似的替身来完成相应的行为 就是利用他，我们可以创建一个傀儡，然后被mock的类要返回的数据我们都可以指定！ 就像下面这样 :User user = mock(User.
使用Retrofit和Mockito进行可靠的Android API测试
哈哈Boy的专栏
11-07 2517
本文由 ImportNew - Peter Pan 翻译自 mdswanson。欢迎加入翻译小组。转载请参见文章末尾的要求。 测试与API交互的HTTP调用是一件令人生厌的复杂事情。测试一个真实的Web服务器时，一大堆问题随之产生：脆性测试（brittle test，因为网络或API本身的问题而导致的测试失败）、速度减慢测试（slow test，每一次HTTP调用都要花费好几秒）和不完全
深度探索：Android应用测试指南
7. **网络和API测试**：测试网络请求和API调用可能涉及OkHttp、Retrofit等库的使用，以及如何验证响应数据的正确性。 8. **安全性测试**：书中可能会涵盖静态代码分析、权限测试和数据加密等方面，确保应用的安全性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值