add docs to readme and contributing

__device-tests__/CONTRIBUTING.md

@@ -0,0 +1,44 @@
+Writing a UI test? Great! 😬 This guide is here to help fill in some of the blanks of how the tests are written now and how you can add a new one. 
+
+You can find our on-device UI tests in the `__device-tests__` folder and that's where all of the code for that really lives.  
+The test suite follows a sort of [Page Object Pattern](https://webdriver.io/docs/pageobjects.html), the `__device-tests__/pages/editor-page.js` manages all interactions with the pages and the `__device-tests__/gutenberg-editor.test.js` actually uses the functions made available via the Page Object `EditorPage` to drive the test cases. At the time of writing this, all the tests live there but as the suite gets large it might be better to manage different classes of tests in different files. 
+
+So what does the process for writing a test look like? Here are some steps that I hope can help make this easier,
+
+### First, define the scenario
+
+- What are the actions that need to take place here? Walk through the scenario and manually to have an idea of what the test steps will need to do, the elements you'll need to interact with and how you're going to need to interact with them. I found it helps to properly define the steps taken in the scenario and the different user interactions that are needed to accomplish it. 
+
+You'd just add a new scenario to the test file as well that would look something like, 
+
+```javscript
+it( 'should be able to do something', async () => {
+	// Code to do something... 
+} );
+```
+
+That first parameter in the block above is where you'd put a short description of the scenario while the next parameter is the code you'd like to execute.
+
+### Second, figure out how to find the elements
+
+- The UI tests rely on locator strategies to identify elements... There's a number of locator strategies available to use and [this blog post](https://saucelabs.com/blog/advanced-locator-strategies) describes in a little more detail what a few of these are and how to use them. You'll need to start thinking about what locator strategy you'll need to use to find the elements you need if it isn't already available. 
+- The preferred strategy is the accessibility identifier and in a lot of cases this might not be possible and you'll have to resort to other less robust alternatives such as XPath. 
+
+There's a few tools you have available to figure out what you need. 
+
+For Android, you can fire up the app and then within Android Studio select `Tools -> Layout Inspector` which will then open up a `.li` file which you can then use to inspect various areas of the app, here's a [screenshot](https://d.pr/free/i/anU50R) of what that looks like. 
+
+For iOS, you can also fire up and use the accessibility inspector, which is an app that should come available on your OSX machine. From there you can choose the process running your simulator and inspect various areas of the app. 
+
+Alternative for both of these platforms and for an interface to simulate the commands I'd recommend [Appium Desktop](https://github.com/appium/appium-desktop/releases/tag/v1.12.1). A great tool for inspecting the view hierarchy and interacting with elements on screen as your test would. Here's a [screenshot](https://d.pr/free/i/GziQ5Q) of what that would look like. 
+
+Using one or a combination of these tools will make it much easier to identify what locator strategy you're going to use or which elements need accessibility identifiers to ease the search process without affecting VoiceOver features. 
+
+### Finally, once you've figured out how you're going to find the elements
+
+- You'll write any functions needed to interact with the page in the `EditorPage` page object and then call those interactions within the test. The code you'll need to write to actually do the finding will use a combination of
+
+- Appium's spec http://appium.io/docs/en/about-appium/intro/ which you can find examples of a variety of functions under the commands tab
+- WebDriver I/O Appium protocols https://webdriver.io/docs/api/appium.html which provides examples and descriptions of what those look like. 
+
+It takes some getting use to but looking at the existing code should be helpful in identifying common commands that it'd help to be familiar with. 

__device-tests__/README.md

@@ -0,0 +1,47 @@
+# Overview
+
+We use [appium](http://appium.io/) combined with [SauceLabs](https://saucelabs.com/) as an on-device testing solution for covering writing flows using Gutenberg blocks.
+
+Appium is built on the idea that testing native apps shouldn't require including an SDK or recompiling your app. And that you should be able to use your preferred test practices, frameworks, and tools. Appium is an open source project and has made design and tool decisions to encourage a vibrant contributing community.
+
+SauceLabs is a cloud hosting platform that provides access to a variety of simulators, emulators and real devices. 
+
+## Getting set up to run the tests
+
+### Emulators && Simulators
+
+iOS: Once you've already set up XCode and the simulators you should be good to go to run the tests on an iOS simulator.
+
+Android: You'll need to have created the emulator images and fired up the desired emulator before running the tests against an Android emulator. 
+
+### Real Devices 
+
+TBA
+
+## Running the tests locally
+
+TLDR; to run the tests locally ensure metro isn't running and then run `yarn test:e2e:ios:local` and `yarn test:e2e:android:local` for the desired platform.
+
+### Starting the Appium Server
+
+One of the Caveats to using Appium is the need for the Appium server to be running to interact with the Simulator or Device through Webdriver, as a result the appium server will need to be started before running the tests. To make the entire process easier in the `beforeAll` block of the tests an Appium instance is fired up on a default port of 4723. If you already have something running on that port and would rather not stop that you can change the port within the code that starts that up. At the moment that port number is referenced from the config located at `__device-tests__/helpers/serverConfigs.js`. The process is killed in the `afterAll` block but at the time of writing this there's a small chance  some errors might cause it not to get there so it might be best to kill the process yourself if you think something is up. The server output when running the tests are written to `appium-out.log`, this can provide useful information when debugging the issues with the tests. 
+
+### WebDriver capabilities 
+
+Appium uses a config object usually referenced to as desired capabilities to connect to a simulator or device, these objects are currently located in `__device-tests__/helpers/caps.js` and then referenced when firing up the driver. There are two values that I think are important to know and that's
+
+- `platformVersion` which is the platform version of a connected adb device. e.g `9.0` for Android or `12.2` for iOS. The version used here is upper bounded by the max allowed on CI but feel free to change this value locally as needed. 
+- `app` which is the absolute path to the `.app` or `.apk` file or the path relative to the **Appium root**. It's important to note that that when using the relative paths it's not to the project folder but to the appium server, since by default we start up appium in the project root when running the paths appear relative to the root but if you were using another instance of the Appium server the relative path would need to come from there.  
+
+A full spec on the capabilities can be found [here](http://appium.io/docs/en/writing-running-appium/caps/) 
+
+## The run process 
+
+At the moment when running locally, the app attempts to fire up an appium server and then connects to it via webdriver. Then 
+
+* on Android, a debug version of the app is bundled, built, and used. 
+* on iOS a release version is bundled built and used. 
+
+It's important to ensure that **metro is not running.** This would cause the value of the `__DEV__` variable to be true and load up the sample blocks. 
+
+The finally the test commands in the suite are executed.