Merge lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers into lp:snappy-ecosystem-tests

[Heber Parrucci]

Adding helpers for Store RESTful APIs.
Also includes a first version of ecosystem test base clase and fixture setup.

This change adds helpers for Store RESTful APIs, a first version of snappy ecosystem test base class and a fixture setup

A simple test was added for making sure we can authenticate against Store RESTful APIs. You can run it: ./run_system_tests snappy_ecosystem_tests/tests/test_store_apis_login.py

[I Ahmad (iahmad)]

How about using it as it is from snapcraft/storeapi as it is, instead of making a copy? that way we won't have to catchup the changes upstream.

Also if we have an example test case along with the merge then it will become convenient to test the base and other utility classes.

Otherwise LGTM

[Omer Akram (om26er)]

Thanks for working on this, I was not able to test the code but wrote some inline comments and suggestions.

review: Needs Fixing

[Omer Akram (om26er)]

We are missing docstrings, so it would also be helpful if you could add docstrings for the methods.

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

FAILED: Continuous integration, rev:6
https://platform-qa-jenkins.ubuntu.com/job/snappy-ecosystem-tests-ci/8/
Executed test runs:
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/1565/console

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

review: Needs Fixing (continuous-integration)

[Santiago Baldassin (sbaldassin)]

Looks good in general. I just think that we should rethink the way the different clients are represented here. So far it is a little bit confussing

review: Needs Fixing

[Heber Parrucci (heber013)]

Reply inline. I will address other comments once we agree in this one, because it would make other comments as not valid depending on which approach we take: use snapcraft upstream code or not.

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

FAILED: Continuous integration, rev:6
https://platform-qa-jenkins.ubuntu.com/job/snappy-ecosystem-tests-ci/35/
Executed test runs:
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/1616/console

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

review: Needs Fixing (continuous-integration)

[lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers]

7. By Heber Parrucci on 2017-02-15

Fixing comments on code review.
Fixing pylint issues.
Addind a simple test for login to Store REST API

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

FAILED: Continuous integration, rev:7
https://platform-qa-jenkins.ubuntu.com/job/snappy-ecosystem-tests-ci/38/
Executed test runs:
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/1623/console

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

review: Needs Fixing (continuous-integration)

[lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers]

8. By Heber Parrucci on 2017-02-15

fixing error in requirements.txt

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

FAILED: Continuous integration, rev:8
https://platform-qa-jenkins.ubuntu.com/job/snappy-ecosystem-tests-ci/39/
Executed test runs:
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/1624/console

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

review: Needs Fixing (continuous-integration)

[lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers]

9. By Heber Parrucci on 2017-02-15

removing duplicated dependencies in requirements.txt

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

FAILED: Continuous integration, rev:9
https://platform-qa-jenkins.ubuntu.com/job/snappy-ecosystem-tests-ci/40/
Executed test runs:
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/1625/console

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

review: Needs Fixing (continuous-integration)

[lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers]

10. By Heber Parrucci on 2017-02-15

changing dict initialization sintax according to PEP 448

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

FAILED: Continuous integration, rev:10
https://platform-qa-jenkins.ubuntu.com/job/snappy-ecosystem-tests-ci/41/
Executed test runs:
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/1626/console

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

review: Needs Fixing (continuous-integration)

[lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers]

11. By Heber Parrucci on 2017-02-15

Merge from parent branch and fixing pylint to met max-line-length=80

12. By Heber Parrucci on 2017-02-15

deleting file not needed

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

FAILED: Continuous integration, rev:11
https://platform-qa-jenkins.ubuntu.com/job/snappy-ecosystem-tests-ci/43/
Executed test runs:
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/1628/console

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

review: Needs Fixing (continuous-integration)

[lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers]

13. By Heber Parrucci on 2017-02-15

changing dict initialization

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

FAILED: Continuous integration, rev:12
https://platform-qa-jenkins.ubuntu.com/job/snappy-ecosystem-tests-ci/44/
Executed test runs:
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/1629/console

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

review: Needs Fixing (continuous-integration)

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

FAILED: Continuous integration, rev:13
https://platform-qa-jenkins.ubuntu.com/job/snappy-ecosystem-tests-ci/45/
Executed test runs:
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/1630/console

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

review: Needs Fixing (continuous-integration)

[lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers]

14. By Heber Parrucci on 2017-02-15

chaning dict initialization until jenkins slave is updated

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

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

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

review: Approve (continuous-integration)

[Omer Akram (om26er)]

Can you tell how should the config file look like ? I ran the tests and got http://paste.ubuntu.com/24006501/ as the config file was probably empty.

review: Needs Information

[lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers]

15. By Heber Parrucci on 2017-02-16

Updating README.rst with user credentials instructions

[Heber Parrucci (heber013)]

> Can you tell how should the config file look like ? I ran the tests and got
> http://paste.ubuntu.com/24006501/ as the config file was probably empty.

Thanks for reviewing!
I have added a section in README that is called: 'User Credentials' here it explains the alternatives for providing them.

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

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

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

review: Approve (continuous-integration)

[lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers]

16. By Heber Parrucci on 2017-02-16

merge from trunk

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

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

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

review: Approve (continuous-integration)

[lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers]

17. By Heber Parrucci on 2017-02-16

Updating README.rst to make storing credentials section more clear.

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

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

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

review: Approve (continuous-integration)

[lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers]

18. By Heber Parrucci on 2017-02-17

renaming class Store and adding a better docstring

19. By Heber Parrucci on 2017-02-17

fixing pylint

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

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

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

review: Approve (continuous-integration)

[Santiago Baldassin (sbaldassin)]

Code looks good to me

review: Approve

[lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers]

20. By Heber Parrucci on 2017-02-20

updating license year in headers

[Omer Akram (om26er)]

code looks good. test passes. Lets land it.

review: Approve

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

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

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

review: Approve (continuous-integration)

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

review: Approve (continuous-integration)

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

review: Approve (continuous-integration)

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

review: Approve (continuous-integration)

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

review: Approve (continuous-integration)

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

review: Approve (continuous-integration)

[lp:~canonical-platform-qa/snappy-ecosystem-tests/store-rest-helpers]

21. By Heber Parrucci on 2017-02-20

merge from trunk

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

review: Approve (continuous-integration)

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

review: Approve (continuous-integration)

=== modified file 'README.rst'
--- README.rst	2017-02-13 16:00:04 +0000
+++ README.rst	2017-02-20 17:48:06 +0000
@@ -56,6 +56,25 @@
 
 pytest.cfg stores the config related to pytest
 
+User Credentials
+================
+For storing user credentials you have 2 options:
+
+option 1 - You can create a config file in your local machine with path:
+~/.config/ecosystem_tests.cfg
+You can change the dir location of that config file by setting the env variable:
+XDG_USER_CONFIG_HOME=^DIR_PATH^
+
+The config file should look like:
+[user]
+user_email=^USER_NAME^
+user_password=^USER_PASSWORD^
+
+option 2 - Set the following environment variables:
+user_email=^USER_NAME^
+user_password=^USER_PASSWORD^
+
+
 Changing store:
 ===============
 You can change the store to use in config file ecosystem_tests.cfg

=== modified file 'pylint.cfg'
--- pylint.cfg	2017-02-15 19:14:19 +0000
+++ pylint.cfg	2017-02-20 17:48:06 +0000
@@ -336,7 +336,7 @@
 [DESIGN]
 
 # Maximum number of arguments for function / method
-max-args=5
+max-args=8
 
 # Argument names that match this expression will be ignored. Default to name
 # with leading underscore

=== modified file 'requirements.txt'
--- requirements.txt	2017-02-13 17:43:02 +0000
+++ requirements.txt	2017-02-20 17:48:06 +0000
@@ -1,3 +1,4 @@
+libnacl
 pytest
 testtools
 unittest2
@@ -11,4 +12,6 @@
 pyxdg==0.25
 jsonschema==2.5.1
 pexpect
+pymacaroons==0.9.2
+requests-toolbelt==0.6.0
 chromedriver_installer

=== modified file 'snappy_ecosystem_tests/helpers/fixture_setup.py'
--- snappy_ecosystem_tests/helpers/fixture_setup.py	2017-02-15 19:14:19 +0000
+++ snappy_ecosystem_tests/helpers/fixture_setup.py	2017-02-20 17:48:06 +0000
@@ -18,10 +18,13 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-"""Manage general tests fixtures"""
+
+"""General fixtures related to the store and the tests environment"""
 
 import os
+
 import fixtures
+
 from snappy_ecosystem_tests.commons.config import CONFIG_STACK
 from snappy_ecosystem_tests.utils.storeconfig import get_current_store
 
@@ -30,10 +33,8 @@
     """Create a temporary directory an cd into it for the test duration."""
 
     def setUp(self):
-        """Create a temporary directory an cd into it for the test duration."""
         super().setUp()
-        current_dir = os.getcwd()
-        self.addCleanup(os.chdir, current_dir)
+        self.addCleanup(os.chdir, os.getcwd())
         os.chdir(self.path)
 
 
@@ -43,10 +44,8 @@
 
     def setUp(self):
         super().setUp()
-
         current_environment = os.environ.copy()
         os.environ = {}
-
         self.addCleanup(os.environ.update, current_environment)
 
 

