"Organizing crossplatform API automation testing" from Sergey Zenchenko

The presentation is about how to test your server API and share API client between tests and mobile app.
Find more useful slides at Sergey's account: https://speakerdeck.com/sergeyzenchenko

Transcript

1. API Testing Break your API before your customer does Sergey Zenchenko CTO
2. • > 100 endpoints • ~ 40 team members • 2 mobile platforms + backend • Micro-services architecture • Need for tests Given
3. Evolution
4. Codeception • PHP sucks • Concurrency support is limited • API client is low level and verbose • Hard to maintain large test suite • No static typing • Code is not reusable codeception.com
5. Runscope • UI Based • Slooooow • Hard to maintain large test suite • Code is not reusable runscope.com
6. Mocha/Supertest/ Chakram • API client is low level and verbose • Concurrency support is limited • Hard to maintain large test suite • No static typing • Code is not reusable https://mochajs.org https://github.com/visionmedia/supertest http://dareid.github.io/chakram/
7. Bright future
8. Requirements • Parallel execution • Simple test structure. No async in tests • Test should operate with business domain, not with HTTP requests • Work with Objects not JSON and Strings • Static typing • Code reusability
9. Java to the rescue! • Already used in the Android app for UI tests • Can be shared between multiple components • Good concurrency support • Mature test frameworks
10. Main components • Test framework • Domain models • API Client • Support: assertions frameworks, reporting tool, etc
11. TestNG • xUnit style • Parallel test execution • Powerful concurrency management using method and group dependencies • Nice features like data providers testng.org
12. Models • Request models • Response models • Assertions for models attrs., not for JSON/XML attrs. Never work with raw data • Response structure validation should be done by model parser, not by humans
13. POJOs More samples
 See https://github.com/techery/janet-sample-api-integration public class User { int id; String param; }
14. Immutable Objects More samples
 See https://github.com/techery/janet-sample-api-integration http://immutables.github.io @Value.Immutable @Gson.TypeAdapters public interface User { @SerializedName("name") String name(); @SerializedName("id") int id(); }
15. Assert for models More samples
 See https://github.com/techery/janet-sample-api-integration assertThat(user.name()).isEqualTo("John"); assertThat(jsonUser.getString("name")).isEqualTo("John"); VS
16. API Client
17. REST-Assured • Simple DSL • Designed especially for testing • POJO support • Might be too low level sometimes • No code reuse :( rest-assured.io
18. REST-Assured sample More samples
 See https://github.com/techery/janet-sample-api-integration given(). param("text", “hey"). param("title", “Amazing post"). when(). post("/posts"). then(). statusCode(201);
19. Retrofit • One of the most popular API frameworks for Java • Code can be reused outside of test project • Can use POJOs • Not flexible enough sometimes square.github.io/retrofit/
20. Retrofit sample More samples
 See https://github.com/techery/janet-sample-api-integration public static class BlogPost { public int id; public String title; public String text; } public interface BlogAPI { @POST("/posts") BlogPost create(@Field("title") String title, @Field("text") String text); } void testBlogPosting() { String title = "Amazing post"; String body = "hey"; BlogPost blogPost = blogAPI.create(title, body); assertThat(blogPost.text, equals(title)); }
21. Janet • Command based service layer • Protocol agnostic • Based on reactive programming approach • Can be used for HTTP with janet-http service • Can be used in any JVM app github.com/techery/janet
22. Janet Action • Java class that describes operation • Each API request is a separate Janet Action • Purely declarative • Annotations are used to map class attrs. to HTTP request values • Action are executed by services. (HTTPService, WebSocketService, SOAPService, YourCustomService)
23. Let’s test something /health_check?url={url} { is_available:boolean, response_time:number }
24. Step 0: setup project More samples
 See https://github.com/techery/janet-sample-api-integration Skip
25. Step 1: define action More samples
 See https://github.com/techery/janet-sample-api-integration @HttpAction(value = "/health_check", method = HttpAction.Method.GET) public class HealthCheckAction { @Query("url") public final String url; public HealthCheckAction(String url) { this.url = url; } @Response public HealthStatus response; }
26. Step 2: define model More samples
 See https://github.com/techery/janet-sample-api-integration public class HealthStatus { @SerializedName("is_available") public Boolean isAvailable; @SerializedName("responseTime") public float responseTime; }
27. Step 3: write test More samples
 See https://github.com/techery/janet-sample-api-integration public class HealthCheckTest { Janet janet; void testHealthCheck() { String originalURL = "https://techery.io/jobs"; final ActionPipe<HealthCheckAction> pipe = janet.createPipe(HealthCheckAction.class); final Observable<ActionState<HealthCheckAction>> observable = pipe.createObservable(new HealthCheckAction(originalURL)); HealthCheckAction action = observable.toBlocking().last().action; HealthStatus response = action.response; assertThat(response).isNotNull(); assertThat(response.isAvailable).isTrue(); assertThat(response.responseTime).isLessThan(100.0f); } }
28. Step 3: write test with some helpers More samples
 See https://github.com/techery/janet-sample-api-integration public class HealthCheckTest extends BaseTest { void testHealthCheck() { String originalURL = "https://techery.io/jobs"; HealthCheckAction action = execute(new HealthCheckAction(originalURL)); HealthStatus response = action.response; assertThat(response).isNotNull(); assertThat(response.isAvailable).isTrue(); assertThat(response.responseTime).isLessThan(100.0f); } }
29. Protocol Agnostic • HTTP • WebSockets • TCP sockets • Etc
30. Step 1: define action More samples
 See https://github.com/techery/janet-sample-api-integration @WsAction(event = "health_check") public class HealthCheckAction { @Payload("url") public final String url; public HealthCheckAction(String url) { this.url = url; } @Response public HealthStatus response; }
31. Step 2: define model More samples
 See https://github.com/techery/janet-sample-api-integration public class HealthStatus { @SerializedName("is_available") public Boolean isAvailable; @SerializedName("responseTime") public float responseTime; }
32. Step 3: write test with some helpers More samples
 See https://github.com/techery/janet-sample-api-integration public class HealthCheckTest extends BaseTest { void testHealthCheck() { String originalURL = "https://techery.io/jobs"; HealthCheckAction action = execute(new HealthCheckAction(originalURL)); HealthStatus response = action.response; assertThat(response).isNotNull(); assertThat(response.isAvailable).isTrue(); assertThat(response.responseTime).isLessThan(100.0f); } }
33. Sample code https://github.com/techery/janet-sample-api-integration Sample Android app with API client library and tests
34. API development workflow 1. New API feature request 2. Team defines models and actions 3. Team writes tests for new endpoint 4. Android team can now start implementing feature by mocking actions if required. 5. Tests run on CI to check if feature is working 6. Backend team deploys new API endpoint 7. Tests pass and feature is ready
35. API development workflow Actions and Models serve as an API contract and every team member can contribute to it
36. Platform structure Janet based API Client Android app API tests UI tests API docs (in beta) iOS Client (in future)
37. Links • https://github.com/techery/janet-sample-api- integration • https://github.com/techery/janet-sample-api- integration • https://github.com/techery/janet-http • http://testng.org/doc/documentation- main.html • http://immutables.github.io
38. We are hiring! techery.io/jobs