Merge lp:~canonical-platform-qa/snappy-ecosystem-tests/export-staging-variables-ssh into lp:snappy-ecosystem-tests

[Omer Akram]

Export staging variables over ssh.

Ensure staging environment variables are available over ssh.

[platform-qa-bot (platform-qa-bot)]

PASSED: Continuous integration, rev:24
https://platform-qa-jenkins.ubuntu.com/job/snappy-ecosystem-tests-ci/226/
Executed test runs:
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/2027/console

Click here to trigger a rebuild:
https://platform-qa-jenkins.ubuntu.com/job/snappy-ecosystem-tests-ci/226/rebuild

review: Approve (continuous-integration)

[Omer Akram (om26er)]

By default ssh is secure and does not allow any random environment variable to be exported. So the ssh config within the container also needs to be updated to allow these variables to be exported.

That can be enabled by container setup script. We basically need to append staging environment variable names to AcceptEnv key inside /etc/ssh/sshd_config. OR if we just want to put this variables inside /etc/environment while we setup the container, that would work, though I am not a fan of that.

For testing just update the AcceptEnv line in the container to

AcceptEnv *

[Omer Akram (om26er)]

(and restart the container)

[lp:~canonical-platform-qa/snappy-ecosystem-tests/export-staging-variables-ssh]

25. By Omer Akram on 2017-03-02

merge with trunk

26. By Omer Akram on 2017-03-02

Finish rebase

27. By Omer Akram on 2017-03-02

fix

28. By Omer Akram on 2017-03-02

fix per suggestion

29. By Omer Akram on 2017-03-02

merge with pre-req

30. By Omer Akram on 2017-03-02

ignore arguments-differ pylint warning

31. By Omer Akram on 2017-03-03

merge with trunk

Unmerged revisions

=== modified file 'README.rst'
--- README.rst	2017-02-22 17:40:11 +0000
+++ README.rst	2017-03-02 10:45:12 +0000
@@ -69,17 +69,22 @@
 [user]
 user_email=^USER_NAME^
 user_password=^USER_PASSWORD^
-hostname_remote=^SSH_HOSTNAME^
-username_remote=^SSH_USERNAME^
-port_remote=^SSH_PORT^
+snapd_hostname_remote=^SNAPD_SSH_HOSTNAME^
+snapd_username_remote=^SNAPD_SSH_USERNAME^
+snapd_port_remote=^SNAPD_SSH_PORT^
+snapcraft_hostname_remote=^SNAPCRAFT_SSH_HOSTNAME^
+snapcraft_username_remote=^SNAPCRAFT_SSH_USERNAME^
+snapcraft_port_remote=^SNAPCRAFT_SSH_PORT^
 
 option 2 - Set the following environment variables:
 user_email=^USER_NAME^
 user_password=^USER_PASSWORD^
-hostname_remote=^SSH_HOSTNAME^
-username_remote=^SSH_USERNAME^
-port_remote=^SSH_PORT^
-
+snapd_hostname_remote=^SNAPD_SSH_HOSTNAME^
+snapd_username_remote=^SNAPD_SSH_USERNAME^
+snapd_port_remote=^SNAPD_SSH_PORT^
+snapcraft_hostname_remote=^SNAPCRAFT_SSH_HOSTNAME^
+snapcraft_username_remote=^SNAPCRAFT_SSH_USERNAME^
+snapcraft_port_remote=^SNAPCRAFT_SSH_PORT^
 
 Changing store:
 ===============
 
=== modified file 'pylint.cfg'
--- pylint.cfg	2017-02-21 13:46:08 +0000
+++ pylint.cfg	2017-03-02 10:45:12 +0000
@@ -169,10 +169,10 @@
 inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$
 
 # Regular expression matching correct function names
-function-rgx=[a-z_][a-z0-9_]{2,30}$
+function-rgx=[a-z_][a-z0-9_]{2,40}$
 
 # Naming hint for function names
-function-name-hint=[a-z_][a-z0-9_]{2,30}$
+function-name-hint=[a-z_][a-z0-9_]{2,40}$
 
 # Regular expression matching correct attribute names
 attr-rgx=[a-z_][a-z0-9_]{2,30}$
@@ -181,10 +181,10 @@
 attr-name-hint=[a-z_][a-z0-9_]{2,30}$
 
 # Regular expression matching correct method names
-method-rgx=[a-z_][a-z0-9_]{2,30}$|setUp|tearDown
+method-rgx=[a-z_][a-z0-9_]{2,30}$|setUp|tearDown|test_*
 
 # Naming hint for method names
-method-name-hint=[a-z_][a-z0-9_]{2,30}$|setUp|tearDown
+method-name-hint=[a-z_][a-z0-9_]{2,30}$|setUp|tearDown|test_*
 
 # Regular expression matching correct class attribute names
 class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
 
=== modified file 'requirements-unit-tests.txt'
--- requirements-unit-tests.txt	2017-02-10 18:18:45 +0000
+++ requirements-unit-tests.txt	2017-03-02 10:45:12 +0000
@@ -1,1 +1,1 @@
-unittest2
+testtools
 
=== modified file 'requirements.txt'
--- requirements.txt	2017-02-21 21:07:33 +0000
+++ requirements.txt	2017-03-02 10:45:12 +0000
@@ -14,7 +14,8 @@
 pexpect
 pymacaroons==0.9.2
 requests-toolbelt==0.6.0
-#chromedriver_installer
 pylxd
 pyyaml
+retrying
 paramiko
+chromedriver_installer
 
=== modified file 'run_checks'
--- run_checks	2017-02-20 13:10:18 +0000
+++ run_checks	2017-03-02 10:45:12 +0000
@@ -51,9 +51,9 @@
 
     if [ "$proxy" ]; then
         echo "Using proxy: $proxy to install dependencies"
-        pip install --proxy $proxy -r requirements-unit-tests.txt
+        pip3 install --proxy $proxy -r requirements-unit-tests.txt
     else
-        pip install -r requirements-unit-tests.txt
+        pip3 install -r requirements-unit-tests.txt
     fi
 
     ve_unit_tests/bin/python3 -m unittest discover snappy_ecosystem_tests.unittests 
 
=== modified file 'run_system_tests'
--- run_system_tests	2017-02-13 16:00:04 +0000
+++ run_system_tests	2017-03-02 10:45:12 +0000
@@ -20,6 +20,7 @@
 
 . ./mk-venv "$@"
 
+ve/bin/python3 ./snappy_ecosystem_tests/utils/store_versions.py
 ve/bin/python3 ./snappy_ecosystem_tests/run.py "$@" -c snappy_ecosystem_tests/configs/pytest.cfg --ignore snappy_ecosystem_tests/unittests/ --junitxml snappy-ecosystem-results.xml
 
 deactivate
 
=== modified file 'snappy_ecosystem_tests/configs/ecosystem_tests.cfg'
--- snappy_ecosystem_tests/configs/ecosystem_tests.cfg	2017-02-10 19:20:45 +0000
+++ snappy_ecosystem_tests/configs/ecosystem_tests.cfg	2017-03-02 10:45:12 +0000
@@ -1,7 +1,5 @@
-[web-ui]
+[selenium]
 browser=chrome