=== added directory 'snappy_ecosystem_tests/helpers/snapcraft'
=== added file 'snappy_ecosystem_tests/helpers/snapcraft/__init__.py'
--- snappy_ecosystem_tests/helpers/snapcraft/__init__.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/helpers/snapcraft/__init__.py	2017-02-20 17:48:06 +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/helpers/snapcraft/client.py'
--- snappy_ecosystem_tests/helpers/snapcraft/client.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/helpers/snapcraft/client.py	2017-02-20 17:48:06 +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/>.
+#
+
+"""Snapcraft client helpers"""
+
+import pexpect
+
+
+# login credentials exported by shell environment
+from snappy_ecosystem_tests.utils import storeconfig
+
+LOGIN_EMAIL, LOGIN_PASSWORD = storeconfig.get_store_credentials()
+
+
+class Snapcraft(object):
+    """Contain Snapcraft specific functionality to use via command
+    line interface"""
+    def __init__(self):
+        """Create new snapcraft instance."""
+        self._login = False
+        self._cleanup()
+
+    def _cleanup(self):
+        """Perform cleanup actions"""
+        self.logout()
+
+    def logout(self):
+        """logout of snapcraft store session"""
+        child = pexpect.spawn("snapcraft logout")
+        err = child.expect('Credentials cleared.')
+        child.terminate(True)
+        child.wait()
+        if err is not 0:
+            raise ValueError("Failed to logout")
+
+        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()

=== added file 'snappy_ecosystem_tests/helpers/snapcraft/config.py'
--- snappy_ecosystem_tests/helpers/snapcraft/config.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/helpers/snapcraft/config.py	2017-02-20 17:48:06 +0000
@@ -0,0 +1,114 @@
+# -*- 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/>.
+#
+
+"""Helpers to store/manage/load snapcraft configuration in a config file"""
+
+import configparser
+import logging
+import os
+import urllib.parse
+
+from snappy_ecosystem_tests.commons.config import CONFIG_STACK
+from xdg import BaseDirectory
+
+LOCAL_CONFIG_FILENAME = '.snapcraft/snapcraft.cfg'
+
+LOGGER = logging.getLogger(__name__)
+
+
+class SnapcraftConfig(object):
+    """Hold configuration options in sections.
+    There can be two sections for the sso related credentials: production and
+    staging. This is governed by the UBUNTU_SSO_API_ROOT_URL environment
+    variable. Other sections are ignored but preserved.
+    """
+
+    def __init__(self):
+        self.parser = configparser.ConfigParser()
+        self.filename = None
+        self.load()
+
+    @staticmethod
+    def _section_name():
+        """Return a section"""
+        # The only section we care about is the host from the SSO url
+        url = os.environ.get('UBUNTU_SSO_API_ROOT_URL',
+                             CONFIG_STACK.config.get('production_urls', 'sso'))
+        return urllib.parse.urlparse(url).netloc
+
+    def get(self, option_name):
+        """Get an option name for a given section"""
+        try:
+            return self.parser.get(self._section_name(), option_name)
+        except (configparser.NoSectionError,
+                configparser.NoOptionError,
+                KeyError):
+            return None
+
+    def set(self, option_name, value):
+        """Set an option with the given value"""
+        section_name = self._section_name()
+        if not self.parser.has_section(section_name):
+            self.parser.add_section(section_name)
+        return self.parser.set(section_name, option_name, value)
+
+    def is_empty(self):
+        """Return True if snapcraft config does not have the default section
+         name"""
+        # Only check the current section
+        section_name = self._section_name()
+        if self.parser.has_section(section_name):
+            if self.parser.options(section_name):
+                return False
+        return True
+
+    def load(self):
+        """Load the snapcraft configuration"""
+        # Local configurations (per project) are supposed to be static.
+        # That's why it's only checked for 'loading' and never written to.
+        # Essentially, all authentication-related changes, like login/logout
+        # or macaroon-refresh, will not be persisted for the next runs.
+        if os.path.exists(LOCAL_CONFIG_FILENAME):
+            self.parser.read(LOCAL_CONFIG_FILENAME)
+            LOGGER.warning(
+                'Using local configuration (`%s`), changes will '
+                'not be persisted.', LOCAL_CONFIG_FILENAME)
+            return
+
+        self.filename = BaseDirectory.load_first_config(
+            'snapcraft', 'snapcraft.cfg')
+        if self.filename and os.path.exists(self.filename):
+            self.parser.read(self.filename)
+
+    @staticmethod
+    def save_path():
+        """Return the save path for the snapcraft configuration"""
+        return os.path.join(BaseDirectory.save_config_path('snapcraft'),
+                            'snapcraft.cfg')
+
+    def save(self):
+        """Save the current configuration in the save path"""
+        self.filename = self.save_path()
+        with open(self.filename, 'w') as _f:
+            self.parser.write(_f)
+
+    def clear(self):
+        """Clear the current configuration"""
+        self.parser.remove_section(self._section_name())

=== added file 'snappy_ecosystem_tests/helpers/snapcraft/constants.py'
--- snappy_ecosystem_tests/helpers/snapcraft/constants.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/helpers/snapcraft/constants.py	2017-02-20 17:48:06 +0000
@@ -0,0 +1,52 @@
+# -*- 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/>.
+#
+
+"""Store snapcraft constants"""
+
+from __future__ import absolute_import, unicode_literals
+
+
+DEFAULT_SERIES = '16'
+SCAN_STATUS_POLL_DELAY = 5
+SCAN_STATUS_POLL_RETRIES = 5
+
+# Messages and warnings.
+MISSING_AGREEMENT = 'Developer has not signed agreement.'
+MISSING_NAMESPACE = 'Developer profile is missing short namespace.'
+AGREEMENT_ERROR = (
+    'You must agree to the developer terms and conditions to upload snaps.')
+NAMESPACE_ERROR = (
+    'You need to set a username. It will appear in the developer field '
+    'alongside the other details for your snap. Please visit {} and login '
+    'again.')
+AGREEMENT_INPUT_MSG = (
+    'Do you agree to the developer terms and conditions. ({})? [y/N] ')
+AGREEMENT_SIGN_ERROR = (
+    'Unexpected error encountered during signing the developer terms and '
+    'conditions. Please visit {} and agree to the terms and conditions before '
+    'continuing.')
+TWO_FACTOR_WARNING = (
+    'We strongly recommend enabling multi-factor authentication: '
+    'https://help.ubuntu.com/community/SSO/FAQs/2FA')
+INVALID_CREDENTIALS = 'Invalid credentials supplied.'
+AUTHENTICATION_ERROR = ('Problems encountered when authenticating your '
+                        'credentials.')
+ACCOUNT_INFORMATION_ERROR = ('Unexpected error when obtaining your account '
+                             'information.')

=== added file 'snappy_ecosystem_tests/helpers/snapcraft/deprecations.py'
--- snappy_ecosystem_tests/helpers/snapcraft/deprecations.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/helpers/snapcraft/deprecations.py	2017-02-20 17:48:06 +0000
@@ -0,0 +1,56 @@
+# -*- 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/>.
+#
+
+"""Handle surfacing deprecation notices.
+
+When a new deprecation has occurred, write a Deprecation Notice for it on the
+wiki, assigning it the next ID (DN1, DN2, etc.). Then add that ID along with a
+brief message for surfacing to the user into the _DEPRECATION_MESSAGES in this
+module.
+"""
+
+import logging
+
+_DEPRECATION_MESSAGES = {
+    'dn1': "The 'snap' keyword has been replaced by 'prime'.",
+    'dn2': "Custom plugins should now be placed in 'snap/plugins'.",
+    'dn3': "Assets in 'setup/gui' should now be placed in 'snap/gui'.",
+}
+
+_DEPRECATION_URL_FMT = 'http://snapcraft.io/docs/deprecation-notices/{id}'
+
+LOGGER = logging.getLogger(__name__)
+
+
+def _deprecation_message(_id):
+    """Return the deprecation message for the given id
+    :raise RuntimeError
+    """
+    message = _DEPRECATION_MESSAGES.get(_id)
+    if not message:
+        raise RuntimeError('No deprecation notice with id {!r}'.format(id))
+    return message
+
+
+def handle_deprecation_notice(_id):
+    """Handle deprecation notice by logging a message"""
+    message = _deprecation_message(_id)
+    LOGGER.warning('DEPRECATED: %s\nSee %s for more information.',
+                   message, _DEPRECATION_URL_FMT.format(id=_id))

