Tips and Tricks for Testing Lambda Expressions in Android

Lambda expressions can be a nice and clean way to accomplish the same thing Anonymous Classes did in the past. However they suffer from the same testing pain point as what they are replacing... mainly they lead to Integration Tests and not Unit Tests. This talk, presented at CodeMash 2017, covers some tips and tricks Android developers using Lambdas, and RXJava can use to help ease this pain.

Transcript

1. Tips and Tricks for Testing Lambda Expressions in Android David Carver CareWorks Tech Google Plus: David Carver Github: kingargyle
2. Agenda • Anonymous Classes and Lambdas ◦ Definitions ◦ Use in Android Applications ▪ Lambdas in Android • Retro Lambda • Jack and Jill • The Problems • Tips and Tricks
4. Unit Testing vs Integration Testing Unit Tests try to test the smallest portion of code individually and independently … for proper operation. Integration Tests test blocks of code as a group. It occurs after unit testing and before validation testing.
5. About Anonymous Classes and Lambdas
6. Anonymous Classes As defined by Java In a Nutshell, “an anonymous class is defined and instantiated in a single succinct expression using the new operator”
7. Where are Anonymous Classes Commonly Used in Android? • Runnables • View Listeners ◦ OnClickListener, OnLongClickListener, OnFocusChangeListener, OnDragListener, OnTouchListener, etc • Comparators • Handler Callbacks • Loaders ◦ OnLoadCanceledListener ◦ OnLoadCompleteListener
8. What Are Lambda Expressions? Microsoft MSDN, July 20, 2015 A lambda expression is an anonymous function that you can use to create delegates or expressions….you can write local functions that can be passed as arguments or returned as the value of the function.
9. What Are Lambda Expressions? Another way to pass code blocks around, but in a more compact syntax. Lambda encourage you to do functional (what you want down, not specifically how it is done) programming instead of an imperative (procedural, how it should be done).
10. Lambdas vs Anonymous Classes Lambdas allow a cleaner syntax for Anonymous Classes that contain a single method that needs to be implemented .
11. Lambda onClickListener implementation Lambda syntax for an onClickListener representation.
12. Android and Lambdas • RetroLambda - https://github.com/orfjackal/retrolambda ◦ Backports the Java 8 support for Lambdas ◦ Allows the use Lambdas all the way back to Java 5. ◦ Generates code at compile time ◦ Gradle Plugin - https://github.com/evant/gradle-retrolambda • Jack and Jill - http://tools.android.com/tech-docs/jackandjill ◦ Android specific compiler ◦ Natively supports Java 8 and Lambdas ◦ Only supports back to Java 7 ▪ No Java 6 support for older devices ◦ Will be the standard android compiler going forward.
13. So What is the Problem? Lambdas as used in Java currently, are a cleaner syntax for single method anonymous classes. • Trying to write tests leads to writing integration tests • Leads to duplication of Code • Can lead to hard to maintain code ◦ Multiple inline overrides embedded multiple levels deep. • Testing code that requires a Framework or other layers to work leads to tests that need more setup. ◦ Can lead to longer execution time of your tests ◦ More difficult to setup tests
14. Performance Lambda Expressions are not as optimized by the compiler currently as standard imperative ways of accomplishing the same thing. Imperative is still faster in the following areas: • Iterators • For Each Benchmarks are tricky and can be misleading, but be careful going hog wild with lambdas as they can introduce slow points in your code. http://blog.takipi.com/benchmark-how-java-8-lambdas-and-streams-can-make-your-code-5-times-slower/
15. Anonymous Classes plague Graphical User Interface work. They are convenient. However, hard to unit test. Lambdas can be used many places that you would implement an Anonymous class. They suffer the same testing problem as Anonymous Classes. It leads to integration testing and not unit testing.
16. HOW DO WE BRING ORDER OUT OF CHAOS?
17. AVOID USING ANONYMOUS CLASSES!
18. AVOID USING LAMBDAS!
19. DO NOT OVER USE LAMBDAS BECAUSE THEY ARE CONVENIENT.
20. DO WHAT IS RIGHT. NOT WHAT IS EASY.
21. You are going to use them anyways right?
22. Tips and Tricks
23. Where are Lambdas Commonly Used in Android? • RXJava and RXJava for Android ◦ Anywhere the Action class/interface would normally be implemented. ◦ Anywhere where anonymous inline overrides would have been used. ◦ If you are doing RX… you are probably using Lambdas otherwise you go insane. • Implementation of Interfaces ◦ Handlers ◦ Runnables ◦ Listeners ◦ Any place you could use an anonymous class with a single method. All of these places are also where you typically have Unit Testing pain points.
24. What is RXJava and RX Android? A library for composing asynchronous and event-based programs by using observable sequences. It is an implementation of ReactiveX (Reactive Extensions). https://github.com/ReactiveX/RxJava/wiki
25. RXJava Syntax for Java 7
26. RXJava Syntax for Java 8
27. Implement Concrete Class from Interface • Simple POJO • Typically the fastest to execute • Typically the least complicated to setup • Can be reused in other places in your application. Many Android examples use Anonymous Classes. Stop following these examples.
28. Implement the Interface on a View/Fragment/Activity This is fine .... until your class starts becoming a GOD class that wants to do everything. Avoid GOD classes… they become a nightmare to test.
29. Easier View Listener Testing
30. Robolectric and Butterknife • Robolectric ◦ Unit Test Framework that runs on your computer ▪ No Device needed ▪ No Simulator ▪ Simulates Android ▪ Runs on your machine. • ButterKnife ◦ Developed by Jake Wharton ◦ Part of the Square Development Stack ◦ Generates Code based on Annotations ▪ @BindView, @BindInt, @BindBoolean ▪ @OnClick, @OnLongClick
31. ButterKnife onClick Binding Example
32. ButterKnife onClick Binding Example
33. ButterKnife Testing Advantages • No Anonymous classes • Lambdas are not necessary • Less Likely to lead to an Integration Test ◦ Allows for a pure unit test without executing more code than necessary • Simpler tests ◦ Leading to faster execution of the tests • Cleaner Code leading to easier maintenance • Can Bind onClicks to multiple views allowing for easier code re-use.
34. Testing Lambdas in RXJava • RXJava allows for easier implementation of Async Tasks ◦ File operations ◦ Database Acccess ◦ Remote Procedure Calls ◦ Any type of Background Tasks ◦ Can support Event Bus style notifications • Lambdas can make writing RXJava Observables cleaner ◦ No Messy inline override syntax • However, RXJava leads to more Integration Style Tests • Tests are harder to setup, and more complicated to verify and isolate.
35. Common RXJava Test Situations • Subscribers and Error conditions • Subjects • Map Flatteners • Joins The simplest way to test these is to extract the functionality to a method, and test the code that is intended to be executed separately.
36. Extract to Method
37. Extract to Method Extracting this out allows for testing of the expected behavior of this code without executing the subscribe directly. It also keeps your code potentially cleaner.
38. RXJava TestSubscriber • Allows you to execute the subscribe, and error portions of an RXJava Observable. • Provides the simplest method for executing the least amount of code possible. • Use in combination with Mockito/EasyMock to provide mocks for the Observables that are being subscribed too. • This is still an Integration Test ◦ Requires RXJava Framework to execute in order to test the conditions and code in the Lambda expression. ◦ Less Complicated though than trying to Mock Out the RXJava Framework itself.
39. RXJava Testing Error Conditions
40. RXJava TestSubscriber - code under test
41. RXJava TestSubscriber - subscribe
42. RXJava - Testing Subjects with Schedulers
43. Summary • Leverage Lambdas ◦ Make sure you are using for the right reasons, not because you can. ◦ They can provide cleaner code, but can make it more complicated to test. • Prefer implementing your Interfaces as re-usable classes ◦ Easier to strictly unit test ◦ Reduce code duplication • Leverage Butterknife when possible for binding click events ◦ Allows simpler tests ◦ Cleaner test setup and execution • Consider extracting lambdas that contain complicated code to either Classes or methods.
44. Resources • RXJava - https://github.com/ReactiveX/RxJava • RXJava for Android - https://github.com/ReactiveX/RxAndroid • RetroLambda - https://github.com/orfjackal/retrolambda • ButterKnife - http://jakewharton.github.io/butterknife/ • Robolectric - https://github.com/robolectric/robolectric • Mockito - http://site.mockito.org/ • Testing RX Java Observables - https://labs.ribot.co.uk/unit-testing-rxjava-6e9540d4a329#.9ydk0xq9b • Testing Lambda Expressions - http://radar.oreilly.com/2014/12/unit-testing-java-8-lambda-expressions-and-strea ms.html
45. Resources