-stage_url=https://myapps.developer.staging.ubuntu.com/
-production_url=https://myapps.developer.ubuntu.com/
 
 [store]
 # store to use in tests. Possible values: staging or production
@@ -12,9 +10,16 @@
 upload=https://upload.apps.staging.ubuntu.com/
 sso=https://login.staging.ubuntu.com/api/v2/
 search=https://search.apps.staging.ubuntu.com/
+web=https://myapps.developer.staging.ubuntu.com/
 
 [production_urls]
 root_api=https://myapps.developer.ubuntu.com/dev/api/
 upload=https://upload.apps.ubuntu.com/
 sso=https://login.ubuntu.com/api/v2/
 search=https://search.apps.ubuntu.com/
+web=https://myapps.developer.ubuntu.com/
+
+[time_between_registrations]
+# Time in seconds between each snap registration
+staging=10
+production=180
 
=== added directory 'snappy_ecosystem_tests/environment'
=== added file 'snappy_ecosystem_tests/environment/__init__.py'
--- snappy_ecosystem_tests/environment/__init__.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/environment/__init__.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,19 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Snappy Ecosystem Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
 
=== added file 'snappy_ecosystem_tests/environment/constants.py'
--- snappy_ecosystem_tests/environment/constants.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/environment/constants.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,82 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Snappy Ecosystem Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""Constants used accross the environment setup"""
+
+SNAPD = 'snapd'
+SNAPCRAFT = 'snapcraft'
+
+DEPENDENCIES = {
+    SNAPD : [],
+    SNAPCRAFT : [],
+    "shared" : ["expect"]
+}
+
+PROFILES = {
+    "staging":{
+        SNAPD:{
+            "channel": "xenial",
+            "package_name": 'snapd',
+            "environment_variables": [
+                {
+                    "name": "UBUNTU_STORE_API_ROOT_URL",
+                    "value": "https://myapps.developer.ubuntu.com/dev/api/"
+                },
+                {
+                    "name": "UBUNTU_STORE_UPLOAD_ROOT_URL",
+                    "value": "https://upload.apps.ubuntu.com"
+                },
+                {
+                    "name":"UBUNTU_SSO_API_ROOT_URL",
+                    "value":"https://login.ubuntu.com/api/v2/"
+                },
+                {
+                    "name":"UBUNTU_STORE_SEARCH_ROOT_URL",
+                    "value":"https://search.apps.ubuntu.com/"
+                }
+            ]
+        },
+        SNAPCRAFT: {
+            "channel": "xenial",
+            "package_name": 'snapcraft',
+            "environment_variables": [
+                {
+                    "name": "UBUNTU_STORE_API_ROOT_URL",
+                    "value": "https://myapps.developer.ubuntu.com/dev/api/"
+                },
+                {
+                    "name": "UBUNTU_STORE_UPLOAD_ROOT_URL",
+                    "value": "https://upload.apps.ubuntu.com"
+                },
+                {
+                    "name":"UBUNTU_SSO_API_ROOT_URL",
+                    "value":"https://login.ubuntu.com/api/v2/"
+                },
+                {
+                    "name":"UBUNTU_STORE_SEARCH_ROOT_URL",
+                    "value":"https://search.apps.ubuntu.com/"
+                }
+            ]
+        },
+        "snapweb":{
+            "url": "https://myapps.developer.ubuntu.com/"
+        },
+    }
+}
 
=== added directory 'snappy_ecosystem_tests/environment/data'
=== added file 'snappy_ecosystem_tests/environment/data/__init__.py'
--- snappy_ecosystem_tests/environment/data/__init__.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/environment/data/__init__.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,19 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Snappy Ecosystem Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
 
=== added file 'snappy_ecosystem_tests/environment/data/snapcraft.py'
--- snappy_ecosystem_tests/environment/data/snapcraft.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/environment/data/snapcraft.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,21 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Snappy Ecosystem Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+"""Snapcraft data"""
+SNAPCRAFT_CONTAINER_NAME = 'snapcraft'
 
=== added file 'snappy_ecosystem_tests/environment/data/snapd.py'
--- snappy_ecosystem_tests/environment/data/snapd.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/environment/data/snapd.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,88 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Snappy Ecosystem Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+"""snapd data"""
+SNAPD_CONTAINER_NAME = 'snapd'
+
+CONTAINER_HOME = '/root'
+DIRECTORY_CLONE = '{}/src/github.com/snapcore/snapd'.format(CONTAINER_HOME)
+DOMAIN_PING = 'ubuntu.com'
+ENV_STORE_API_ROOT = 'UBUNTU_STORE_API_ROOT_URL'
+ENV_STORE_SEARCH_ROOT = 'UBUNTU_STORE_SEARCH_ROOT_URL'
+ENV_STORE_UPLOAD_ROOT = 'UBUNTU_STORE_UPLOAD_ROOT_URL'
+ENV_SSO_API_ROOT = 'UBUNTU_SSO_API_ROOT_URL'
+PACKAGES_SNAPD = ['snapd', 'snap-confine', 'ubuntu-core-launcher']
+COMMAND_REMOVE_SNAPD = 'apt purge -y {}'.format(' '.join(PACKAGES_SNAPD))
+COMMAND_APT_BUILD_DEP = 'apt build-dep -y ./'
+COMMAND_APT_INSTALL = 'apt install -y {}'
+COMMAND_APT_INSTALL_STAGING_DEBS = COMMAND_APT_INSTALL.format(
+    ' '.join(['../{}*.deb'.format(pkg) for pkg in PACKAGES_SNAPD]))
+COMMAND_APT_UPDATE = 'apt update'
+COMMAND_APT_UPGRADE = 'apt dist-upgrade -y'
+COMMAND_BUILD_SNAPD = 'DEB_BUILD_OPTIONS="nocheck testkeys" ' \
+                      'dpkg-buildpackage -tc -b'
+COMMAND_EXPORT_STAGING_STORE_VAR = 'echo SNAPPY_USE_STAGING_STORE=1 >> ' \
+                                   '/etc/environment'
+COMMAND_GET_GOVENDOR = 'go get -v github.com/kardianos/govendor'
+COMMAND_GIT_CLONE = 'git clone {} {}'
+COMMAND_GOVENDOR_SYNC = 'govendor sync'
+REPOSITORY_GIT = 'https://github.com/snapcore/snapd'
+URL_API_ROOT = 'https://myapps.developer.staging.ubuntu.com/dev/api/'
+URL_SEARCH_ROOT = 'https://search.apps.staging.ubuntu.com/'
+URL_UPLOAD_ROOT = 'https://upload.apps.staging.ubuntu.com/'
+URL_SSO_API_ROOT = 'https://login.staging.ubuntu.com/api/v2/'
+
+CONTAINER_SETUP = [
+    COMMAND_REMOVE_SNAPD,
+    COMMAND_APT_UPDATE,
+    # Hold open-iscsi which is causing apt upgrade errors while running
+    # inside container.
+    'apt-mark hold open-iscsi',
+    COMMAND_APT_UPGRADE,
+    # Needed for snaps to work inside a lxd container
+    #  ref: https://stgraber.org/2016/12/07/running-snaps-in-lxd-containers/
+    COMMAND_APT_INSTALL.format('squashfuse'),
+    COMMAND_GIT_CLONE.format(REPOSITORY_GIT, DIRECTORY_CLONE),
+    {'command': COMMAND_APT_BUILD_DEP, 'cwd': DIRECTORY_CLONE},
+    {'command': COMMAND_GET_GOVENDOR, 'cwd': DIRECTORY_CLONE},
+    {'command': COMMAND_GOVENDOR_SYNC, 'cwd': DIRECTORY_CLONE},
+    {'command': COMMAND_BUILD_SNAPD, 'cwd': DIRECTORY_CLONE},
+    COMMAND_EXPORT_STAGING_STORE_VAR,
+    {'command': COMMAND_APT_INSTALL_STAGING_DEBS, 'cwd': DIRECTORY_CLONE}
+]
+
+CONTAINER_ENV_VARS = {
+    'GOPATH': CONTAINER_HOME,
+    'SNAPPY_USE_STAGING_STORE': '1',
+    ENV_STORE_API_ROOT: URL_API_ROOT,
+    ENV_STORE_SEARCH_ROOT: URL_SEARCH_ROOT,
+    ENV_STORE_UPLOAD_ROOT: URL_UPLOAD_ROOT,
+    ENV_SSO_API_ROOT: URL_SSO_API_ROOT,
+}
+
+DEFAULT_CONTAINER_CONFIG = {
+    "name": "snapd",
+    "source": {
+        "type": "image",
+        "mode": "pull",
+        "server": "https://cloud-images.ubuntu.com/releases",
+        "protocol": "simplestreams",
+        "fingerprint": "16.04"
+    }
+}
 
=== added file 'snappy_ecosystem_tests/environment/managers.py'
--- snappy_ecosystem_tests/environment/managers.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/environment/managers.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,142 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""Managers to setup the environment"""
+
+import os
+import shlex
+from pylxd import Client
+from pylxd.exceptions import NotFound, LXDAPIException
+from retrying import retry
+
+from snappy_ecosystem_tests.environment import constants
+from snappy_ecosystem_tests.environment.constants import (
+    PROFILES, DEPENDENCIES)
+from snappy_ecosystem_tests.environment.data.snapcraft import (
+    SNAPCRAFT_CONTAINER_NAME)
+from snappy_ecosystem_tests.environment.data.snapd import (
+    DEFAULT_CONTAINER_CONFIG, SNAPD_CONTAINER_NAME)
+
+def get_manager(mode):
+    """Get the manager for the given mode"""
+    supported_modules = {
+        "lxd": LxdManager
+    }
+    try:
+        manager = supported_modules[mode]
+        return manager()
+    except KeyError:
+        raise RuntimeError("Mode: {} is not supported".format(mode))
+
+
+class LxdManager:
+    """Manage lxd containers"""
+
+    def __init__(self):
+        self.client = Client()
+
+    def launch(self, container_name, release='16.04'):
+        """Launch a container"""
+        try:
+            container = self.client.containers.get(container_name)
+            if container.status == "Running":
+                container.stop(wait=True)
+            container.delete(wait=True)
+        except NotFound:
+            pass
+        container_config = DEFAULT_CONTAINER_CONFIG.copy()
+        container_config['source']['alias'] = release
+        container_config['name'] = container_name
+        container = self.client.containers.create(container_config, wait=True)
+        container.start(wait=True)
+
+    def execute_command(self, container_name, command):
+        """execute command"""
+        container = self.client.containers.get(container_name)
+        container.execute(command)
+
+    def install(self, container_name, packages, channel=None):
+        """Install a packages"""
+        container = self.client.containers.get(container_name)
+        container.execute(shlex.split('apt-get update'))
+        install_command = 'apt-get install {} -y'.format(packages)
+        if channel:
+            install_command += ' -t {}'.format(channel)
+        container.execute(shlex.split(install_command))
+
+    def install_dependencies(self, container_name, container_type):
+        """Install a dependencies"""
+        self.install(
+            container_name,
+            DEPENDENCIES[container_type] + DEPENDENCIES['shared'])
+
+
+    def configure(self, container_name, container_type, profile):
+        """Configure a given container"""
+        container = self.client.containers.get(container_name)
+        for variable in \
+                PROFILES[profile][container_type]['environment_variables']:
+            container.config.update({'environment.{}'.format(
+                variable['name']): variable['value']})
+        container.save(wait=True)
+
+    @retry(stop_max_attempt_number=5, wait_fixed=3000,
+           retry_on_exception=lambda exception: isinstance(
+               exception, LXDAPIException))
+    def enable_ssh(self, container_name):
+        """Enable the ssh connection on the container"""
+        container = self.client.containers.get(container_name)
+        pub_key = open(
+            os.path.expanduser('~') + '/.ssh/id_rsa.pub').read().strip('\n')
+        container.files.put('/home/ubuntu/.ssh/authorized_keys', pub_key)
+
+
+    def setup(self, profile):
+        """setup the container based on the profile"""
+        self._setup(SNAPD_CONTAINER_NAME, constants.SNAPD, profile)
+        self._setup(
+            SNAPCRAFT_CONTAINER_NAME, constants.SNAPCRAFT, profile)
+
+
+    def _setup(self, container_name, container_type, profile):
+        """
+        Launch a container, enable ssh, install dependencies
+        and setup the needed environment variables
+        """
+        self.launch(container_name)
+        self.enable_ssh(container_name)
+        self.install(
+            container_name,
+            packages=PROFILES[profile][container_type]["package_name"],
+            channel=PROFILES[profile][container_type]["channel"])
+        self.install_dependencies(container_name, container_type)
+        self.configure(container_name, container_type, profile)
+
+    def get_ip(self, container_name):
+        """Gets the ip address for a given container"""
+        networks = self.client.containers.get(
+            container_name).state().network['eth0']['addresses']
+
+        for network in networks:
+            if network['address']:
+                return network['address']
+        raise RuntimeError(
+            "The container {} does not have an IPV4 connection".format(
+                container_name))
 