=== added file 'snappy_ecosystem_tests/helpers/snapcraft/indicators.py'
--- snappy_ecosystem_tests/helpers/snapcraft/indicators.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/helpers/snapcraft/indicators.py	2017-02-20 17:48:06 +0000
@@ -0,0 +1,118 @@
+# -*- 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/>.
+#
+
+"""Helpers for snapcraft indicators with pretty progress bar"""
+
+import os
+import sys
+
+from urllib.request import urlretrieve
+from progressbar import (
+    AnimatedMarker,
+    Bar,
+    Percentage,
+    ProgressBar,
+    UnknownLength,
+)
+
+
+def _init_progress_bar(total_length, destination, message=None):
+    """Init the progress bar with the given length, destination and message"""
+    if not message:
+        message = 'Downloading {!r}'.format(os.path.basename(destination))
+
+    valid_length = total_length and total_length > 0
+
+    if valid_length and is_dumb_terminal():
+        widgets = [message, ' ', Percentage()]
+        maxval = total_length
+    elif valid_length and not is_dumb_terminal():
+        widgets = [message,
+                   Bar(marker='=', left='[', right=']'),
+                   ' ', Percentage()]
+        maxval = total_length
+    elif not valid_length and is_dumb_terminal():
+        widgets = [message]
+        maxval = UnknownLength
+    else:
+        widgets = [message, AnimatedMarker()]
+        maxval = UnknownLength
+
+    return ProgressBar(widgets=widgets, maxval=maxval)
+
+
+def download_requests_stream(request_stream, destination, message=None):
+    """This is a facility to download a request with nice progress bars."""
+
+    # Doing len(request_stream.content) may defeat the purpose of a
+    # progress bar
+    total_length = 0
+    if not request_stream.headers.get('Content-Encoding', ''):
+        total_length = int(request_stream.headers.get('Content-Length', '0'))
+
+    total_read = 0
+    progress_bar = _init_progress_bar(total_length, destination, message)
+    progress_bar.start()
+    with open(destination, 'wb') as destination_file:
+        for buf in request_stream.iter_content(1024):
+            destination_file.write(buf)
+            total_read += len(buf)
+            progress_bar.update(total_read)
+    progress_bar.finish()
+
+
+class UrllibDownloader(object):
+    """This is a facility to download an uri with nice progress bars."""
+
+    def __init__(self, uri, destination, message=None):
+        self.uri = uri
+        self.destination = destination
+        self.message = message
+        self.progress_bar = None
+
+    def download(self):
+        """Download with a pretty progress bar"""
+        urlretrieve(self.uri, self.destination, self._progress_callback)
+
+        if self.progress_bar:
+            self.progress_bar.finish()
+
+    def _progress_callback(self, block_num, block_size, total_length):
+        """Callback to be used when downloading"""
+        if not self.progress_bar:
+            self.progress_bar = _init_progress_bar(
+                total_length, self.destination, self.message)
+            self.progress_bar.start()
+
+        total_read = block_num * block_size
+        self.progress_bar.update(
+            min(total_read, total_length) if total_length > 0 else total_read)
+
+
+def download_urllib_source(uri, destination, message=None):
+    """Perform a download from the given uri to the given destination"""
+    UrllibDownloader(uri, destination, message).download()
+
+
+def is_dumb_terminal():
+    """Return True if on a dumb terminal."""
+    is_stdout_tty = os.isatty(sys.stdout.fileno())
+    is_term_dumb = os.environ.get('TERM', '') == 'dumb'
+    return not is_stdout_tty or is_term_dumb

=== added file 'snappy_ecosystem_tests/helpers/snapcraft/options.py'
--- snappy_ecosystem_tests/helpers/snapcraft/options.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/helpers/snapcraft/options.py	2017-02-20 17:48:06 +0000
@@ -0,0 +1,244 @@
+# -*- 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 snapcraft project options"""
+
+import logging
+import multiprocessing
+import os
+import platform
+
+from snappy_ecosystem_tests.helpers.snapcraft.deprecations import (
+    handle_deprecation_notice
+)
+
+LOGGER = logging.getLogger(__name__)
+
+
+_ARCH_TRANSLATIONS = {
+    'armv7l': {
+        'kernel': 'arm',
+        'deb': 'armhf',
+        'cross-compiler-prefix': 'arm-linux-gnueabihf-',
+        'cross-build-packages': ['gcc-arm-linux-gnueabihf'],
+        'triplet': 'arm-linux-gnueabihf',
+        'core-dynamic-linker': 'lib/ld-linux-armhf.so.3',
+    },
+    'aarch64': {
+        'kernel': 'arm64',
+        'deb': 'arm64',
+        'cross-compiler-prefix': 'aarch64-linux-gnu-',
+        'cross-build-packages': ['gcc-aarch64-linux-gnu'],
+        'triplet': 'aarch64-linux-gnu',
+        'core-dynamic-linker': 'lib/ld-linux-aarch64.so.1',
+    },
+    'i686': {
+        'kernel': 'x86',
+        'deb': 'i386',
+        'triplet': 'i386-linux-gnu',
+    },
+    'ppc64le': {
+        'kernel': 'powerpc',
+        'deb': 'ppc64el',
+        'cross-compiler-prefix': 'powerpc64le-linux-gnu-',
+        'cross-build-packages': ['gcc-powerpc64le-linux-gnu'],
+        'triplet': 'powerpc64le-linux-gnu',
+        'core-dynamic-linker': '/lib64/ld64.so.2',
+    },
+    'ppc': {
+        'kernel': 'powerpc',
+        'deb': 'powerpc',
+        'cross-compiler-prefix': 'powerpc-linux-gnu-',
+        'cross-build-packages': ['gcc-powerpc-linux-gnu'],
+        'triplet': 'powerpc-linux-gnu',
+    },
+    'x86_64': {
+        'kernel': 'x86',
+        'deb': 'amd64',
+        'triplet': 'x86_64-linux-gnu',
+        'core-dynamic-linker': 'lib64/ld-linux-x86-64.so.2',
+    },
+    's390x': {
+        'kernel': 's390x',
+        'deb': 's390x',
+        'cross-compiler-prefix': 's390x-linux-gnu-',
+        'cross-build-packages': ['gcc-s390x-linux-gnu'],
+        'triplet': 's390x-linux-gnu',
+        'core-dynamic-linker': '/lib/ld64.so.1',
+    }
+}
+
+
+_32BIT_USERSPACE_ARCHITECTURE = {
+    'aarch64': 'armv7l',
+    'armv8l': 'armv7l',
+    'ppc64le': 'ppc',
+    'x86_64': 'i686',
+}
+
+
+def _get_platform_architecture():
+    """Return the current platform architecture of the machine"""
+    architecture = platform.machine()
+    if platform.architecture()[0] == '32bit':
+        userspace = _32BIT_USERSPACE_ARCHITECTURE.get(architecture)
+        if userspace:
+            architecture = userspace
+    return architecture
+
+
+class ProjectOptions:
+    """Represents a snapcraft project options"""
+    def __init__(self, use_geoip=False, parallel_builds=True,
+                 target_deb_arch=None, debug=False):
+        self.__project_dir = os.getcwd()
+        self.__use_geoip = use_geoip
+        self.__parallel_builds = parallel_builds
+        self._set_machine(target_deb_arch)
+        self.__debug = debug
+
+    @property
+    def use_geoip(self):
+        """Return True if the project uses geoip"""
+        return self.__use_geoip
+
+    @property
+    def parallel_builds(self):
+        """Return True if the project uses parallel build"""
+        return self.__parallel_builds
+
+    @property
+    def parallel_build_count(self):
+        """Return the amount of cpus used for parallel builds"""
+        build_count = 1
+        if self.__parallel_builds:
+            try:
+                build_count = multiprocessing.cpu_count()
+            except NotImplementedError:
+                LOGGER.warning(
+                    'Unable to determine CPU count; disabling parallel builds')
+        return build_count
+
+    @property
+    def is_cross_compiling(self):
+        """Return True if the target machine does not match
+         the platform arch of the project"""
+        return self.__target_machine != self.__platform_arch
+
+    @property
+    def cross_compiler_prefix(self):
+        """Return the cross compiler prefix"""
+        try:
+            return self.__machine_info['cross-compiler-prefix']
+        except KeyError:
+            raise EnvironmentError(
+                'Cross compilation not support for target arch {}'.format(
+                    self.__target_machine))
+
+    @property
+    def additional_build_packages(self):
+        """Return the additional build packages from the machine info"""
+        packages = []
+        if self.is_cross_compiling:
+            packages.extend(self.__machine_info.get(
+                'cross-build-packages', []))
+        return packages
+
+    @property
+    def arch_triplet(self):
+        """Return the arch triplet from the machine info"""
+        return self.__machine_info['triplet']
+
+    @property
+    def deb_arch(self):
+        """Return the deb arch from the machine info"""
+        return self.__machine_info['deb']
+
+    @property
+    def kernel_arch(self):
+        """Return the kernel arch from the machine info"""
+        return self.__machine_info['kernel']
+
+    @property
+    def local_plugins_dir(self):
+        """Return the plugin directory"""
+        deprecated_plugins_dir = os.path.join(self.parts_dir, 'plugins')
+        if os.path.exists(deprecated_plugins_dir):
+            handle_deprecation_notice('dn2')
+            return deprecated_plugins_dir
+        return os.path.join(self.__project_dir, 'snap', 'plugins')
+
+    @property
+    def parts_dir(self):
+        """Return the parts directory"""
+        return os.path.join(self.__project_dir, 'parts')
+
+    @property
+    def stage_dir(self):
+        """Return the stage directory"""
+        return os.path.join(self.__project_dir, 'stage')
+
+    @property
+    def snap_dir(self):
+        """Return the snap directory"""
+        return os.path.join(self.__project_dir, 'prime')
+
+    @property
+    def debug(self):
+        """Return debug of the project options"""
+        return self.__debug
+
+    def get_core_dynamic_linker(self):
+        """Returns the dynamic linker used for the targetted core.
+        If not found realpath for `/lib/ld-linux.so.2` is returned.
+        However if core is not installed None will be returned.
+        """
+        core_path = os.path.join('/snap', 'core', 'current')
+        core_dynamic_linker = self.__machine_info.get('core-dynamic-linker',
+                                                      'lib/ld-linux.so.2')
+
+        try:
+            dynamic_linker_resolved_path = os.readlink(
+                os.path.join(core_path, core_dynamic_linker))
+            dynamic_linker_path = os.path.join(
+                core_path, dynamic_linker_resolved_path.lstrip('/'))
+        except FileNotFoundError:
+            dynamic_linker_path = None
+
+        return dynamic_linker_path
+
+    def _set_machine(self, target_deb_arch):
+        """Set the target machine with the given deb arch"""
+        self.__platform_arch = _get_platform_architecture()
+        if not target_deb_arch:
+            self.__target_machine = self.__platform_arch
+        else:
+            self.__target_machine = _find_machine(target_deb_arch)
+            LOGGER.info('Setting target machine to {%s}', target_deb_arch)
+        self.__machine_info = _ARCH_TRANSLATIONS[self.__target_machine]
+
+
+def _find_machine(deb_arch):
+    """Return a machine for the given deb arch"""
+    for machine in _ARCH_TRANSLATIONS:
+        if _ARCH_TRANSLATIONS[machine].get('deb', '') == deb_arch:
+            return machine
+    raise EnvironmentError(
+        'Cannot set machine from deb_arch {!r}'.format(deb_arch))

