You will need an access key and secret access key. The AWSCredentials guide explains how to get them from your AWS account.

Then you will need an AWS keypair. The EC2 keypairs guide explains how to import your own Key Pair to Amazon EC2. Mobile-testkit creates a key-pair in the us-east region so the key pair must be set on this region too.

• Add boto configuration

• Add your AWS credentials (Below are a fake example).

• Add AWS env variables

You probably want to persist these in your .bash_profile

1. Create and AWS CloudFormation Stack. Make sure you have set up AWS credentials described in [Sync Gateway Test Dependencies]

1. Generate pool.json file

Replace YourCloudFormationStack with the actual cloudformation stack name used.

1. Install VirtualBox

2. Install Vagrant

3. cd into vagrant/private_network (or vagrant/public_network if you need VM’s exposed to LAN, for example when testing against actual mobile devices)

Create cluster with private network

vagrant up

1. Run python utilities/generate_cluster_configs_from_vagrant_hosts.py --private-network|public-network

   • This will discover running vagrant boxes and get their ips

   • Generate resources/pool.json

   • Generate resources/cluster_configs/

2. Create an ssh key. cd <home-dir>/.ssh/ && ssh-keygen

3. Make sure you have PasswordAuthentication set on each vagrant instance

Do the same for rests of the hosts in the Vagrantfile

1. Install the ssh key into the machines via

use the password vagrant.

1. Create ansible.cfg

1. Edit ansible.cfg and change the user to 'vagrant'

2. Set the CLUSTER_CONFIG environment variable that is required by the provision_cluster.py script. Eg: $ export CLUSTER_CONFIG=resources/cluster_configs/1sg

3. Install the dependencies

1. Provision the cluster

Enjoy! You now have a Couchbase Server + Sync Gateway cluster running on your machine!

Make sure to use your ssh user ("root" is default). If you are using AWS, you may have to change this to "centos"

This is the list of machines that is used to generate the resources/cluster_configs which are used by the functional tests.

• Rename resources/pool.json.example to resources/pool.json. Update the fake ips with your endpoints or EC2 endpoints.

• If you do not have IP endpoints and would like to use Vagrant, see Spin Up Machines on Vagrant

• If you do not have IP endpoints and would like to use AWS, see Spin Up Machines on AWS

• Make sure you have at least 4 unique endpoints

• If you are using vms and do not have key access for ssh, you can use the key installer script (Not required for AWS). This will target 'resources/pool.json' and attempt to deploy a public key of your choice to the machines.

In order to use Ansible, the controller needs to have it’s SSH keys in all the hosts that it’s connecting to.

Follow the instructions in Docker container SSH key instructions to setup keys in Docker

• Generate the necessary cluster topologies to run the tests

This targets the 'resources/pool.json' you supplied above and generates cluster definitions required for provisioning and running the tests. The generated configurations can be found in 'resources/cluster_configs/'.

• Provision the cluster with --install-deps flag (only once)

• Set the CLUSTER_CONFIG environment variable that is required by the provision_cluster.py script. Eg: $ export CLUSTER_CONFIG=resources/cluster_configs/2sg_1cbs

• Install the dependencies:

• Install sync_gateway package:

• OR Install sync_gateway source:

Since building Sync Gateway from source requires access to the private sync-gateway-accel repo, you will need to be in possession of the appropriate SSH key. See install-gh-deploy-keys.py for more info.

If you experience ssh errors, you may need to verify that the key has been added to your ssh agent

• Follow instructions here - http://docs.ansible.com/ansible/intro_windows.html

• Create an inventory similar to -

Save as resources/cluster_configs/windows

• Download and execute this in the windows target PowerShell (Run as Administrator) ConfigureRemotingForAnsible.ps1

If you hit errors, you may have to allow unsigned script execution (Use with caution)

Test by:

• Go to PyCharm → Preferences

• Expand Project: mobile-testkit and select Project Interpreter

• From the dropdown, make sure your venv (created above) is selected

• Click Apply

• Click on the gear next to the interpreter

• Select More …​

• Make sure your virtualenv is selected and click on the directory icon on the bottom (Show Paths for Selected Interpreter)

• Click the plus icon and find the path to mobile-testkit/

• Select libraries from inside the repo directory

• Click OK, OK, Apply

Now PyCharm should recognize the custom libraries and provide intellisense.

• Open Android Studio

• Create new "dummy" project

• Click on AVD manager (purple icon)

• Create Virtual Device

• Click "Download" next to Marshmallow x86_64

• Hit Next/Finish to create it

The scenarios can run on Android stock emulators/Genymotion emulators and devices.

If you’re running Android stock emulators you should make sure they are using HAXM. Follow the instructions here to install HAXM.

Ensure the RAM allocated to your combined running emulators is less than the total allocated to HAXM. You can configure the RAM for your emulator images in the Android Virtual Device Manager and in HAXM by reinstalling via the .dmg in the android sdk folder.

To run the tests make sure you have lauched the correct number of emulators. You can launch them using the following command.

Verify that the names listed below match the device definitions for the test you are trying to run

Most of the port forwarding will be set up via instantiation of the Listener. However, you do need to complete some additional steps.

Once you have emulators and possibly port forwarding setup, set the P2P_APP environment variable to the .apk of the application to be tested.

If the test fails with a hostname unreachable error then it’s probably because port forwarding needs to be configured (read section below).

Add the following lines to the file /etc/sysctl.conf

Specifying the 'local_port' when instantiating a Listener will forward the port on localhost only.

Parse and test your anchor file to make sure there a no errors:

The file at /etc/pf.conf is the main configuration file that pf loads at boot. Make sure to add both lines below to /etc/pf.conf:

The lo0 are for local requests, and the en0 entries are for external requests (coming from an actual device or another emulator targeting your host).

Next, load and enable pf by running the following:

Now, all the databases are reachable on the internal network via host:forwarded_port (ex. http://192.168.0.21:10000/db), where 192.168.0.21 is your host computer’s ip and 10000 is the 'local_port' passed when instantiating the Listener.