=== added file 'snappy_ecosystem_tests/environment/setup.py'
--- snappy_ecosystem_tests/environment/setup.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/environment/setup.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,46 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""Standalone script to setup an ecosystem environment"""
+
+import argparse
+
+import logging
+
+from snappy_ecosystem_tests.environment.managers import get_manager
+
+logging.basicConfig(level=logging.DEBUG)
+
+def main(mode, profile):
+    """Main script"""
+    manager = get_manager(mode)
+    manager.setup(profile)
+
+
+if __name__ == '__main__':
+    PARSER = argparse.ArgumentParser(description=
+                                     'Setup a snappy ecosystem environment.')
+    PARSER.add_argument('--mode', default="lxd",
+                        help='lxd')
+    PARSER.add_argument('--profile', default="staging",
+                        help='Profile to configure the environment')
+    ARGS = PARSER.parse_args()
+
+    main(ARGS.mode, ARGS.profile)
 
=== modified file 'snappy_ecosystem_tests/helpers/snapcraft/client.py'
--- snappy_ecosystem_tests/helpers/snapcraft/client.py	2017-02-15 19:35:54 +0000
+++ snappy_ecosystem_tests/helpers/snapcraft/client.py	2017-03-02 10:45:12 +0000
@@ -20,14 +20,49 @@
 
 """Snapcraft client helpers"""
 
+import logging
+import subprocess
+import time
+
 import pexpect
 
-
-# login credentials exported by shell environment
+from snappy_ecosystem_tests.models.snap import Snap
+from snappy_ecosystem_tests.utils import ssh
+from snappy_ecosystem_tests.utils.commands import build_command
+from snappy_ecosystem_tests.utils.filters import filter_list
+from snappy_ecosystem_tests.utils.storeconfig import get_current_store
+
+from snappy_ecosystem_tests.commons.config import CONFIG_STACK
+
 from snappy_ecosystem_tests.utils import storeconfig
 
+# login credentials gotten from config file or shell environment
+from snappy_ecosystem_tests.utils.user import (
+    get_snapcraft_remote_host_credentials
+)
+
 LOGIN_EMAIL, LOGIN_PASSWORD = storeconfig.get_store_credentials()
 
+# Commands
+PATH_SNAPCRAFT = '/usr/bin/snapcraft'
+COMMANDS_LOGIN = """\
+/usr/bin/expect \
+-c 'spawn {snapcraft} login' \
+-c 'expect Email:' \
+-c 'send {email}\\r' \
+-c 'expect Password:' \
+-c 'send {password}\\r' \
+-c 'interact'\
+"""
+
+COMMAND_LOGOUT = 'logout'
+COMMAND_REGISTER = 'register'
+COMMAND_LIST_REGISTERED = 'list-registered'
+
+LOGGER = logging.getLogger(__name__)
+
+HOSTNAME, USERNAME, PORT = get_snapcraft_remote_host_credentials()
+
 
 class Snapcraft(object):
     """Contain Snapcraft specific functionality to use via command