=== renamed directory 'snappy_ecosystem_tests/snapd' => 'snappy_ecosystem_tests/helpers/snapd'
=== added directory 'snappy_ecosystem_tests/helpers/store_apis'
=== added file 'snappy_ecosystem_tests/helpers/store_apis/__init__.py'
--- snappy_ecosystem_tests/helpers/store_apis/__init__.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/helpers/store_apis/__init__.py	2017-02-20 17:48:06 +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/helpers/store_apis/errors.py'
--- snappy_ecosystem_tests/helpers/store_apis/errors.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/helpers/store_apis/errors.py	2017-02-20 17:48:06 +0000
@@ -0,0 +1,371 @@
+# -*- Mode:Python; indent-tabs-mode:nil; tab-width:4 -*-
+#
+# Copyright (C) 2017 Canonical Ltd
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# 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/>.
+
+"""All the store exceptions"""
+
+from simplejson.scanner import JSONDecodeError
+
+
+class StoreException(Exception):
+    """Base class for all store exceptions.
+    :cvar fmt: A format string that daughter classes override
+    """
+    fmt = 'Daughter classes should redefine this'
+
+    def __init__(self, **kwargs):
+        super().__init__()
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def __str__(self):
+        return self.fmt.format([], **self.__dict__)
+
+
+class InvalidCredentialsError(StoreException):
+    """Exception to be raised when credentials are invalid"""
+    fmt = 'Invalid credentials: {message}.'
+
+    def __init__(self, message):
+        super().__init__(message=message)
+
+
+class SnapNotFoundError(StoreException):
+    """Exception to be raised when a snap is not found in the store"""
+    __FMT_ARCH_CHANNEL = (
+        'Snap {name!r} for {arch!r} cannot be found in the {channel!r} '
+        'channel.')
+    __FMT_CHANNEL = 'Snap {name!r} was not found in the {channel!r} channel.'
+    __FMT_SERIES_ARCH = (
+        'Snap {name!r} for {arch!r} was not found in {series!r} series.')
+    __FMT_SERIES = 'Snap {name!r} was not found in {series!r} series.'
+
+    fmt = 'Snap {name!r} was not found.'
+
+    def __init__(self, name, channel=None, arch=None, series=None):
+        if channel and arch:
+            self.fmt = self.__FMT_ARCH_CHANNEL
+        elif channel:
+            self.fmt = self.__FMT_CHANNEL
+        elif series and arch:
+            self.fmt = self.__FMT_SERIES_ARCH
+        elif series:
+            self.fmt = self.__FMT_SERIES
+
+        super().__init__(name=name, channel=channel, arch=arch, series=series)
+
+
+class SHAMismatchError(StoreException):
+    """Exception to be raised when there is a mismatch in sha512"""
+    fmt = 'SHA512 checksum for {path} is not {expected_sha}.'
+
+    def __init__(self, path, expected_sha):
+        super().__init__(path=path, expected_sha=expected_sha)
+
+
+class StoreAuthenticationError(StoreException):
+    """Exception to be raised when there is an authentication error in the
+     store"""
+    fmt = 'Authentication error: {}.'
+
+    def __init__(self, message):
+        super().__init__(message=message)
+
+
+class StoreTwoFactorAuthenticationRequired(StoreAuthenticationError):
+    """Exception to be raised when the credentials were provided but 2-factor
+    authentication was not and is required.
+    """
+    def __init__(self):
+        super().__init__("Two-factor authentication required.")
+
+
+class StoreMacaroonNeedsRefreshError(StoreException):
+    """Exception to be raised when a request needs to refresh
+     the macaroon to be authenticated properly"""
+    fmt = 'Authentication macaroon needs to be refreshed.'
+
+
+class DeveloperAgreementSignError(StoreException):
+    """Exception to be raised when developer tries to do an operation
+     in the store but he did not sign the Agreement yet"""
+    fmt = (
+        'There was an error while signing developer agreement.\n'
+        'Reason: {reason!r}\n'
+        'Text: {text!r}')
+
+    def __init__(self, response):
+        super().__init__(reason=response.reason, text=response.text)
+
+
+class NeedTermsSignedError(StoreException):
+    """Exception to be raised when an operation needs the Developer
+     Terms of Service to be signed before proceed"""
+    fmt = (
+        'Developer Terms of Service agreement must be signed '
+        'before continuing: {message}')
+
+    def __init__(self, message):
+        super().__init__(message=message)
+
+
+class StoreAccountInformationError(StoreException):
+    """Exception to be raised when there was not possible
+     to fetch the user account information"""
+    fmt = 'Error fetching account information from store: {error}'
+
+    def __init__(self, response):
+        error = '{} {}'.format(response.status_code, response.reason)
+        extra = []
+        try:
+            response_json = response.json()
+            if 'error_list' in response_json:
+                error = ' '.join(
+                    error['message'] for error in response_json['error_list'])
+                extra = [
+                    error['extra'] for error in response_json[
+                        'error_list'] if 'extra' in error]
+        except JSONDecodeError:
+            pass
+        super().__init__(error=error, extra=extra)
+
+
+class StoreKeyRegistrationError(StoreException):
+    """Exception to be raised when there was a problem
+     registering a key in the store"""
+    fmt = 'Key registration failed: {error}'
+
+    def __init__(self, response):
+        error = '{} {}'.format(response.status_code, response.reason)
+        try:
+            response_json = response.json()
+            if 'error_list' in response_json:
+                error = ' '.join(
+                    error['message'] for error in response_json['error_list'])
+        except JSONDecodeError:
+            pass
+        super().__init__(error=error)
+
+
+class StoreRegistrationError(StoreException):
+    """Exception to be raised when there was a problem registering
+    a snap name"""
+    __FMT_ALREADY_REGISTERED = (
+        'The name {snap_name!r} is already taken.\n\n'
+        'We can if needed rename snaps to ensure they match the expectations '
+        'of most users. If you are the publisher most users expect for '
+        '{snap_name!r} then claim the name at {register_name_url!r}')
+
+    __FMT_ALREADY_OWNED = 'You already own the name {snap_name!r}.'
+
+    __FMT_RESERVED = (
+        'The name {snap_name!r} is reserved.\n\n'
+        'If you are the publisher most users expect for '
+        '{snap_name!r} then please claim the name at {register_name_url!r}')
+
+    __FMT_RETRY_WAIT = (
+        'You must wait {retry_after} seconds before trying to register '
+        'your next snap.')
+
+    fmt = 'Registration failed.'
+
+    __error_messages = {
+        'already_registered': __FMT_ALREADY_REGISTERED,
+        'already_owned': __FMT_ALREADY_OWNED,
+        'reserved_name': __FMT_RESERVED,
+        'register_window': __FMT_RETRY_WAIT,
+    }
+
+    def __init__(self, snap_name, response):
+        try:
+            response_json = response.json()
+        except JSONDecodeError:
+            response_json = {}
+
+        error_code = response_json.get('code')
+        if error_code:
+            # we default to self.fmt in case error_code is not mapped yet.
+            self.fmt = self.__error_messages.get(error_code, self.fmt)
+
+        super().__init__(snap_name=snap_name, **response_json)
+
+
+class StoreUploadError(StoreException):
+    """Exception to be raised when there was a problem
+     uploading a snap to the store"""
+    fmt = (
+        'There was an error uploading the package.\n'
+        'Reason: {reason!r}\n'
+        'Text: {text!r}')
+
+    def __init__(self, response):
+        super().__init__(reason=response.reason, text=response.text)
+
+
+class StorePushError(StoreException):
+    """Exception to be raised when there was a problem
+     pushing a snap to the store"""
+    __FMT_NOT_REGISTERED = (
+        'You are not the publisher or allowed to push revisions for this '
+        'snap. To become the publisher, run `snapcraft register {snap_name}` '
+        'and try to push again.')
+
+    fmt = 'Received {status_code!r}: {text!r}'
+
+    def __init__(self, snap_name, response):
+        try:
+            response_json = response.json()
+        except (AttributeError, JSONDecodeError):
+            response_json = {}
+
+        if response.status_code == 404:
+            self.fmt = self.__FMT_NOT_REGISTERED
+        elif response.status_code == 401 or response.status_code == 403:
+            try:
+                response_json['text'] = response.text
+            except AttributeError:
+                response_json['text'] = 'error while pushing'
+
+        super().__init__(snap_name=snap_name, status_code=response.status_code,
+                         **response_json)
+
+
+class StoreReviewError(StoreException):
+    """Exception to be raised when there was a problem in the snap
+     that prevents it to be published/updated"""
+    __FMT_NEED_MANUAL_REVIEW = (
+        'Publishing checks failed.\n'
+        'To release this to stable channel please request a review on '
+        'the snapcraft list.\n'
+        'Use devmode in the edge or beta channels to disable confinement.')
+
+    __FMT_PROCESSING_ERROR = (
+        'There has been a problem while analyzing the snap, check the snap '
+        'and try to push again.')
+
+    __messages = {
+        'need_manual_review': __FMT_NEED_MANUAL_REVIEW,
+        'processing_error': __FMT_PROCESSING_ERROR,
+    }
+
+    def __init__(self, result):
+        self.fmt = self.__messages[result['code']]
+        super().__init__()
+
+
+class StoreReleaseError(StoreException):
+    """Exception to be raised when the snap could not be released"""
+    __FMT_NOT_REGISTERED = (
+        'Sorry, try `snapcraft register {snap_name}` before trying to '
+        'release or choose an existing revision.')
+
+    fmt = 'Received {status_code!r}: {text!r}'
+
+    def __init__(self, snap_name, response):
+        try:
+            response_json = response.json()
+        except (AttributeError, JSONDecodeError):
+            response_json = {}
+
+        if response.status_code == 404:
+            self.fmt = self.__FMT_NOT_REGISTERED
+        elif response.status_code == 401 or response.status_code == 403:
+            try:
+                response_json['text'] = response.text
+            except AttributeError:
+                response_json['text'] = 'error while releasing'
+        elif 'errors' in response_json:
+            self.fmt = '{errors}'
+
+        super().__init__(snap_name=snap_name, status_code=response.status_code,
+                         **response_json)
+
+
+class StoreValidationError(StoreException):
+    """Exception to be raised when there was a validation
+     problem in the store"""
+    fmt = 'Received error {status_code!r}: {text!r}'
+
+    def __init__(self, response, message=None):
+        try:
+            response_json = response.json()
+            response_json['text'] = response.json()['error_list'][0]['message']
+        except (AttributeError, JSONDecodeError):
+            response_json = {'text': message or response}
+
+        super().__init__(status_code=response.status_code,
+                         **response_json)
+
+
+class StoreSnapBuildError(StoreException):
+    """Exception to be raised when a snap build assertion fails"""
+    fmt = 'Could not assert build: {error}'
+
+    def __init__(self, response):
+        error = '{} {}'.format(response.status_code, response.reason)
+        try:
+            response_json = response.json()
+            if 'error_list' in response_json:
+                error = ' '.join(
+                    error['message'] for error in response_json['error_list'])
+        except JSONDecodeError:
+            pass
+
+        super().__init__(error=error)
+
+
+class StoreSnapHistoryError(StoreException):
+    """Exception to be raised when there was a problem fetching a snap
+    history"""
+    fmt = (
+        'Error fetching history of snap id {snap_id!r} for {arch!r} '
+        'in {series!r} series: {error}.')
+
+    def __init__(self, response, snap_id, series, arch):
+        error = '{} {}'.format(response.status_code, response.reason)
+        try:
+            response_json = response.json()
+            if 'error_list' in response_json:
+                error = ' '.join(
+                    error['message'] for error in response_json['error_list'])
+        except JSONDecodeError:
+            pass
+
+        super().__init__(
+            snap_id=snap_id, arch=arch or 'any arch',
+            series=series or 'any', error=error)
+
+
+class StoreSnapStatusError(StoreSnapHistoryError):
+    """Exception to be raised when there was a problem fetching a snap
+    status"""
+    fmt = (
+        'Error fetching status of snap id {snap_id!r} for {arch!r} '
+        'in {series!r} series: {error}.')
+
+
+class StoreChannelClosingError(StoreException):
+    """Exception to be raised when there was a problem fetching a snap
+    history"""
+    fmt = 'Could not close channel: {error}'
+
+    def __init__(self, response):
+        try:
+            _e = response.json()['error_list'][0]
+            error = '{}'.format(_e['message'])
+        except (JSONDecodeError, KeyError, IndexError):
+            error = '{} {}'.format(
+                response.status_code, response.reason)
+        super().__init__(error=error)

