What is Reddit's opinion of Yandex.Mail?

From 3.5 billion Reddit comments

I'm a developer of Yandex.Mail app.

First of all, we, do continuous integration. We use Teamcity and on every pull request we run in parallel (with separate check reports via Github status API):

• Actual apk builds. We also upload artifacts to our companies' internal beta delivery platform, so once some branch is built anyone can check it out (before it even merged in dev branch) without having to log in teamcity, downloading artifcats and stuff
• Unit/Integration JVM tests
• Code analysis: checkstyle/lint/findbugs/pmd
• 'Acceptance' set of Espresso UI tests

We also run remaining Espresso tests and blackbox functional tests (Appium framework) on nightly or on-demand basis. We wish we could run them on CI as well, but they tend to be too slow and sometimes result in false negatives, so they still need some human assistance..

Another cool thing related to testing we do is we report Appium test results in our internal QA test cases tracker. QA engineers store tests scenarios there, distribute tasks among each other and stuff. This way, manual testers don't have to know anything about Appium and its reports format at all. They just know that a certain test case was verified by automated testing and that they don't have to test it manually.

We also have an internal platform for projects localization, basically, we don't enter any string resources manually, but instead add them via this localization system's web interface and then pull the strings via its API in our project. That way, people who actually translate stuff don't have to deal with Android project, they just type the translations in web interface and we can pull them afterwards.

I am a developer at Yandex.Mail (so I work for Yandex).

Our app is basically email client with offline mode support, so you can read emails, tag them and move them around with no network, and it will sync once it connects to the internet. So, we've got REST API for backend comunitation, good old GET requests for downloading attaches and avatars, etc. Complicated storage: sqlite database with multiple tables, file system, shared prefs, etc. UI is complicated as well: lots of various fragments and dialogs.

Even though we've got some legacy 'god fragment' code, we basically use clean/MVP for all of new code.

We use Dagger 2 extensively, including custom scopes (for instance, we have an AccountScope, whiche provides dependencies specific for a certain account, like its database, its OAuth token, etc.). Brrr, would be so much boilerplate without Dagger or at least without some DI framework.

We use RxJava all the time; I haven't written or reviewed AsyncTasks/Futures/etc in my colleagues' code for a really long time. Again, hard to imagine living without it or at least any other decent, fluent API for asyncronous code.

As for clean/MVP: we are no fanatics. If you've got a trivial yes/no dialogue window, no one will force you to extract a presenter for it. However, once your logic gets complicated enough, we'll kindly ask to cover it with tests, and that's probably where you will basically have to do MVP in order to do that.

So I don't really get the 'how the fuck don't you go insane' part. The core of MVP/Clean is separation of concerns, which makes every piece of app simple and testable.

So, just to give you some context: we work on email app (Yandex.Mail, more than 5 millions of installations, a lot of active users (NDA…)).

We do:

• Unit testing (with Robolectric when needed), we try to write unit tests for all code that can be covered with unit tests, sometimes even parts of the View code, such as list adapters, etc.
• Integration testing with Robolectric, the main difference from unit testing here is that we also test complex composition of the objects with mocking backend responses and real implementation of the objects on the JVM (fast).
• Functional testing (UI) with Espresso. Page-oriented architecture, custom rules to handle outgoing intents (Camera, Gallery, Google Play).
• Functional testing (UI) with Appium (hope we'll move all tests to Espresso at some point). Page-oriented architecture. I would not recommend Appium at all, it's slow, it has many bugs and weird behavior, try to avoid it.

TODO:

• More unit tests (not all of the old code covered well enough).
• Mock backend responses for functional (UI) tests, currently we're hitting real endpoints in functional tests, and that makes me really, really sad.
• Try to run some functional tests under Robolectric, testing on emulator/device is way too slow.
• Write or find some good test runner for functional (UI) tests with concurrent execution of each test case on a free device/emulator + video report for failed tests. If somebody from SoundCloud reading this — please open source your test runner!
• Developers should write functional (UI) tests themselves, currently most of the functional tests written by the part of QA team.

Results: we're pretty sure that new code runs smooth, as soon as we find some bug — we try to fix it and cover with tests so we won't see it as a regression in future.

Feel free to ask details (of course some of the info is under NDA, but I'll try to answer).

// And by the way, we're hiring! (iOS team too)(Russia, but I hope we'll open positions in some other countries too)