@@ -37,13 +72,37 @@
         self._login = False
         self._cleanup()
 
+    @staticmethod
+    def _run_snapcraft_command_ssh(command, debug=True):
+        """
+        Run snapcraft command via ssh
+        :param command: the command to be executed.
+        Can be a single string or a list of strings
+        :param debug: whether to enable debug mode
+        :return: the command's output
+        """
+        if not command.startswith(PATH_SNAPCRAFT):
+            command = build_snapcraft_command(command)
+        if debug:
+            command += ' -d'
+        return ssh.run_command(command, hostname=HOSTNAME, username=USERNAME,
+                               port=PORT)
+
+    def assert_logged_in(self):
+        """Assert that an user is logged.
+        :raise ValueError: in case login is false
+        """
+        if self._login is False:
+            raise ValueError("User is not logged in, "
+                             "please login before using this command")
+
     def _cleanup(self):
         """Perform cleanup actions"""
         self.logout()
 
     def logout(self):
         """logout of snapcraft store session"""
-        child = pexpect.spawn("snapcraft logout")
+        child = pexpect.spawn(build_snapcraft_command(COMMAND_LOGOUT))
         err = child.expect('Credentials cleared.')
         child.terminate(True)
         child.wait()
@@ -52,23 +111,105 @@
 
         self._login = False
 
-    def login(self):
-        """login to store using the credential environment variables"""
-        child = pexpect.spawn("snapcraft login")
-        child.expect('Email: ')
-        child.sendline(LOGIN_EMAIL)
-        child.expect('Password:')
-        child.sendline(LOGIN_PASSWORD)
-        err = child.expect('Login successful')
-        if err is not 0:
-            raise ValueError("Failed to login")
-
-        self._login = True
-
-    def list_registered(self):
-        """call snapcraft list-registered command,
-        raise exception if not logged in"""
-        if self._login is False:
-            raise ValueError("User is not logged in, "
-                             "please login before using this command")
-        return pexpect.spawnu("snapcraft list-registered").read()
+    def login(self, email=LOGIN_EMAIL, password=LOGIN_PASSWORD):
+        """Login to Snapcraft. If email and/or password are not provided,
+        use the default ones.
+        :param email: the SSO email
+        :param password: the email password
+        """
+        output = ssh.run_command(
+            COMMANDS_LOGIN.format(email=email, password=password,
+                                  snapcraft=PATH_SNAPCRAFT),
+            hostname=HOSTNAME, username=USERNAME, port=PORT)
+        self._login = 'login successful' in output.lower()
+        return self._login
+
+    def list_registered(self, debug=True, raw=False):
+        """Call snapcraft list-registered command,
+        raise exception if not logged in
+        :param debug: whether to enable debug mode
+        :param raw: whether to return the output as a raw.
+        If False, return a list of Snap instances
+        """
+        self.assert_logged_in()
+        registered_snaps_output = self._run_snapcraft_command_ssh(
+            COMMAND_LIST_REGISTERED,
+            debug=debug)
+        if raw:
+            return registered_snaps_output
+        else:
+            snaps = registered_snaps_output.splitlines()
+            # if debug is set, the first 3 lines of output are the API calls
+            return parse_snaps_raw(snaps if debug is False else snaps[3:])
+
+    def filter_snaps(self, **predicates):
+        """
+        Return a list of the snaps that match with all the given predicates.
+        Examples:
+        filter_snap() --> return all the snaps
+        filter_snap(name='my_name') --> return the snaps that matches with
+         name 'my_name'
+        filter_snap(name='my_name', private=True) --> return the snaps that
+         matches with name 'my_name' and are private.
+        filter_snap(price='5') --> return the snaps with price '5'.
+        :return: A list of snap instances
+        """
+        return filter_list(self.list_registered(raw=False), **predicates)
+
+    def register(self, snap_name, private=False, wait=True):
+        """
+        Register a snap name in the store.
+        :param snap_name: the snap name to register.
+        :param private: whether the snap name is private.
+        :param wait: wheter to wait after registration to hitting the store
+         restriction on following registrations
+        :return: True if the snap was registered successfully, False otherwise.
+        """
+        self.assert_logged_in()
+        LOGGER.info('About to register snap: %s', snap_name)
+        command = build_snapcraft_command(COMMAND_REGISTER, snap_name)
+        if private:
+            command += ' --private'
+        try:
+            Snapcraft._run_snapcraft_command_ssh(command)
+        except subprocess.CalledProcessError as _e:
+            LOGGER.error('Unable to register snap: %s', _e.output)
+            return False
+        if wait:
+            time.sleep(int(CONFIG_STACK.get('time_between_registrations',
+                                            get_current_store())))
+        LOGGER.info('Snap %s registered successfully!!!', snap_name)
+        return True
+
+
+def build_snapcraft_command(*args, base_command=PATH_SNAPCRAFT):
+    """
+    Build a snapcraft command with arguments
+    :param args: list of arguments for the command
+    :param base_command: snapcraft executable that is going to be used
+    :return: the snapcraft command ready to be executed
+    """
+    return build_command(base_command, *args)
+
+
+def parse_snaps_raw(raw):
+    """
+    Parse snaps raw output to a list of Snaps object
+    :param raw: the raw that contains the snaps info.
+    It assumes that the first line is the output Header like:
+     (Name, Since, Price, etc.) to get the attributes order.
+    :return: A list of snaps instances
+    """
+    attributes_order = {}
+    for _i, att in enumerate(raw[0].split()):
+        attributes_order[att.lower()] = _i
+    snaps = []
+    for snap_raw in raw[1:]:
+        attrs = snap_raw.split()
+        private = attrs[attributes_order.get('visibility')].lower() == 'private'
+        snaps.append(Snap(name=attrs[attributes_order.get('name')],
+                          since=attrs[attributes_order.get('since')],
+                          private=private,
+                          price=attrs[attributes_order.get('price')],
+                          notes=attrs[attributes_order.get('notes')]))
+    return snaps
 