=== added file 'snappy_ecosystem_tests/helpers/store_apis/rest_apis.py'
--- snappy_ecosystem_tests/helpers/store_apis/rest_apis.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/helpers/store_apis/rest_apis.py	2017-02-20 17:48:06 +0000
@@ -0,0 +1,880 @@
+# -*- Mode:Python; indent-tabs-mode:nil; tab-width:4 -*-
+#
+# Copyright (C) 2017 Canonical Ltd
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# 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/>.
+
+"""Clients needed to interact with the Snap Store"""
+
+import contextlib
+import hashlib
+import itertools
+import json
+import logging
+import os
+import urllib.parse
+from queue import Queue
+from threading import Thread
+from time import sleep
+
+import pymacaroons
+import requests
+from progressbar import (
+    AnimatedMarker,
+    ProgressBar,
+    UnknownLength,
+)
+from simplejson.scanner import JSONDecodeError
+from snappy_ecosystem_tests.commons.config import CONFIG_STACK
+
+from snappy_ecosystem_tests.helpers.snapcraft import constants
+from snappy_ecosystem_tests.helpers.snapcraft.config import SnapcraftConfig
+from snappy_ecosystem_tests.helpers.snapcraft.indicators import (
+    download_requests_stream
+)
+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
+
+LOGGER = logging.getLogger(__name__)
+
+JSON_CONTENT_TYPE = {'Content-Type': 'application/json'}
+JSON_ACCEPT = {'Accept': 'application/json'}
+JSON_HEADERS = dict(JSON_CONTENT_TYPE, **JSON_ACCEPT)
+
+
+def _macaroon_auth(conf):
+    """Format a macaroon and its associated discharge.
+    :return: A string suitable to use in an Authorization header.
+    """
+    root_macaroon_raw = conf.get('macaroon')
+    if root_macaroon_raw is None:
+        raise errors.InvalidCredentialsError(
+            'Root macaroon not in the config file')
+    unbound_raw = conf.get('unbound_discharge')
+    if unbound_raw is None:
+        raise errors.InvalidCredentialsError(
+            'Unbound discharge not in the config file')
+
+    root_macaroon = _deserialize_macaroon(root_macaroon_raw)
+    unbound = _deserialize_macaroon(unbound_raw)
+    bound = root_macaroon.prepare_for_request(unbound)
+    discharge_macaroon_raw = bound.serialize()
+    auth = 'Macaroon root={}, discharge={}'.format(
+        root_macaroon_raw, discharge_macaroon_raw)
+    return auth
+
+
+def _deserialize_macaroon(value):
+    """Deserialize the given macaroon and return it
+    :raise InvalidCredentialsError: when macaroon cannot be deserialized
+    """
+    try:
+        return pymacaroons.Macaroon.deserialize(value)
+    except:
+        raise errors.InvalidCredentialsError('Failed to deserialize macaroon')
+
+
+class Client:
+    """A base class to define clients for the ols servers.
+    This is a simple wrapper around requests.Session so we inherit all good
+    bits while providing a simple point for tests to override when needed.
+    """
+
+    def __init__(self, conf, root_url):
+        self.conf = conf
+        self.root_url = root_url
+        self.session = requests.Session()
+
+    def request(self, method, url, params=None, headers=None, **kwargs):
+        """Overriding base class to handle the root url."""
+        # Note that url may be absolute in which case 'root_url' is ignored by
+        # urljoin.
+        if headers is None:
+            headers = JSON_HEADERS
+        final_url = urllib.parse.urljoin(self.root_url, url)
+        response = self.session.request(
+            method, final_url, headers=headers,
+            params=params, **kwargs)
+        return response
+
+    def get(self, url, **kwargs):
+        """Do a GET request and return the response"""
+        return self.request('GET', url, **kwargs)
+
+    def post(self, url, **kwargs):
+        """Do a POST request and return the response"""
+        return self.request('POST', url, **kwargs)
+
+    def put(self, url, **kwargs):
+        """Do a PUT request and return the response"""
+        return self.request('PUT', url, **kwargs)
+
+
+class Store:
+    """It is an entry point for all the REST operations in the store.
+    It will call the corresponding client to resolve the request.
+    It also takes care about refreshing the macaroon if necessary
+    in each request.
+    """
+
+    ACLs = ('package_upload', 'package_access')
+
+    def __init__(self):
+        self.conf = SnapcraftConfig()
+        self.sso = SSOClient(self.conf)
+        self.cpi = SnapIndexClient(self.conf)
+        self.updown = UpDownClient(self.conf)
+        self.sca = SCAClient(self.conf)
+
+    def login(self, email, password, one_time_password=None, acls=ACLs,
+              packages=None, channels=None, save=True):
+        """Log in via the Ubuntu One SSO API."""
+        # Ask the store for the needed capabilities to be associated with the
+        # macaroon.
+        macaroon = self.sca.get_macaroon(acls, packages, channels)
+        caveat_id = self._extract_caveat_id(macaroon)
+        unbound_discharge = self.sso.get_unbound_discharge(
+            email, password, one_time_password, caveat_id)
+        # The macaroon has been discharged, save it in the config
+        self.conf.set('macaroon', macaroon)
+        self.conf.set('unbound_discharge', unbound_discharge)
+        if save:
+            self.conf.save()
+
+    @property
+    def config(self):
+        """Get current config"""
+        return self.conf
+
+    def load_config(self):
+        """Load current config"""
+        self.conf.load()
+
+    def _extract_caveat_id(self, root_macaroon):
+        """Extract caveat id for the given macaroon
+        :raise InvalidCredentialsError: when given macaroon is not valid
+        """
+        macaroon = pymacaroons.Macaroon.deserialize(root_macaroon)
+        # macaroons are all bytes, never strings
+        sso_host = urllib.parse.urlparse(self.sso.root_url).netloc
+        for caveat in macaroon.caveats:
+            if caveat.location == sso_host:
+                return caveat.caveat_id
+        raise errors.InvalidCredentialsError('Invalid root macaroon')
+
+    def logout(self):
+        """Logout from Store client"""
+        self.conf.clear()
+        self.conf.save()
+
+    def _refresh_if_necessary(self, func, *args, **kwargs):
+        """Make a request, refreshing macaroons if necessary."""
+        try:
+            return func(*args, **kwargs)
+        except errors.StoreMacaroonNeedsRefreshError:
+            unbound_discharge = self.sso.refresh_unbound_discharge(
+                self.conf.get('unbound_discharge'))
+            self.conf.set('unbound_discharge', unbound_discharge)
+            self.conf.save()
+            return func(*args, **kwargs)
+
+    def get_account_information(self):
+        """Get current account information"""
+        return self._refresh_if_necessary(self.sca.get_account_information)
+
+    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):
+        """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)
+
+    def push_precheck(self, snap_name):
+        """Do a snap push as a pre-check (dry_run: do not actually push)
+        First refresh macaroon if necessary
+        """
+        return self._refresh_if_necessary(
+            self.sca.snap_push_precheck, snap_name)
+
+    def push_snap_build(self, snap_id, snap_build):
+        """Do a snap push
+        First refresh macaroon if necessary
+        """
+        return self._refresh_if_necessary(
+            self.sca.push_snap_build, snap_id, snap_build)
+
+    def upload(self, snap_name, snap_filename):
+        """Upload a snap file.
+        :raise InvalidCredentialsError  when no unbound_discharge
+         is found in current config
+        """
+        if not self.conf.get('unbound_discharge'):
+            raise errors.InvalidCredentialsError(
+                'Unbound discharge not in the config file')
+
+        updown_data = upload_files(snap_filename, self.updown)
+
+        return self._refresh_if_necessary(
+            self.sca.snap_push_metadata, snap_name, updown_data)
+
+    def release(self, snap_name, revision, channels):
+        """Release a snap revision to the given channels
+        First refresh macaroon if necessary
+        """
+        return self._refresh_if_necessary(
+            self.sca.snap_release, snap_name, revision, channels)
+
+    def get_snap_history(self, snap_name, series=None, arch=None):
+        """Get a snap history. First refresh macaroon if necessary
+        :raise: SnapNotFoundError if the snap does not belong to
+        the current user
+        or if it is not found.
+        """
+        if series is None:
+            series = constants.DEFAULT_SERIES
+
+        account_info = self.get_account_information()
+        try:
+            snap_id = account_info['snaps'][series][snap_name]['snap-id']
+        except KeyError:
+            raise errors.SnapNotFoundError(snap_name, series=series, arch=arch)
+
+        response = self._refresh_if_necessary(
+            self.sca.snap_history, snap_id, series, arch)
+
+        if not response:
+            raise errors.SnapNotFoundError(snap_name, series=series, arch=arch)
+
+        return response
+
+    def get_snap_status(self, snap_name, series=None, arch=None):
+        """Get a snap status. First refresh macaroon if necessary
+        :raise: SnapNotFoundError if the snap does not belong
+        to the current user
+        or if it is not found.
+        """
+        if series is None:
+            series = constants.DEFAULT_SERIES
+
+        account_info = self.get_account_information()
+        try:
+            snap_id = account_info['snaps'][series][snap_name]['snap-id']
+        except KeyError:
+            raise errors.SnapNotFoundError(snap_name, series=series, arch=arch)
+
+        response = self._refresh_if_necessary(
+            self.sca.snap_status, snap_id, series, arch)
+
+        if not response:
+            raise errors.SnapNotFoundError(snap_name, series=series, arch=arch)
+
+        return response
+
+    def close_channels(self, snap_id, channel_names):
+        """Close channels for the given snap_id.
+        First refresh macaroon if necessary"""
+        return self._refresh_if_necessary(
+            self.sca.close_channels, snap_id, channel_names)
+
+    def download(self, snap_name, channel, download_path, arch=None):
+        """Download a snap and store it locally
+        :param snap_name: the snap name
+        :param channel: the channel name
+        :param download_path: the local path to download the snap
+        :param arch: the snap architecture
+        """
+        if arch is None:
+            arch = ProjectOptions().deb_arch
+
+        package = self.cpi.get_package(snap_name, channel, arch)
+        self._download_snap(
+            snap_name, download_path,
+            package['anon_download_url'], package['download_sha512'])
+
+    def _download_snap(self, name, download_path, download_url,
+                       expected_sha512):
+        """Download a snap and store it locally
+        :param name: the snap name
+        :param download_path: the local path to download the snap
+        :param download_url: the url to download the snap
+        :param expected_sha512: the snap expected sha256
+        """
+        if self._is_downloaded(download_path, expected_sha512):
+            LOGGER.info('Already downloaded %s at %s', name, download_path)
+            return
+        LOGGER.info('Downloading %s at %s', name, download_path)
+        request = self.cpi.get(download_url, stream=True)
+        request.raise_for_status()
+        download_requests_stream(request, download_path)
+
+        if self._is_downloaded(download_path, expected_sha512):
+            LOGGER.info('Successfully downloaded %s at %s', name,
+                        download_path)
+        else:
+            raise errors.SHAMismatchError(download_path, expected_sha512)
+
+    @staticmethod
+    def _is_downloaded(path, expected_sha512):
+        """Return True if the snap is already downloaded in the local machine
+        :param path: the path to look for the snap
+        :param expected_sha512: the expected snap sha512
+        """
+        if not os.path.exists(path):
+            return False
+
+        file_sum = hashlib.sha512()
+        with open(path, 'rb') as _f:
+            for file_chunk in iter(
+                    lambda: _f.read(file_sum.block_size * 128), b''):
+                file_sum.update(file_chunk)
+        return expected_sha512 == file_sum.hexdigest()
+
+    def push_validation(self, snap_id, assertion):
+        """Push a snap validation/assertion to the store
+        :param snap_id: the snap id
+        :param assertion: the snap assertion
+        """
+        return self.sca.push_validation(snap_id, assertion)
+
+    def get_validations(self, snap_id):
+        """Get current snap validations/assertions"""
+        return self.sca.get_validations(snap_id)
+
+    def sign_developer_agreement(self, latest_tos_accepted=False):
+        """Sign developer agreement to be able to do operations in the store"""
+        return self.sca.sign_developer_agreement(latest_tos_accepted)
+
+
+class SSOClient(Client):
+    """The Single Sign On server deals with authentication.
+    It is used directly or indirectly by other servers.
+    """
+    def __init__(self, conf):
+        super().__init__(conf, os.environ.get(
+            'UBUNTU_SSO_API_ROOT_URL',
+            CONFIG_STACK.config.get('production_urls', 'sso')))
+
+    def get_unbound_discharge(self, email, password, one_time_password,
+                              caveat_id):
+        """Get the unbound discharge for the caveat_id.
+        :param email: user email
+        :param password: user password
+        :param one_time_password: the one time password
+        :param caveat_id: the caveat id to get the unbound discharge
+        :raise StoreTwoFactorAuthenticationRequired:
+        if response is unauthorized and two-factor is required
+        :raise StoreAuthenticationError: if failed to get unbound discharge
+        """
+        data = dict(email=email, password=password,
+                    caveat_id=caveat_id)
+        if one_time_password:
+            data['otp'] = one_time_password
+        response = self.post(
+            'tokens/discharge', data=json.dumps(data),
+            headers=JSON_HEADERS)
+        try:
+            response_json = response.json()
+        except JSONDecodeError:
+            response_json = {}
+        if response.ok:
+            return response_json['discharge_macaroon']
+        else:
+            if (response.status_code == requests.codes.get('unauthorized') and
+                    any(error.get('code') == 'twofactor-required'
+                        for error in response_json.get('error_list', []))):
+                raise errors.StoreTwoFactorAuthenticationRequired()
+            else:
+                raise errors.StoreAuthenticationError(
+                    'Failed to get unbound discharge: {}'.format(
+                        response.text))
+
+    def refresh_unbound_discharge(self, unbound_discharge):
+        """Refresh the given unbound discharge.
+        :raise StoreAuthenticationError: if fails to refresh the
+        unbound discharge.
+        """
+        data = {'discharge_macaroon': unbound_discharge}
+        response = self.post(
+            'tokens/refresh', data=json.dumps(data),
+            headers=JSON_HEADERS)
+        if response.ok:
+            return response.json()['discharge_macaroon']
+        else:
+            raise errors.StoreAuthenticationError(
+                'Failed to refresh unbound discharge: {}'.format(
+                    response.text))
+
+
+class SnapIndexClient(Client):
+    """The Click Package Index knows everything about existing snaps.
+    https://wiki.ubuntu.com/AppStore/Interfaces/ClickPackageIndex is the
+    canonical reference.
+    """
+    def __init__(self, conf):
+        super().__init__(conf, os.environ.get(
+            'UBUNTU_STORE_SEARCH_ROOT_URL',
+            CONFIG_STACK.config.get('production_urls', 'search')))
+
+    def get_default_headers(self):
+        """Return default headers for CPI requests.
+        Tries to build an 'Authorization' header with local credentials
+        if they are available.
+        Also pin specific branded store if `SNAPCRAFT_UBUNTU_STORE`
+        environment is set.
+        """
+        headers = {}
+
+        with contextlib.suppress(errors.InvalidCredentialsError):
+            headers['Authorization'] = _macaroon_auth(self.conf)
+
+        branded_store = os.getenv('SNAPCRAFT_UBUNTU_STORE')
+        if branded_store:
+            headers['X-Ubuntu-Store'] = branded_store
+
+        return headers
+
+    def get_package(self, snap_name, channel, arch=None):
+        """Get snap details.
+        :param snap_name: the snap name
+        :param channel: the snap channel
+        :param arch: the snap architecture
+        """
+        headers = self.get_default_headers()
+        headers.update({
+            'Accept': 'application/hal+json',
+            'X-Ubuntu-Release': constants.DEFAULT_SERIES,
+        })
+        if arch:
+            headers['X-Ubuntu-Architecture'] = arch
+
+        params = {
+            'channel': channel,
+            'fields': 'status,anon_download_url,download_url,'
+                      'download_sha512,snap_id,release',
+        }
+        LOGGER.info('Getting details for %s', snap_name)
+        url = 'api/v1/snaps/details/{}'.format(snap_name)
+        resp = super().get(url, headers=headers, params=params)
+        if resp.status_code != 200:
+            raise errors.SnapNotFoundError(snap_name, channel, arch)
+        return resp.json()
+
+
+class UpDownClient(Client):
+    """The Up/Down server provide upload/download snap capabilities."""
+
+    def __init__(self, conf):
+        super().__init__(conf, os.environ.get(
+            'UBUNTU_STORE_UPLOAD_ROOT_URL',
+            CONFIG_STACK.config.get('production_urls', 'upload')))
+
+    def upload(self, monitor):
+        """Upload a snap capability"""
+        return self.post(
+            urllib.parse.urljoin(self.root_url, 'unscanned-upload/'),
+            data=monitor,
+            headers=dict({'Content-Type': monitor.content_type},
+                         **JSON_ACCEPT))
+
+
+class SCAClient(Client):
+    """The software center agent deals with managing snaps."""
+
+    def __init__(self, conf):
+        super().__init__(conf, os.environ.get(
+            'UBUNTU_STORE_API_ROOT_URL',
+            CONFIG_STACK.config.get('production_urls', 'root_api')))
+
+    def get_macaroon(self, acls, packages=None, channels=None):
+        """Get a macaroon that is used to authenticate
+        request against the store
+        :param acls: list of permissions to request the macaroon for.
+        :param packages: list of packages to request the macaroon for.
+        :param channels: list of channels to request the macaroon for.
+        """
+        data = {'permissions': acls}
+        if packages is not None:
+            data.update({'packages': packages})
+        if channels is not None:
+            data.update({'channels': channels})
+        headers = JSON_ACCEPT
+        response = self.post(
+            'acl/', json=data, headers=headers)
+        if response.ok:
+            return response.json()['macaroon']
+        else:
+            raise errors.StoreAuthenticationError('Failed to get macaroon')
+
+    @staticmethod
+    def _needs_refreshed_response(response):
+        """Return True if the given response needs to refresh the macaroon.
+        :param response: the response to check if the
+        macaroon refresh is needed.
+        """
+        return (
+            response.status_code == requests.codes.get('unauthorized') and
+            response.headers.get('WWW-Authenticate') == (
+                'Macaroon needs_refresh=1'))
+
+    def request(self, *args, **kwargs):
+        """Wrapper of client request that raises an exception for
+         the cases that the response macaroon needs to be refreshed
+         :raise StoreMacaroonNeedsRefreshError:
+         if the response needs the macaroon to be refreshed.
+         """
+        response = super().request(*args, **kwargs)
+        if self._needs_refreshed_response(response):
+            raise errors.StoreMacaroonNeedsRefreshError()
+        return response
+
+    def get_account_information(self):
+        """Get the current account information
+        :raise StoreAccountInformationError: if response is not ok status
+        """
+        auth = _macaroon_auth(self.conf)
+        response = self.get(
+            'account',
+            headers=dict({'Authorization': auth}, **JSON_ACCEPT))
+        if response.ok:
+            return response.json()
+        else:
+            raise errors.StoreAccountInformationError(response)
+
+    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
+        :raise StoreKeyRegistrationError
+        """
+        data = {'account_key_request': account_key_request}
+        auth = _macaroon_auth(self.conf)
+        response = self.post(
+            'account/account-key', data=json.dumps(data),
+            headers=dict({'Authorization': auth}, **JSON_HEADERS))
+        if not response.ok:
+            raise errors.StoreKeyRegistrationError(response)
+
+    def register(self, snap_name, is_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 series: the snap's series to be registered
+        """
+        auth = _macaroon_auth(self.conf)
+        data = dict(snap_name=snap_name, is_private=is_private,
+                    series=series)
+        response = self.post(
+            'register-name/', data=json.dumps(data),
+            headers=dict({'Authorization': auth}, **JSON_ACCEPT))
+        if not response.ok:
+            raise errors.StoreRegistrationError(snap_name, response)
+
+    def snap_push_precheck(self, snap_name):
+        """Do a snap push pre-check (dry_run: do not actually push)
+        :raise StorePushError
+        """
+        data = {
+            'name': snap_name,
+            'dry_run': True,
+        }
+        auth = _macaroon_auth(self.conf)
+        response = self.post(
+            'snap-push/', data=json.dumps(data),
+            headers=dict({'Authorization': auth}, **JSON_HEADERS))
+        if not response.ok:
+            raise errors.StorePushError(data['name'], response)
+
+    def snap_push_metadata(self, snap_name, updown_data):
+        """Push metadata fot the given snap
+        :param snap_name: the snap name which metadata want to be updated
+        :param updown_data: a dictionary that contains the metadata: upload_id,
+        binary_filesize, source_uploaded
+        :raise: StorePushError
+        """
+        data = {
+            'name': snap_name,
+            'series': constants.DEFAULT_SERIES,
+            'updown_id': updown_data['upload_id'],
+            'binary_filesize': updown_data['binary_filesize'],
+            'source_uploaded': updown_data['source_uploaded'],
+        }
+        auth = _macaroon_auth(self.conf)
+        response = self.post(
+            'snap-push/', data=json.dumps(data),
+            headers=dict({'Authorization': auth}, **JSON_HEADERS))
+        if not response.ok:
+            raise errors.StorePushError(data['name'], response)
+
+        return StatusTracker(response.json()['status_details_url'])
+
+    def snap_release(self, snap_name, revision, channels):
+        """
+        Release a snap revision to the given channel
+        :param snap_name: the snap name to be released
+        :param revision: the revision number to be released
+        :param channels: the channels in which release the snap
+        :raise: StoreReleaseError
+        """
+        data = {
+            'name': snap_name,
+            'revision': str(revision),
+            'channels': channels,
+        }
+        auth = _macaroon_auth(self.conf)
+        response = self.post(
+            'snap-release/', data=json.dumps(data),
+            headers=dict({'Authorization': auth}, **JSON_HEADERS))
+        if not response.ok:
+            raise errors.StoreReleaseError(data['name'], response)
+
+        response_json = response.json()
+
+        return response_json
+
+    def push_validation(self, snap_id, assertion):
+        """
+        Push a validation/assertion to the store
+        :param snap_id: the snap_id of the snap
+        :param assertion: the validation/assertion to be pushed
+        :raise: JSONDecodeError, StoreValidationError
+        """
+        data = {
+            'assertion': assertion.decode('utf-8'),
+        }
+        auth = _macaroon_auth(self.conf)
+        response = self.put(
+            'snaps/{}/validations'.format(snap_id), data=json.dumps(data),
+            headers=dict({'Authorization': auth}, **JSON_HEADERS))
+        if not response.ok:
+            raise errors.StoreValidationError(snap_id, response)
+        try:
+            response_json = response.json()
+        except JSONDecodeError:
+            message = ('Invalid response from the server when pushing '
+                       'validations: {} {}').format(
+                           response.status_code, response)
+            LOGGER.debug(message)
+            raise errors.StoreValidationError(
+                response, message='Invalid response from the server')
+
+        return response_json
+
+    def get_validations(self, snap_id):
+        """Get validations/assertion of a given snap
+        :param snap_id: the id of the snap to get the validations for.
+        :raise: JSONDecodeError, StoreValidationError
+        """
+        auth = _macaroon_auth(self.conf)
+        response = self.get(
+            'snaps/{}/validations'.format(snap_id),
+            headers=dict({'Authorization': auth}, **JSON_HEADERS))
+        if not response.ok:
+            raise errors.StoreValidationError(snap_id, response)
+        try:
+            response_json = response.json()
+        except JSONDecodeError:
+            message = ('Invalid response from the server when getting '
+                       'validations: {} {}').format(
+                           response.status_code, response)
+            LOGGER.debug(message)
+            raise errors.StoreValidationError(
+                response, message='Invalid response from the server')
+
+        return response_json
+
+    def push_snap_build(self, snap_id, snap_build):
+        """
+        Push a snap build to the store
+        :param snap_id: the snap id
+        :param snap_build: the snap build to push
+        :raise: StoreSnapBuildError
+        """
+        url = 'snaps/{}/builds'.format(snap_id)
+        data = json.dumps({"assertion": snap_build})
+
+        headers = dict({'Authorization': _macaroon_auth(self.conf)},
+                       **JSON_CONTENT_TYPE)
+        response = self.post(url, data=data, headers=headers)
+        if not response.ok:
+            raise errors.StoreSnapBuildError(response)
+
+    def snap_history(self, snap_id, series=None, arch=None):
+        """
+        Get a snap history
+        :param snap_id: the id of the snap to get the history for.
+        :param series: the series of the snap
+        :param arch: the architecture of the snap
+        :raise: StoreSnapHistoryError
+        """
+        qs = {}
+        if series:
+            qs['series'] = series
+        if arch:
+            qs['arch'] = arch
+        url = 'snaps/' + snap_id + '/history'
+        if qs:
+            url += '?' + urllib.parse.urlencode(qs)
+        auth = _macaroon_auth(self.conf)
+        response = self.get(
+            url,
+            headers=dict({'Authorization': auth}, **JSON_HEADERS))
+        if not response.ok:
+            raise errors.StoreSnapHistoryError(response, snap_id, series, arch)
+
+        response_json = response.json()
+
+        return response_json
+
+    def snap_status(self, snap_id, series=None, arch=None):
+        """
+        Get a snap status
+        :param snap_id: the id of the snap to get the history for.
+        :param series: the series of the snap
+        :param arch: the architecture of the snap
+        :raise: StoreSnapStatusError
+        """
+        qs = {}
+        if series:
+            qs['series'] = series
+        if arch:
+            qs['arch'] = arch
+        url = 'snaps/' + snap_id + '/status'
+        if qs:
+            url += '?' + urllib.parse.urlencode(qs)
+        auth = _macaroon_auth(self.conf)
+        response = self.get(
+            url,
+            headers=dict({'Authorization': auth}, **JSON_HEADERS))
+        if not response.ok:
+            raise errors.StoreSnapStatusError(response, snap_id, series, arch)
+
+        response_json = response.json()
+
+        return response_json
+
+    def close_channels(self, snap_id, channel_names):
+        """
+        Close channel for a given snap
+        :param snap_id: the id of the snap
+        :param channel_names: the channels to be closed
+        :raise: StoreChannelClosingError
+        """
+        url = 'snaps/{}/close'.format(snap_id)
+        data = {
+            'channels': channel_names
+        }
+        headers = {
+            'Authorization': _macaroon_auth(self.conf),
+        }
+        response = self.post(url, json=data, headers=headers)
+        if not response.ok:
+            raise errors.StoreChannelClosingError(response)
+
+        try:
+            results = response.json()
+            return results['closed_channels'], results['channel_maps']
+        except (JSONDecodeError, KeyError):
+            LOGGER.debug(
+                'Invalid response from the server on channel closing:\n'
+                '%s %s\n%s', response.status_code, response.reason,
+                response.content)
+            raise errors.StoreChannelClosingError(response)
+
+    def sign_developer_agreement(self, latest_tos_accepted=False):
+        """Sign developer agreement to be able to do operations in the store"""
+        auth = _macaroon_auth(self.conf)
+        data = {'latest_tos_accepted': latest_tos_accepted}
+        response = self.post(
+            'agreement/', data=json.dumps(data),
+            headers=dict({'Authorization': auth}, **JSON_HEADERS))
+        if not response.ok:
+            raise errors.DeveloperAgreementSignError(response)
+        return response.json()
+
+
+class StatusTracker:
+
+    """Class to track the status of an operation"""
+
+    __messages = {
+        'being_processed': 'Processing...',
+        'ready_to_release': 'Ready to release!',
+        'need_manual_review': 'Will need manual review...',
+        'processing_error': 'Error while processing...',
+    }
+
+    __error_codes = (
+        'processing_error',
+        'need_manual_review',
+    )
+
+    def __init__(self, status_details_url):
+        self.__content = None
+        self.__status_details_url = status_details_url
+
+    def track(self):
+        """Track the status"""
+        queue = Queue()
+        thread = Thread(target=self._update_status, args=(queue,))
+        thread.start()
+        widgets = ['Processing...', AnimatedMarker()]
+        progress_indicator = ProgressBar(widgets=widgets, maxval=UnknownLength)
+        progress_indicator.start()
+        content = {}
+        for indicator_count in itertools.count():
+            if not queue.empty():
+                content = queue.get()
+                if isinstance(content, Exception):
+                    raise Exception(content)
+                widgets[0] = self._get_message(content)
+            progress_indicator.update(indicator_count)
+            if content.get('processed'):
+                break
+            sleep(0.1)
+        progress_indicator.finish()
+        self.__content = content
+        return content
+
+    def raise_for_code(self):
+        """Raise an exception if content has particular error codes"""
+        if any(self.__content['code'] == _k for _k in self.__error_codes):
+            raise errors.StoreReviewError(self.__content)
+
+    def _get_message(self, content):
+        """Get a message from content"""
+        return self.__messages.get(content['code'], content['code'])
+
+    def _update_status(self, queue):
+        """Update an operation status"""
+        for content in self._get_status():
+            queue.put(content)
+            if content['processed']:
+                break
+            sleep(constants.SCAN_STATUS_POLL_DELAY)
+
+    def _get_status(self):
+        """Get an operation status"""
+        connection_errors_allowed = 10
+        while True:
+            try:
+                content = requests.get(self.__status_details_url).json()
+            except (requests.ConnectionError, requests.HTTPError) as _e:
+                if not connection_errors_allowed:
+                    yield _e
+                content = {'processed': False, 'code': 'being_processed'}
+                connection_errors_allowed -= 1
+            yield content

=== added file 'snappy_ecosystem_tests/helpers/store_apis/upload.py'
--- snappy_ecosystem_tests/helpers/store_apis/upload.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/helpers/store_apis/upload.py	2017-02-20 17:48:06 +0000
@@ -0,0 +1,97 @@
+# -*- 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/>.
+#
+
+"""Helpers to upload binary files to the store"""
+
+import logging
+import functools
+import os
+
+from progressbar import (
+    Bar,
+    Percentage,
+    ProgressBar,
+)
+from requests_toolbelt import (MultipartEncoder, MultipartEncoderMonitor)
+
+from snappy_ecosystem_tests.helpers.store_apis.errors import StoreUploadError
+
+LOGGER = logging.getLogger(__name__)
+
+
+def _update_progress_bar(progress_bar, maximum_value, monitor):
+    """Update the progress bar status"""
+    if monitor.bytes_read <= maximum_value:
+        progress_bar.update(monitor.bytes_read)
+
+
+def upload_files(binary_filename, updown_client):
+    """Upload a binary file to the Store.
+    Submit a file to the Store upload service and return the
+    corresponding upload_id.
+    """
+    binary_file = None
+    try:
+        binary_file_size = os.path.getsize(binary_filename)
+        binary_file = open(binary_filename, 'rb')
+        encoder = MultipartEncoder(
+            fields={
+                'binary': ('filename', binary_file, 'application/octet-stream')
+            }
+        )
+
+        # Create a progress bar that looks like: Uploading foo [==  ] 50%
+        progress_bar = ProgressBar(
+            widgets=['Uploading {} '.format(binary_filename),
+                     Bar(marker='=', left='[', right=']'), ' ', Percentage()],
+            maxval=os.path.getsize(binary_filename))
+        progress_bar.start()
+        # Print a newline so the progress bar has some breathing room.
+        LOGGER.info('')
+
+        # Create a monitor for this upload, so that progress can be displayed
+        monitor = MultipartEncoderMonitor(
+            encoder, functools.partial(_update_progress_bar, progress_bar,
+                                       binary_file_size))
+
+        # Begin upload
+        response = updown_client.upload(monitor)
+
+        # Make sure progress bar shows 100% complete
+        progress_bar.finish()
+
+    except Exception as err:
+        raise RuntimeError(
+            'An unexpected error was found while uploading '
+            'files: {!r}.'.format(err))
+    finally:
+        # Close the open file
+        if binary_file:
+            binary_file.close()
+
+    if not response.ok:
+        raise StoreUploadError(response)
+
+    response_data = response.json()
+    return {
+        'upload_id': response_data['upload_id'],
+        'binary_filesize': binary_file_size,
+        'source_uploaded': False,
+    }

=== removed directory 'snappy_ecosystem_tests/snapcraft'
=== removed file 'snappy_ecosystem_tests/snapcraft/__init__.py'
--- snappy_ecosystem_tests/snapcraft/__init__.py	2017-02-09 20:09:40 +0000
+++ snappy_ecosystem_tests/snapcraft/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,19 +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/>.
-#

=== removed file 'snappy_ecosystem_tests/snapcraft/snapcraft.py'
--- snappy_ecosystem_tests/snapcraft/snapcraft.py	2017-02-15 19:14:19 +0000
+++ snappy_ecosystem_tests/snapcraft/snapcraft.py	1970-01-01 00:00:00 +0000
@@ -1,74 +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/>.
-#
-
-"""Snapcraft client helpers"""
-
-import pexpect
-
-
-# login credentials exported by shell environment
-from snappy_ecosystem_tests.utils import storeconfig
-
-LOGIN_EMAIL, LOGIN_PASSWORD = storeconfig.get_store_credentials()
-
-
-class Snapcraft(object):
-    """Contain Snapcraft specific functionality to use via command
-    line interface"""
-    def __init__(self):
-        """Create new snapcraft instance."""
-        self._login = False
-        self._cleanup()
-
-    def _cleanup(self):
-        """Perform cleanup actions"""
-        self.logout()
-
-    def logout(self):
-        """logout of snapcraft store session"""
-        child = pexpect.spawn("snapcraft logout")
-        err = child.expect('Credentials cleared.')
-        child.terminate(True)
-        child.wait()
-        if err is not 0:
-            raise ValueError("Failed to logout")
-
-        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()

=== added file 'snappy_ecosystem_tests/tests/test_store_apis_login.py'
--- snappy_ecosystem_tests/tests/test_store_apis_login.py	1970-01-01 00:00:00 +0000
+++ snappy_ecosystem_tests/tests/test_store_apis_login.py	2017-02-20 17:48:06 +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/>.
+#
+
+"""Test for Login to the Store via RESTful APIs"""
+
+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 StoreAPILoginTestCase(SnappyEcosystemTestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.client = Store()
+
+    def test_api_login_logout(self):
+        """Test login and logout functionality in store REST APIs"""
+        self.client.login(*get_store_credentials())
+        self.client.load_config()
+        self.assertIsNotNone(self.client.config.get('macaroon'))
+        self.assertIsNotNone(self.client.config.get('unbound_discharge'))

=== modified file 'snappy_ecosystem_tests/tests/test_store_login.py'
--- snappy_ecosystem_tests/tests/test_store_login.py	2017-02-15 19:14:19 +0000
+++ snappy_ecosystem_tests/tests/test_store_login.py	2017-02-20 17:48:06 +0000
@@ -20,7 +20,7 @@
 
 """Test for Login to the Store via Web Interface, snapcraft and snapd"""
 
-from snappy_ecosystem_tests.snapcraft.snapcraft import Snapcraft
+from snappy_ecosystem_tests.helpers.snapcraft.client import Snapcraft
 from snappy_ecosystem_tests.helpers.web_test_base import UbuntuStoreWebTestsBase