=== modified file 'snappy_ecosystem_tests/helpers/snapd/snapd.py'
--- snappy_ecosystem_tests/helpers/snapd/snapd.py	2017-02-21 15:17:12 +0000
+++ snappy_ecosystem_tests/helpers/snapd/snapd.py	2017-03-02 10:45:12 +0000
@@ -26,6 +26,7 @@
 import yaml
 
 from snappy_ecosystem_tests.utils import ssh
+from snappy_ecosystem_tests.utils.user import get_snapd_remote_host_credentials
 
 PATH_SNAP = '/usr/bin/snap'
 COMMAND_DOWNLOAD = 'download {snap} --channel={channel}'
@@ -47,6 +48,8 @@
 """
 LOGGER = logging.getLogger(__name__)
 
+HOSTNAME, USERNAME, PORT = get_snapd_remote_host_credentials()
+
 
 def run_snapd_command_ssh(parameters, cwd=''):
     """Run snapd command over ssh.
@@ -59,7 +62,8 @@
     if cwd:
         return ssh.run_command(
             'cd {}; {} {}'.format(cwd, PATH_SNAP, parameters))
-    return ssh.run_command('{} {}'.format(PATH_SNAP, parameters))
+    return ssh.run_command('{} {}'.format(PATH_SNAP, parameters),
+                           hostname=HOSTNAME, username=USERNAME, port=PORT)
 
 
 def login(email, password):
 
=== modified file 'snappy_ecosystem_tests/helpers/snapd/staging_builder.py'
--- snappy_ecosystem_tests/helpers/snapd/staging_builder.py	2017-02-21 13:46:08 +0000
+++ snappy_ecosystem_tests/helpers/snapd/staging_builder.py	2017-03-02 10:45:12 +0000
@@ -24,6 +24,8 @@
 import sys
 from time import sleep
 
+from snappy_ecosystem_tests.environment.data.snapd import (
+    CONTAINER_HOME, CONTAINER_ENV_VARS, CONTAINER_SETUP)
 from snappy_ecosystem_tests.utils.lxd import Container, launch_container
 
 CONTAINER_HOME = '/root'
@@ -71,15 +73,20 @@
     COMMAND_EXPORT_STAGING_STORE_VAR,
     {'command': COMMAND_APT_INSTALL_STAGING_DEBS, 'cwd': DIRECTORY_CLONE}
 ]
-
-CONTAINER_ENV_VARS = {
-    'GOPATH': CONTAINER_HOME,
-    'SNAPPY_USE_STAGING_STORE': '1',
+SNAPCRAFT_STAGING_VARIABLES = {
     ENV_STORE_API_ROOT: URL_API_ROOT,
     ENV_STORE_SEARCH_ROOT: URL_SEARCH_ROOT,
     ENV_STORE_UPLOAD_ROOT: URL_UPLOAD_ROOT,
     ENV_SSO_API_ROOT: URL_SSO_API_ROOT,
 }
+SNAPD_STAGING_VARIABLES = {
+    'SNAPPY_USE_STAGING_STORE': '1'
+}
+STAGING_VARIABLES = dict(
+    SNAPCRAFT_STAGING_VARIABLES, **SNAPD_STAGING_VARIABLES)
+CONTAINER_ENV_VARS = {
+    'GOPATH': CONTAINER_HOME,
+}
 
 LOGGER = logging.getLogger(__name__)
 
 
=== modified file 'snappy_ecosystem_tests/helpers/store_apis/rest_apis.py'
--- snappy_ecosystem_tests/helpers/store_apis/rest_apis.py	2017-02-17 18:41:32 +0000
+++ snappy_ecosystem_tests/helpers/store_apis/rest_apis.py	2017-03-02 10:45:12 +0000
@@ -45,6 +45,8 @@
 from snappy_ecosystem_tests.helpers.snapcraft.options import ProjectOptions
 from snappy_ecosystem_tests.helpers.store_apis import errors
 from snappy_ecosystem_tests.helpers.store_apis.upload import upload_files
+from snappy_ecosystem_tests.models.snap import Snap
+from snappy_ecosystem_tests.utils.filters import filter_list
 
 LOGGER = logging.getLogger(__name__)
 
@@ -193,16 +195,28 @@
         """Get current account information"""
         return self._refresh_if_necessary(self.sca.get_account_information)
 
+    def get_registered_snaps(self, series=constants.DEFAULT_SERIES):
+        """Get registered snaps for current user.
+        First refresh macaroon if necessary"""
+        return self._refresh_if_necessary(self.sca.get_registered_snaps,
+                                          series)
+
+    def filter_snaps(self, series=constants.DEFAULT_SERIES, **predicates):
+        """Filter snaps that match with given predicates
+        First refresh macaroon if necessary"""
+        return self._refresh_if_necessary(self.sca.filter_snaps,
+                                          series=series, **predicates)
+
     def register_key(self, account_key_request):
         """Register a key for the current user"""
         return self._refresh_if_necessary(
             self.sca.register_key, account_key_request)
 
-    def register(self, snap_name, is_private=False):
+    def register(self, snap_name, private=False):
         """Register a package name for the current user
         First refresh macaroon if necessary"""
         return self._refresh_if_necessary(
-            self.sca.register, snap_name, is_private, constants.DEFAULT_SERIES)
+            self.sca.register, snap_name, private, constants.DEFAULT_SERIES)
 
     def push_precheck(self, snap_name):
         """Do a snap push as a pre-check (dry_run: do not actually push)
@@ -555,6 +569,36 @@
         else:
             raise errors.StoreAccountInformationError(response)
 
+    def get_registered_snaps(self, series=constants.DEFAULT_SERIES):
+        """
+        Get the registered snaps for the current user
+        :param series: get only snaps that match with this series
+        :return: the list of registered snaps
+        """
+        account_info = self.get_account_information()
+        user_snaps = account_info.get('snaps')
+        snaps_dict = user_snaps.get(series)
+        snaps = []
+        for name, snap_data in snaps_dict.items():
+            snaps.append(Snap(name=name, **snap_data))
+        return snaps
+
+    def filter_snaps(self, series=constants.DEFAULT_SERIES, **predicates):
+        """
+        Return a list of the snaps that match with all the given predicates.
+        :param: series: only look in the snaps that match with this series
+        Examples:
+        filter_snap() --> return all the snaps
+        filter_snap(name='my_name') --> return the snaps that matches with
+         name 'my_name'
+        filter_snap(name='my_name', private=True) --> return the snaps that
+         matches with name 'my_name' and are private.
+        filter_snap(price='5') --> return the snaps that with price '5'.
+        :return: A list of snap instances
+        """
+        return filter_list(self.get_registered_snaps(series=series),
+                           **predicates)
+
     def register_key(self, account_key_request):
         """Register a key for a user with the given request
         :param account_key_request: the key to register
@@ -568,20 +612,21 @@
         if not response.ok:
             raise errors.StoreKeyRegistrationError(response)
 
-    def register(self, snap_name, is_private, series):
+    def register(self, snap_name, private, series):
         """Register a snap name in the store
         :param snap_name: the name to be registered
-        :param is_private: whether the snap name is private or not
+        :param private: whether the snap name is private or not
         :param series: the snap's series to be registered
         """
         auth = _macaroon_auth(self.conf)
-        data = dict(snap_name=snap_name, is_private=is_private,
+        data = dict(snap_name=snap_name, is_private=private,
                     series=series)
         response = self.post(
             'register-name/', data=json.dumps(data),
-            headers=dict({'Authorization': auth}, **JSON_ACCEPT))
+            headers=dict({'Authorization': auth}, **JSON_CONTENT_TYPE))
         if not response.ok:
             raise errors.StoreRegistrationError(snap_name, response)
+        return True
 
     def snap_push_precheck(self, snap_name):
         """Do a snap push pre-check (dry_run: do not actually push)
 
=== added directory 'snappy_ecosystem_tests/models'
=== added file 'snappy_ecosystem_tests/models/__init__.py'
--- snappy_ecosystem_tests/models/__init__.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/models/__init__.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,19 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Snappy Ecosystem Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
 
=== added file 'snappy_ecosystem_tests/models/snap.py'
--- snappy_ecosystem_tests/models/snap.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/models/snap.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,39 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Snappy Ecosystem Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""Business model classes for snaps"""
+
+
+class Snap:
+    """Represents a snap entity."""
+
+    def __init__(self, name='', price=None, private=False, since=None,
+                 _id=None, status=None, notes=None, **kwargs):
+        self.name = name
+        self.price = price
+        self.private = private
+        self.since = since
+        self._id = _id or kwargs.get('snap-id')
+        self.status = status
+        self.notes = notes
+
+    def is_private(self):
+        """Return True if the snap is private, False otherwise"""
+        return self.private
 
=== modified file 'snappy_ecosystem_tests/run.py'
--- snappy_ecosystem_tests/run.py	2017-02-15 19:14:19 +0000
+++ snappy_ecosystem_tests/run.py	2017-03-02 10:45:12 +0000
@@ -20,28 +20,38 @@
 
 """Entry point to run snappy ecosystem tests"""
 
+import argparse
+import os
 import re
 import sys
 import pytest
 
-FILTER_ARGUMENTS = '--proxy'
-
-
-def _filter_arguments():
-    """Remove from command line arguments all the ones that are in
-     FILTER_ARGUMENTS list."""
-    filtered_args = sys.argv[1:]
-    for i, arg in enumerate(sys.argv[1:]):
-        if arg in FILTER_ARGUMENTS:
-            filtered_args.pop(i + 1)
-            filtered_args.pop(i)
-    return filtered_args
-
 
 def _parse_arguments():
     """Parse and filter command line arguments to makethem pytest compatible"""
     sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-    return _filter_arguments()
+    parser = argparse.ArgumentParser(description=
+                                     'Run snappy ecosystem tests.')
+    parser.add_argument('--proxy',
+                        help='proxy to use for creating the virtual env.',
+                        required=False)
+    parser.add_argument('--target', default="lxd",
+                        help='Target on which tests will be executed.')
+    ecosystem_args, pytest_args = parser.parse_known_args()
+    _set_env_variables(ecosystem_args)
+    return pytest_args
+
+
+def _set_env_variables(args):
+    """
+    Set environment variables with ecosystem arguments passed
+    in the command line.
+    :param args: The arguments to store in env variables
+    """
+    for arg in vars(args):
+        value = getattr(args, arg, None)
+        if value:
+            os.environ[arg] = value
 
 if __name__ == '__main__':
     sys.exit(pytest.main(args=_parse_arguments() + ['-p', 'no:cacheprovider']))
 
=== added file 'snappy_ecosystem_tests/tests/test_register_snap.py'
--- snappy_ecosystem_tests/tests/test_register_snap.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/tests/test_register_snap.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,116 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Snappy Ecosystem Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""Tests for Registering a snap name in the store"""
+
+import uuid
+
+from snappy_ecosystem_tests.helpers.snapcraft.client import Snapcraft
+from snappy_ecosystem_tests.helpers.store_apis.rest_apis import Store
+from snappy_ecosystem_tests.helpers.test_base import SnappyEcosystemTestCase
+from snappy_ecosystem_tests.utils.storeconfig import get_store_credentials
+
+
+class RegisterSnapNameTestCase(SnappyEcosystemTestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.store = Store()
+        self.snapcraft = Snapcraft()
+        self.store.login(*get_store_credentials())
+        self.addCleanup(self.store.logout)
+        self.snapcraft.login()
+        self.addCleanup(self.snapcraft.logout)
+
+    @staticmethod
+    def _get_random_snap_name(prefix='ecosystem-test'):
+        """Get a random snap name using uuid
+        :param prefix: the string prefix,
+        if not provided, use default one.
+        """
+        return '{}{}'.format(prefix, int(uuid.uuid4()))
+
+    def test_register_public_snap_name_using_snapcraft(self):
+        """Test register a public snap name via snapcraft
+        and verify it via REST API"""
+        # Register snap via Snapcraft
+        snap_name = self._get_random_snap_name()
+        self.assertTrue(self.snapcraft.register(snap_name),
+                        'Unable to register snap')
+
+        # Verify the registered snap via REST API
+        snaps = self.store.filter_snaps(name=snap_name)
+        self.assertEqual(1, len(snaps),
+                         'Expected 1 snap with name %s but found %s'
+                         % (snap_name, len(snaps)))
+        snap = snaps[0]
+        self.assertEqual(snap_name, snap.name)
+        self.assertFalse(snap.is_private())
+
+    def test_register_private_snap_name_using_snapcraft(self):
+        """Test register a private snap name via snapcraft
+        and verify it via REST API"""
+        # Register snap via Snapcraft
+        snap_name = self._get_random_snap_name()
+        self.assertTrue(self.snapcraft.register(snap_name, private=True),
+                        'Unable to register snap')
+
+        # Verify the registered snap via REST API
+        snaps = self.store.filter_snaps(name=snap_name)
+        self.assertEqual(1, len(snaps),
+                         'Expected 1 snap with name %s but found %s'
+                         % (snap_name, len(snaps)))
+        snap = snaps[0]
+        self.assertEqual(snap_name, snap.name)
+        self.assertTrue(snap.is_private())
+
+    def test_register_public_snap_name_using_api(self):
+        """Verify that snapcraft lists a new snap registered via
+        RESTful API when using the command snapcraft list-registered"""
+        # Register snap via API
+        snap_name = self._get_random_snap_name()
+        self.assertTrue(self.store.register(snap_name),
+                        'Unable to register snap')
+
+        # Verify the registered snap via Snapcraft
+        snaps = self.snapcraft.filter_snaps(name=snap_name)
+        self.assertEqual(1, len(snaps),
+                         'Expected 1 snap with name %s but found %s'
+                         % (snap_name, len(snaps)))
+        snap = snaps[0]
+        self.assertEqual(snap_name, snap.name)
+        self.assertFalse(snap.is_private())
+
+    def test_register_private_snap_name_using_api(self):
+        """Verify that snapcraft lists a new private snap registered via
+        RESTful API when using the command snapcraft list-registered"""
+        # Register snap via API
+        snap_name = self._get_random_snap_name()
+        self.assertTrue(self.store.register(snap_name, private=True),
+                        'Unable to register snap')
+
+        # Verify the registered snap via Snapcraft
+        snaps = self.snapcraft.filter_snaps(name=snap_name)
+        self.assertEqual(1, len(snaps),
+                         'Expected 1 snap with name %s but found %s'
+                         % (snap_name, len(snaps)))
+        snap = snaps[0]
+        self.assertEqual(snap_name, snap.name)
+        self.assertTrue(snap.is_private())
 
=== added file 'snappy_ecosystem_tests/unittests/test_filters.py'
--- snappy_ecosystem_tests/unittests/test_filters.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/unittests/test_filters.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,113 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Snappy Ecosystem Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""Unit tests cases for filter utils"""
+
+from testtools import (
+    TestCase,
+    ExpectedException
+)
+
+from snappy_ecosystem_tests.utils.filters import (
+    object_filter,
+    filter_list
+)
+
+
+class DummyObject:  # pylint: disable=too-few-public-methods
+    """Dummy object to be used in unit tests"""
+
+    def __init__(self, **kwargs):
+        for _k, _v in kwargs.items():
+            setattr(self, _k, _v)
+
+
+class FilterTestCase(TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.obj = DummyObject(name='dummy', desc='this is dummy')
+        self.obj_2 = DummyObject(name='another-dummy',
+                                 desc='this is another dummy')
+        self.objects = [self.obj, self.obj_2]
+
+    def test_object_filter_with_single_argument(self):
+        """Filter successfully passing one argument"""
+        objects = list(filter(object_filter(name='dummy'), self.objects))
+        self.assertIsNotNone(objects)
+        self.assertEqual(len(objects), 1)
+        self.assertEqual(objects[0], self.obj)
+
+    def test_object_filter_with_multiple_arguments(self):
+        """Filter successfully passing two arguments"""
+        objects = list(filter(object_filter(name='dummy',
+                                            desc='this is dummy'),
+                              self.objects))
+        self.assertIsNotNone(objects)
+        self.assertEqual(len(objects), 1)
+        self.assertEqual(objects[0], self.obj)
+
+    def test_object_filter_does_not_match(self):
+        """Return empty list when no object match criteria"""
+        objects = list(filter(object_filter(name='dummy',
+                                            desc='any desc'),
+                              self.objects))
+        self.assertEqual([], objects)
+
+    def test_object_filter_return_all(self):
+        """Get all objects when no filter is provided"""
+        objects = list(filter(object_filter(), self.objects))
+        self.assertEqual(len(objects), len(self.objects))
+
+    def test_object_filter_raises_attribute_error_if_invalid_filter_name(self):
+        """Object filter raises AttributeError when invalid filter
+         is provided"""
+        with ExpectedException(AttributeError):
+            list(filter(object_filter(invalid='dummy'), self.objects))
+
+    def test_filter_list_with_single_argument(self):
+        """Filter List successfully passing one argument"""
+        objects = filter_list(self.objects, name='dummy')
+        self.assertIsNotNone(objects)
+        self.assertEqual(len(objects), 1)
+        self.assertEqual(objects[0], self.obj)
+
+    def test_filter_list_with_multiple_arguments(self):
+        """Filter List successfully passing multiple argument"""
+        objects = filter_list(self.objects, name='another-dummy',
+                              desc='this is another dummy')
+        self.assertIsNotNone(objects)
+        self.assertEqual(len(objects), 1)
+        self.assertEqual(objects[0], self.obj_2)
+
+    def test_filter_list_does_not_match(self):
+        """Filter List returns empty list when no object match criteria"""
+        objects = filter_list(self.objects, desc='desc does not match')
+        self.assertEqual([], objects)
+
+    def test_filter_list_return_all(self):
+        """Filter list returns all objects when no filter is provided"""
+        objects = filter_list(self.objects)
+        self.assertEqual(len(objects), len(self.objects))
+
+    def test_filter_list_raises_attribute_error_if_invalid_filter_name(self):
+        """Filter list raises AttributeError when invalid filter is provided"""
+        with ExpectedException(AttributeError):
+            filter_list(self.objects, invalid='invalid filter')
 
=== removed file 'snappy_ecosystem_tests/unittests/test_snapcraft.py'
--- snappy_ecosystem_tests/unittests/test_snapcraft.py	2017-02-13 16:00:04 +0000
+++ snappy_ecosystem_tests/unittests/test_snapcraft.py	1970-01-01 00:00:00 +0000
@@ -1,31 +0,0 @@
-# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-
-#
-# Snappy Ecosystem Tests
-# Copyright (C) 2017 Canonical
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-"""Unit tests cases for snapcraft"""
-
-from unittest2 import TestCase
-
-
-class SnapcraftTestCase(TestCase):
-
-    def test_snapcraft_dummy_test(self):
-        """Dummy test case"""
-        _a = True
-        self.assertTrue(_a)
 
=== added file 'snappy_ecosystem_tests/utils/commands.py'
--- snappy_ecosystem_tests/utils/commands.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/utils/commands.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,31 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Snappy Ecosystem Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""Manage commands to be executed in a shell"""
+
+
+def build_command(command, *args):
+    """
+    Build a command with arguments
+    :param command: the executable that is going to be used
+    :param args: list of arguments for the command
+    :return: the command ready to be executed
+    """
+    return'{c} {a}'.format(c=command, a=' '.join(args)).strip()
 
=== added file 'snappy_ecosystem_tests/utils/filters.py'
--- snappy_ecosystem_tests/utils/filters.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/utils/filters.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,51 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Snappy Ecosystem Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""Filter utils"""
+
+
+def object_filter(**predicates):
+    """
+    Higher-order function to build and return an object filter function
+     :param predicates: key/values that represent
+     the conditions to look for in the object instance.
+    :return: a function to be used with filter or lambda expressions.
+    :raise: AttributeError if any of the attributes provided in predicates
+     does not exists
+    """
+    def wrapped_filter(instance):
+        """wrapped function to be returned when calling object_filter"""
+        return all(getattr(instance,
+                           param) == val for param, val in predicates.items())
+    return wrapped_filter
+
+
+def filter_list(objects_list, **predicates):
+    """
+    Filter a list of objects with the given predicates
+    :param objects_list: the target list that contains
+     the objects to be filtered
+    :param predicates: key/values that represent
+    the conditions to look for in the object list.
+    :return: A list with the objects that match all the predicates
+    :raise: AttributeError if any of the attributes provided in predicates
+     does not exists
+    """
+    return list(filter(object_filter(**predicates), objects_list))
 
=== modified file 'snappy_ecosystem_tests/utils/ssh.py'
--- snappy_ecosystem_tests/utils/ssh.py	2017-02-22 18:56:04 +0000
+++ snappy_ecosystem_tests/utils/ssh.py	2017-03-02 10:45:12 +0000
@@ -23,6 +23,8 @@
 import paramiko
 
 from snappy_ecosystem_tests.utils.user import get_remote_host_credentials
+from snappy_ecosystem_tests.helpers.snapd.staging_builder import (
+    STAGING_VARIABLES)
 
 
 class SSHManager:
@@ -83,10 +85,13 @@
     :raises ValueError: if command exits with non-zero status.
     :return: the stdout of the command.
     """
-    _hostname, _username, _port = get_remote_host_credentials()
+    # Take snapd remote credentials as default if they are not provided.
+    # Just arbitrary... Could have been other ones.
+    _hostname, _username, _port = get_snapd_remote_host_credentials()
     ssh = SSHManager.get_instance(
         hostname or _hostname, username or _username, port or _port)
-    _, stdout, stderr = ssh.exec_command(command)
+    _, stdout, stderr = ssh.exec_command(
+        command, environment=STAGING_VARIABLES)
     if stdout.channel.recv_exit_status() != 0:
         raise ValueError(stderr.read().decode())
     return stdout.read().decode()
 
=== added file 'snappy_ecosystem_tests/utils/store_versions.py'
--- snappy_ecosystem_tests/utils/store_versions.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/utils/store_versions.py	2017-03-02 10:45:12 +0000
@@ -0,0 +1,74 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Snappy Ecosystem Tests
+# Copyright (C) 2017 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""Utility for printing Store versions of: CPI, SCA and SSO.
+To be called as a standalone script.
+"""
+
+import requests
+
+DEFAULT_HEADER = "X-BZR-REVISION-NUMBER"
+
+SERVICES_INFO = dict(
+    CPI=('https://search.apps.ubuntu.com/api/v1',
+         'https://search.apps.staging.ubuntu.com/api/v1'),
+    SCA=('https://myapps.developer.ubuntu.com/',
+         'https://myapps.developer.staging.ubuntu.com/'),
+    SSO=('https://login.ubuntu.com/',
+         'https://login.staging.ubuntu.com/'),
+)
+
+
+def get_deployed_revno(service, environment):
+    """Get revno from service."""
+    prod, stag = SERVICES_INFO[service]
+    if environment == 'staging':
+        url = stag
+    else:
+        url = prod
+    with requests.Session() as session:
+        resp = session.get(url)
+        if resp.status_code == 200:
+            revno = resp.headers[DEFAULT_HEADER]
+        else:
+            print("{} 500'ed: {}".format(service, resp.text))
+            revno = 0
+    return service, environment, revno
+
+
+def print_versions():
+    """Print Store components version"""
+    coros = []
+    for service in SERVICES_INFO:
+        coro = get_deployed_revno(service, 'staging')
+        coros.append(coro)
+        coro = get_deployed_revno(service, 'production')
+        coros.append(coro)
+
+    data = {(service, kind): value for service, kind, value in coros}
+    print("#########################-STORE VERSIONS-#########################")
+    for service in sorted(SERVICES_INFO):
+        print("{}:    Staging:    {:>5}".format(service,
+                                                data[(service, 'staging')]))
+        print("{}:    Production: {:>5}".format(service,
+                                                data[(service, 'production')]))
+
+if __name__ == '__main__':
+    print_versions()
 
=== modified file 'snappy_ecosystem_tests/utils/storeconfig.py'
--- snappy_ecosystem_tests/utils/storeconfig.py	2017-02-15 19:14:19 +0000
+++ snappy_ecosystem_tests/utils/storeconfig.py	2017-03-02 10:45:12 +0000
@@ -27,8 +27,8 @@
     USER_CONFIG_STACK
 )
 
-URL_WEB_STORE_PRODUCTION = CONFIG_STACK.get('web-ui', 'production_url')
-URL_WEB_STORE_STAGING = CONFIG_STACK.get('web-ui', 'stage_url')
+URL_WEB_STORE_PRODUCTION = CONFIG_STACK.get('production_urls', 'web')
+URL_WEB_STORE_STAGING = CONFIG_STACK.get('staging_urls', 'web')
 
 
 def get_store_credentials():
 
=== modified file 'snappy_ecosystem_tests/utils/user.py'
--- snappy_ecosystem_tests/utils/user.py	2017-02-22 15:39:40 +0000
+++ snappy_ecosystem_tests/utils/user.py	2017-03-02 10:45:12 +0000
@@ -23,13 +23,34 @@
 import os
 
 from snappy_ecosystem_tests.commons.config import USER_CONFIG_STACK
-
-
-def get_remote_host_credentials():
-    """Return credentials for remote machine, to run commands on."""
-    return (USER_CONFIG_STACK.get('user', 'hostname_remote',
-                                  default=os.environ.get('hostname_remote')),
-            USER_CONFIG_STACK.get('user', 'username_remote',
-                                  default=os.environ.get('username_remote')),
-            USER_CONFIG_STACK.get('user', 'port_remote',
-                                  default=os.environ.get('port_remote')))
+from snappy_ecosystem_tests.environment.managers import get_manager
+
+MANAGER = get_manager(os.environ['target'])
+
+
+def get_snapd_remote_host_credentials():
+    """Return credentials for snapd remote machine, to run commands on."""
+    _ip = MANAGER.get_ip(USER_CONFIG_STACK.get(
+        'user', 'snapd_hostname_remote',
+        default=os.environ.get('snapd_hostname_remote')))
+    return (_ip,
+            USER_CONFIG_STACK.get('user', 'snapd_username_remote',
+                                  default=os.environ.get(
+                                      'snapd_username_remote')),
+            USER_CONFIG_STACK.get('user', 'snapd_port_remote',
+                                  default=os.environ.get(
+                                      'snapd_port_remote')))
+
+
+def get_snapcraft_remote_host_credentials():
+    """Return credentials for snapcraft remote machine, to run commands on."""
+    _ip = MANAGER.get_ip(USER_CONFIG_STACK.get(
+        'user', 'snapcraft_hostname_remote',
+        default=os.environ.get('snapcraft_snapcraft_remote')))
+    return (_ip,
+            USER_CONFIG_STACK.get('user', 'snapcraft_username_remote',
+                                  default=os.environ.get(
+                                      'snapcraft_username_remote')),
+            USER_CONFIG_STACK.get('user', 'snapcraft_port_remote',
+                                  default=os.environ.get(
+                                      'snapcraft_port_remote')))