Merge ~matt-goodall/snapstore-client:per-store-config into snapstore-client:master

[Matt Goodall]

Configure a "store" at login and use that config for future calls.

Replaces old config consisting of fixed service URLs (too fine-grained anyway) and per-store credentials. A store's config now consists of the store's URL, SSO's URL, and the user credentials (macaroons etc).

For now, there is only one store - called "default" - but the command line could be extended to login and then select a store with a different name.

The diff makes it look more complicated than it is I think.

To help review ...

The big difference is that there's no global/fixed state any more - config is loaded at the start of a command and explicitly passed through to things like the webservices calls. No more importing config from files relative to Python modules \o/.

As a result, config management changed quite a lot although was largely based on the old Credentials bit of the config. It's actually simpler now.

[Adam Collard (adam-collard)]

review: Approve

[Otto Co-Pilot (otto-copilot)]

Project setup failed
https://jenkins.ols.canonical.com/online-services/job/snapstore-client/3/

[Matt Goodall (matt-goodall)]

review: Approve

[Otto Co-Pilot (otto-copilot)]

Running landing tests failed
https://jenkins.ols.canonical.com/online-services/job/snapstore-client/6/

diff --git a/README b/README
index 8c40b12..6171594 100644
--- a/README
+++ b/README
@@ -1,20 +1,8 @@
-SIAB client script.
-===================
+snapstore administration client
+===============================
 
+This repo contains a client to adminster a snapstore.
 
-This repo contains a few points of interest:
+After authenticating with a snapstore the administrator can:
 
- * The serve-snaps.py script will start a simple HTTP server to serve snap
-   files from 'snap_storage'. Please don't use this in production, it's only
-   supposed to be used for dev setups.
-
- * The snapstore script is a CLI UI to administer the snap store. Currently the
-   only command is 'upload'. It can do two things:
-
-    - upload a snap to the store, but don't release it::
-
-     $ snapstore upload /path/to/file.snap
-
-    - upload and release a snap to a given channel:
-
-     $ snapstore upload --channel /path/to/file.snap
+  - manage revision overrides
diff --git a/snapstore b/snapstore
index ec0978d..9c2b0b1 100755
--- a/snapstore
+++ b/snapstore
@@ -17,6 +17,9 @@ from snapstore_client.logic.overrides import (
 )
 
 
+DEFAULT_SSO_URL = 'https://login.ubuntu.com/'
+
+
 def main():
     configure_logging()
     args = parse_args()
@@ -27,8 +30,13 @@ def parse_args():
     parser = argparse.ArgumentParser()
     subparsers = parser.add_subparsers(help='sub-command help')
 
-    login_parser = subparsers.add_parser('login', help='Sign into a store.')
+    login_parser = subparsers.add_parser(
+        'login', help='Sign into a store.',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    login_parser.add_argument('store_url', help='Store URL')
     login_parser.add_argument('email', help='Ubuntu One SSO email', nargs='?')
+    login_parser.add_argument('--sso-url', help='Ubuntu One SSO URL',
+                              default=DEFAULT_SSO_URL)
     login_parser.set_defaults(func=login)
 
     list_overrides_parser = subparsers.add_parser(
diff --git a/snapstore_client/config.py b/snapstore_client/config.py
index 94df99b..ca7beb9 100644
--- a/snapstore_client/config.py
+++ b/snapstore_client/config.py
@@ -6,150 +6,69 @@
 
 import configparser
 import os
-from urllib.parse import urlparse
 
 from xdg import BaseDirectory
 
 
-ROOT = os.path.abspath(
-    os.path.join(
-        os.path.dirname(__file__),
-        '..'
-    )
-)
+class Config:
 
-
-DEFAULT_TEST_CONFIG = {
-    'services': {
-        'snapdevicegw': 'http://localhost:8000/',
-        'storage': 'http://localhost:8005/',
-    }
-}
-
-
-def _production_read_config():
-    root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
-    config = configparser.ConfigParser(dict(ROOT=root))
-    default_path = os.path.join(root, 'service.conf')
-    config.read(default_path)
-    return {sec: dict(config.items(sec)) for sec in config.sections()}
-
-
-class ConfigProvider(object):
-
-    """Provide a single entry point for reading config that can be altered.
-
-    This class allows production code to call 'read_config' and get a copy of
-    test configuration during test runs, but production config during normal
-    operations.
-    """
-
-    def __init__(self, default_test_config):
-        self._test_override = []
-        self._default_test_config = default_test_config
-
-    def __call__(self):
-        if self._test_override:
-            return self._test_override[-1]
-        else:
-            return _production_read_config()
-
-    def merge_config(self, config, new_config):
-        merged_config = config.copy()
-        for key in new_config.keys():
-            if key in config.keys():
-                if isinstance(config[key], dict) and \
-                   isinstance(new_config[key], dict):
-                    merged_config[key] = self.merge_config(
-                        config[key], new_config[key])
-                else:
-                    merged_config[key] = new_config[key]
-            else:
-                merged_config[key] = new_config[key]
-        return merged_config
-
-    def override_for_test(self, new_config):
-        """Override configuration for a test.
-
-        In a test, if you wanted to set a value, you can do this::
-
-            from snapdevicegw.config import read_config
-
-            def test_something(self):
-                new_config = {
-                    'worker': {
-                        'some_setting': 'some_value'
-                    }
-                }
-                self.addCleanup(read_config.override_for_test(new_config))
-
-        The configuration provided is merged on top of DEFAULT_TEST_CONFIG
-        (see above), so there's no need to specify values that are in the
-        default config.
-        """
-        if self._test_override:
-            source = self._test_override[-1]
-        else:
-            source = self._default_test_config.copy()
-        config = self.merge_config(source, new_config)
-        self._test_override.append(config)
-        return self._test_override.pop
-
-
-read_config = ConfigProvider(DEFAULT_TEST_CONFIG)
-
-
-class Credentials:
-    """Per-user credentials storage."""
+    xdg_name = 'snapstore-client'
 
     def __init__(self):
         self.parser = configparser.ConfigParser()
         self.load()
 
-    @property
-    def _section_name(self):
-        # The only section we care about is the host from the snapdevicegw
-        # URL.
-        return urlparse(read_config()['services']['snapdevicegw']).netloc
+    def load(self):
+        path = BaseDirectory.load_first_config(
+            self.xdg_name, 'config.ini')
+        if path is not None and os.path.exists(path):
+            self.parser.read(path)
+
+    def save(self):
+        path = os.path.join(
+            BaseDirectory.save_config_path(self.xdg_name),
+            'config.ini')
+        # TODO: better to write atomically
+        with open(path, 'w') as f:
+            self.parser.write(f)
 
-    def get(self, option_name):
+    def get(self, section, option):
         try:
-            return self.parser.get(self._section_name, option_name)
+            return self.parser.get(section, option)
         except (configparser.NoSectionError,
                 configparser.NoOptionError,
                 KeyError):
             return None
 
-    def set(self, option_name, 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 set(self, section, option, value):
+        if not self.parser.has_section(section):
+            self.parser.add_section(section)
+        return self.parser.set(section, option, value)
 
-    def is_empty(self):
-        # 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 section(self, name):
+        return Section(self, name)
 
-    def load(self):
-        path = BaseDirectory.load_first_config(
-            'snapstore-client', 'credentials.cfg')
-        if path is not None and os.path.exists(path):
-            self.parser.read(path)
+    def store_section(self, name):
+        return Section(self, 'store:'+name)
 
-    @staticmethod
-    def save_path():
-        return os.path.join(
-            BaseDirectory.save_config_path('snapstore-client'),
-            'credentials.cfg')
 
-    def save(self):
-        path = self.save_path()
-        with open(path, 'w') as f:
-            self.parser.write(f)
+class Section:
 
-    def clear(self):
-        self.parser.remove_section(self._section_name)
+    def __init__(self, config, name):
+        self.config = config
+        self.name = name
+
+    def get(self, option):
+        return self.config.get(self.name, option)
+
+    def set(self, option, value):
+        return self.config.set(self.name, option, value)
+
+    # XXX: mostly a hack
+    # I don't think it's nice to expose save like this because it implies only
+    # the section is updated. However, the webservices code currently refreshes
+    # a store's macaroon and therefore needs to update and save config.
+    # A better approach may be to *always* save config at the end of the
+    # process so the internal implementation doesn't care about persistence.
+    def save(self):
+        self.config.save()
diff --git a/snapstore_client/logic/login.py b/snapstore_client/logic/login.py
index 47ab6b8..2963aef 100644
--- a/snapstore_client/logic/login.py
+++ b/snapstore_client/logic/login.py
@@ -16,9 +16,9 @@ from snapstore_client import (
 logger = logging.getLogger(__name__)
 
 
-def _extract_caveat_id(root_macaroon):
+def _extract_caveat_id(sso_url, root_macaroon):
     macaroon = Macaroon.deserialize(root_macaroon)
-    sso_host = urlparse(config.read_config()['services']['sso']).netloc
+    sso_host = urlparse(sso_url).netloc
     for caveat in macaroon.caveats:
         if caveat.location == sso_host:
             return caveat.caveat_id
@@ -27,22 +27,26 @@ def _extract_caveat_id(root_macaroon):
 
 
 def login(args):
+    # TODO: validate these before using to avoid ugly errors.
+    gw_url = args.store_url
+    sso_url = args.sso_url
+
     logger.info('Enter your Ubuntu One SSO credentials.')
     email = args.email
     if not email:
         email = input('Email: ')
     password = getpass.getpass('Password: ')
 
-    root = ws.issue_store_admin()
-    caveat_id = _extract_caveat_id(root)
+    root = ws.issue_store_admin(gw_url)
+    caveat_id = _extract_caveat_id(sso_url, root)
     try:
         try:
             unbound_discharge = ws.get_sso_discharge(
-                email, password, caveat_id)
+                sso_url, email, password, caveat_id)
         except exceptions.StoreTwoFactorAuthenticationRequired:
             one_time_password = input('Second-factor auth: ')
             unbound_discharge = ws.get_sso_discharge(
-                email, password, caveat_id,
+                sso_url, email, password, caveat_id,
                 one_time_password=one_time_password)
     except exceptions.StoreAuthenticationError as e:
         logger.error('Login failed.')
@@ -54,10 +58,17 @@ def login(args):
                 logger.error('%s: %s', key, value)
         return 1
 
-    credentials = config.Credentials()
-    credentials.set('root', root)
-    credentials.set('unbound_discharge', unbound_discharge)
-    credentials.set('email', email)
-    credentials.save()
+    cfg = config.Config()
+    # For now, the store is always called "default". In the future we may want
+    # to support multiple stores by allowing the user to provide a nice name
+    # for a store at login that can be used to select the store for later
+    # operations.
+    store = cfg.store_section('default')
+    store.set('gw_url', gw_url)
+    store.set('sso_url', sso_url)
+    store.set('root', root)
+    store.set('unbound_discharge', unbound_discharge)
+    store.set('email', email)
+    cfg.save()
 
     return 0
diff --git a/snapstore_client/logic/overrides.py b/snapstore_client/logic/overrides.py
index f514c48..54e421e 100644
--- a/snapstore_client/logic/overrides.py
+++ b/snapstore_client/logic/overrides.py
@@ -5,6 +5,7 @@ import logging
 from requests.exceptions import HTTPError
 
 from snapstore_client import (
+    config,
     exceptions,
     webservices as ws,
 )
@@ -19,13 +20,30 @@ logger = logging.getLogger(__name__)
 
 def _log_credentials_error(e):
     logger.error('%s', e)
-    logger.error('Have you run "snapstore login"?')
+    logger.error('Try to "snapstore login" again.')
+
+
+def _check_default_store(cfg):
+    """Load the default store from the config."""
+    store = cfg.store_section('default')
+    # If the gw URL is configured then everything else should be too.
+    if not store.get('gw_url'):
+        logger.error(
+            'No store configuration found. Have you run "snapstore login"?')
+        return None
+    return store
 
 
 def list_overrides(args):
+    cfg = config.Config()
+    store = _check_default_store(cfg)
+    if not store:
+        return 1
+
     try:
         response = ws.refresh_if_necessary(
-            ws.get_overrides, args.snap_name, series=args.series)
+            store, ws.get_overrides,
+            store, args.snap_name, series=args.series)
     except exceptions.InvalidCredentials as e:
         _log_credentials_error(e)
         return 1
@@ -37,6 +55,11 @@ def list_overrides(args):
 
 
 def override(args):
+    cfg = config.Config()
+    store = _check_default_store(cfg)
+    if not store:
+        return 1
+
     overrides = []
     for channel_map_entry in args.channel_map_entries:
         channel, revision = channel_map_string_to_tuple(channel_map_entry)
@@ -47,7 +70,9 @@ def override(args):
             'series': args.series,
         })
     try:
-        response = ws.refresh_if_necessary(ws.set_overrides, overrides)
+        response = ws.refresh_if_necessary(
+            store, ws.set_overrides,
+            store, overrides)
     except exceptions.InvalidCredentials as e:
         _log_credentials_error(e)
         return 1
@@ -59,6 +84,11 @@ def override(args):
 
 
 def delete_override(args):
+    cfg = config.Config()
+    store = _check_default_store(cfg)
+    if not store:
+        return 1
+
     overrides = []
     for channel in args.channels:
         overrides.append({
@@ -68,7 +98,9 @@ def delete_override(args):
             'series': args.series,
         })
     try:
-        response = ws.refresh_if_necessary(ws.set_overrides, overrides)
+        response = ws.refresh_if_necessary(
+            store, ws.set_overrides,
+            store, overrides)
     except exceptions.InvalidCredentials as e:
         _log_credentials_error(e)
         return 1
diff --git a/snapstore_client/logic/tests/test_login.py b/snapstore_client/logic/tests/test_login.py
index 20d9d74..25ef14f 100644
--- a/snapstore_client/logic/tests/test_login.py
+++ b/snapstore_client/logic/tests/test_login.py
@@ -2,9 +2,8 @@
 
 import json
 from unittest import mock
-from urllib.parse import urljoin
+from urllib.parse import urljoin, urlparse
 
-from acceptable._doubles import set_service_locations
 import fixtures
 from pymacaroons import Macaroon
 import responses
@@ -20,20 +19,15 @@ from snapstore_client import (
     exceptions,
 )
 from snapstore_client.logic.login import login
-from snapstore_client.tests import (
-    factory,
-    testfixtures,
-)
+from snapstore_client.tests import factory
 
 
 class LoginTests(TestCase):
 
     def setUp(self):
         super().setUp()
-        self.useFixture(testfixtures.ConfigOverrideFixture(
-            {'services': {'sso': 'https://login.example.com/'}}))
-        service_locations = config.read_config()['services']
-        set_service_locations(service_locations)
+        self.default_gw_url = 'http://store.local/'
+        self.default_sso_url = 'https://login.staging.ubuntu.com/'
         self.logger = self.useFixture(fixtures.FakeLogger())
         self.config_path = self.useFixture(fixtures.TempDir()).path
         self.useFixture(fixtures.MonkeyPatch(
@@ -60,27 +54,33 @@ class LoginTests(TestCase):
         iter_responses = iter(full_responses)
         return lambda request: next(iter_responses)
 
-    def make_args(self, email=None):
-        return factory.Args(email=email)
+    def make_args(self, store_url=None, sso_url=None, email=None):
+        return factory.Args(
+            store_url=store_url or self.default_gw_url,
+            sso_url=sso_url or self.default_sso_url,
+            email=email,
+        )
 
-    def add_issue_store_admin_response(self, *response_templates):
-        devicegw_root = config.read_config()['services']['snapdevicegw']
-        issue_store_admin_url = urljoin(
-            devicegw_root, '/v2/auth/issue-store-admin')
+    def add_issue_store_admin_response(self, *response_templates, gw_url=None):
+        gw_url = gw_url or self.default_gw_url
+        issue_store_admin_url = urljoin(gw_url, '/v2/auth/issue-store-admin')
         responses.add_callback(
             'POST', issue_store_admin_url,
             self.make_responses_callback(response_templates))
 
-    def add_get_sso_discharge_response(self, *response_templates):
-        sso_root = config.read_config()['services']['sso']
-        discharge_url = urljoin(sso_root, '/api/v2/tokens/discharge')
+    def add_get_sso_discharge_response(self, *response_templates,
+                                       sso_url=None):
+        sso_url = sso_url or self.default_sso_url
+        discharge_url = urljoin(sso_url, '/api/v2/tokens/discharge')
         responses.add_callback(
             'POST', discharge_url,
             self.make_responses_callback(response_templates))
 
-    def make_root_macaroon(self):
+    def make_root_macaroon(self, sso_url=None):
         macaroon = Macaroon()
-        macaroon.add_third_party_caveat('login.example.com', 'key', 'payload')
+        sso_url = sso_url or self.default_sso_url
+        sso_host = urlparse(sso_url).netloc
+        macaroon.add_third_party_caveat(sso_host, 'key', 'payload')
         return macaroon.serialize()
 
     @responses.activate
@@ -161,8 +161,10 @@ class LoginTests(TestCase):
             'caveat_id': 'payload',
             'otp': '123456',
         }, json.loads(responses.calls[2].request.body.decode()))
-        self.assertThat(config.Credentials().parser, ContainsDict({
-            'localhost:8000': MatchesDict({
+        self.assertThat(config.Config().parser, ContainsDict({
+            'store:default': MatchesDict({
+                'gw_url': Equals(self.default_gw_url),
+                'sso_url': Equals(self.default_sso_url),
                 'root': Equals(root),
                 'unbound_discharge': Equals('dummy'),
                 'email': Equals('[e-mail]'),
@@ -190,8 +192,10 @@ class LoginTests(TestCase):
             'password': 'secret',
             'caveat_id': 'payload',
         }, json.loads(responses.calls[1].request.body.decode()))
-        self.assertThat(config.Credentials().parser, ContainsDict({
-            'localhost:8000': MatchesDict({
+        self.assertThat(config.Config().parser, ContainsDict({
+            'store:default': MatchesDict({
+                'gw_url': Equals(self.default_gw_url),
+                'sso_url': Equals(self.default_sso_url),
                 'root': Equals(root),
                 'unbound_discharge': Equals('dummy'),
                 'email': Equals('[e-mail]'),
@@ -219,10 +223,62 @@ class LoginTests(TestCase):
             'password': 'secret',
             'caveat_id': 'payload',
         }, json.loads(responses.calls[1].request.body.decode()))
-        self.assertThat(config.Credentials().parser, ContainsDict({
-            'localhost:8000': MatchesDict({
+        self.assertThat(config.Config().parser, ContainsDict({
+            'store:default': MatchesDict({
+                'gw_url': Equals(self.default_gw_url),
+                'sso_url': Equals(self.default_sso_url),
                 'root': Equals(root),
                 'unbound_discharge': Equals('dummy'),
                 'email': Equals('[e-mail]'),
             }),
         }))
+
+    @responses.activate
+    def test_store_url(self):
+        gw_url = 'http://otherstore.local:1234/'
+
+        self.mock_input.return_value = '[e-mail]'
+        self.mock_getpass.return_value = 'secret'
+        root = self.make_root_macaroon()
+        self.add_issue_store_admin_response(
+            {'status': 200, 'json': {'macaroon': root}}, gw_url=gw_url)
+        self.add_get_sso_discharge_response(
+            {'status': 200, 'json': {'discharge_macaroon': 'dummy'}})
+        login(self.make_args(store_url=gw_url))
+
+        self.assertEqual(2, len(responses.calls))
+        self.assertEqual(responses.calls[0].request.url[:len(gw_url)], gw_url)
+        self.assertTrue(
+            responses.calls[1].request.url.startswith(self.default_sso_url))
+        self.assertThat(config.Config().parser, ContainsDict({
+            'store:default': ContainsDict({
+                'gw_url': Equals(gw_url),
+                'sso_url': Equals(self.default_sso_url),
+            }),
+        }))
+
+    @responses.activate
+    def test_sso_url(self):
+        sso_url = 'https://othersso.local:1234/'
+
+        self.mock_input.return_value = '[e-mail]'
+        self.mock_getpass.return_value = 'secret'
+        root = self.make_root_macaroon(sso_url=sso_url)
+        self.add_issue_store_admin_response(
+            {'status': 200, 'json': {'macaroon': root}})
+        self.add_get_sso_discharge_response(
+            {'status': 200, 'json': {'discharge_macaroon': 'dummy'}},
+            sso_url=sso_url)
+        login(self.make_args(sso_url=sso_url))
+
+        self.assertEqual(2, len(responses.calls))
+        self.assertTrue(
+            responses.calls[0].request.url.startswith(self.default_gw_url))
+        self.assertEqual(
+            responses.calls[1].request.url[:len(sso_url)], sso_url)
+        self.assertThat(config.Config().parser, ContainsDict({
+            'store:default': ContainsDict({
+                'gw_url': Equals(self.default_gw_url),
+                'sso_url': Equals(sso_url),
+            }),
+        }))
diff --git a/snapstore_client/logic/tests/test_overrides.py b/snapstore_client/logic/tests/test_overrides.py
index 80a929f..b92c966 100644
--- a/snapstore_client/logic/tests/test_overrides.py
+++ b/snapstore_client/logic/tests/test_overrides.py
@@ -3,7 +3,6 @@
 import json
 from urllib.parse import urljoin
 
-from acceptable._doubles import set_service_locations
 import fixtures
 import responses
 from testtools import TestCase
@@ -22,15 +21,19 @@ from snapstore_client.tests import (
 
 class OverridesTests(TestCase):
 
-    def setUp(self):
-        super().setUp()
-        service_locations = config.read_config()['services']
-        set_service_locations(service_locations)
+    def test_list_overrides_no_store_config(self):
+        self.useFixture(testfixtures.ConfigFixture(empty=True))
+        logger = self.useFixture(fixtures.FakeLogger())
+        rc = list_overrides(factory.Args(snap_name='some-snap', series='16'))
+        self.assertEqual(rc, 1)
+        self.assertEqual(
+            logger.output,
+            'No store configuration found. Have you run "snapstore login"?\n')
 
     @responses.activate
     def test_list_overrides(self):
+        self.useFixture(testfixtures.ConfigFixture())
         logger = self.useFixture(fixtures.FakeLogger())
-        self.useFixture(testfixtures.CredentialsFixture())
         snap_id = factory.generate_snap_id()
         overrides = [
             factory.SnapDeviceGateway.Override(
@@ -43,7 +46,7 @@ class OverridesTests(TestCase):
         # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
         # they exist.
         overrides_url = urljoin(
-            config.read_config()['services']['snapdevicegw'],
+            config.Config().store_section('default').get('gw_url'),
             '/v2/metadata/overrides/mysnap')
         responses.add(
             'GET', overrides_url, status=200, json={'overrides': overrides})
@@ -54,10 +57,21 @@ class OverridesTests(TestCase):
             'mysnap foo/stable i386 3 (upstream 4)\n',
             logger.output)
 
+    def test_override_no_store_config(self):
+        self.useFixture(testfixtures.ConfigFixture(empty=True))
+        logger = self.useFixture(fixtures.FakeLogger())
+        rc = override(factory.Args(
+            snap_name='some-snap', channel_map_entries=['stable=1'],
+            series='16'))
+        self.assertEqual(rc, 1)
+        self.assertEqual(
+            logger.output,
+            'No store configuration found. Have you run "snapstore login"?\n')
+
     @responses.activate
     def test_override(self):
+        self.useFixture(testfixtures.ConfigFixture())
         logger = self.useFixture(fixtures.FakeLogger())
-        self.useFixture(testfixtures.CredentialsFixture())
         snap_id = factory.generate_snap_id()
         overrides = [
             factory.SnapDeviceGateway.Override(
@@ -70,7 +84,7 @@ class OverridesTests(TestCase):
         # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
         # they exist.
         overrides_url = urljoin(
-            config.read_config()['services']['snapdevicegw'],
+            config.Config().store_section('default').get('gw_url'),
             '/v2/metadata/overrides')
         responses.add(
             'POST', overrides_url, status=200, json={'overrides': overrides})
@@ -98,10 +112,20 @@ class OverridesTests(TestCase):
             'mysnap foo/stable i386 3 (upstream 4)\n',
             logger.output)
 
+    def test_delete_override_no_store_config(self):
+        self.useFixture(testfixtures.ConfigFixture(empty=True))
+        logger = self.useFixture(fixtures.FakeLogger())
+        rc = delete_override(factory.Args(
+            snap_name='some-snap', channels=['stable'], series='16'))
+        self.assertEqual(rc, 1)
+        self.assertEqual(
+            logger.output,
+            'No store configuration found. Have you run "snapstore login"?\n')
+
     @responses.activate
     def test_delete_override(self):
+        self.useFixture(testfixtures.ConfigFixture())
         logger = self.useFixture(fixtures.FakeLogger())
-        self.useFixture(testfixtures.CredentialsFixture())
         snap_id = factory.generate_snap_id()
         overrides = [
             factory.SnapDeviceGateway.Override(
@@ -114,7 +138,7 @@ class OverridesTests(TestCase):
         # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
         # they exist.
         overrides_url = urljoin(
-            config.read_config()['services']['snapdevicegw'],
+            config.Config().store_section('default').get('gw_url'),
             '/v2/metadata/overrides')
         responses.add(
             'POST', overrides_url, status=200, json={'overrides': overrides})
diff --git a/snapstore_client/tests/test_config.py b/snapstore_client/tests/test_config.py
index 0940828..2ddbc5c 100644
--- a/snapstore_client/tests/test_config.py
+++ b/snapstore_client/tests/test_config.py
@@ -1,71 +1,74 @@
 # Copyright 2017 Canonical Ltd.  This software is licensed under the
 # GNU General Public License version 3 (see the file LICENSE).
 
+import os.path
+from textwrap import dedent
+
 from testtools import TestCase
 
-from snapstore_client.config import ConfigProvider
-
-
-class ConfigProviderTestCase(TestCase):
-
-    def test_override_works_for_new_section_and_option(self):
-        default = {}
-        override = {
-            'new_section': {
-                'new_option': 'new_value'
-            }
-        }
-        expected = override.copy()
-
-        provider = ConfigProvider(default)
-        provider.override_for_test(override)
-
-        self.assertEqual(expected, provider())
-
-    def test_override_works_when_adding_new_option_to_existing_section(self):
-        default = {
-            'section': {
-                'option': 'value'
-            }
-        }
-        override = {
-            'section': {
-                'new_option': 'new_value'
-            }
-        }
-        expected = {
-            'section': {
-                'option': 'value',
-                'new_option': 'new_value'
-            }
-        }
-
-        provider = ConfigProvider(default)
-        provider.override_for_test(override)
-
-        self.assertEqual(expected, provider())
-
-    def test_override_works_when_changing_existing_option(self):
-        default = {
-            'section': {
-                'option': 'value'
-            }
-        }
-        override = {
-            'section': {
-                'option': 'new_value'
-            }
-        }
-        expected = {
-            'section': {
-                'option': 'new_value',
-            }
-        }
-
-        provider = ConfigProvider(default)
-        provider.override_for_test(override)
-
-        self.assertEqual(expected, provider())
+from snapstore_client.config import Config
+from snapstore_client.tests.testfixtures import (
+    ConfigFixture,
+    XDGConfigDirFixture,
+)
+
+
+class ConfigTests(TestCase):
+
+    def test_no_config(self):
+        xdg_path = self.useFixture(XDGConfigDirFixture()).path
+        config_ini = os.path.join(xdg_path, Config.xdg_name, 'config.ini')
+        self.assertFalse(os.path.exists(config_ini))
+        Config()
+
+    def test_init_loads(self):
+        self.useFixture(ConfigFixture())
+        cfg = Config()
+        self.assertIsNotNone(cfg.get("store:default", "gw_url"))
+
+    def test_save(self):
+        xdg_path = self.useFixture(XDGConfigDirFixture()).path
+        config_ini = os.path.join(xdg_path, 'snapstore-client', 'config.ini')
+        self.assertFalse(os.path.exists(config_ini))
+
+        cfg = Config()
+        cfg.set("s", "k", "v")
+        cfg.save()
+
+        self.assertTrue(os.path.exists(config_ini))
+        with open(config_ini) as f:
+            content = f.read()
+        self.assertEqual(content, dedent('''\
+            [s]
+            k = v
+
+        '''))
+
+    def test_get_missing(self):
+        self.useFixture(XDGConfigDirFixture())
+        cfg = Config()
+        self.assertIsNone(cfg.get("s", "k"))
+
+    def test_get(self):
+        self.useFixture(XDGConfigDirFixture())
+        cfg = Config()
+        cfg.set("s", "k", "v")
+        self.assertEqual(cfg.get("s", "k"), "v")
+
+    def test_section(self):
+        self.useFixture(XDGConfigDirFixture())
+        cfg = Config()
+        s = cfg.section("s")
+        s.set("k", "v")
+        self.assertEqual(s.get("k"), "v")
+        self.assertEqual(cfg.get("s", "k"), "v")
+
+    def test_store_section(self):
+        self.useFixture(XDGConfigDirFixture())
+        cfg = Config()
+        store = cfg.store_section("foo")
+        store.set("k", "v")
+        self.assertEqual(cfg.get("store:foo", "k"), "v")
 
 
 def test_suite():
diff --git a/snapstore_client/tests/test_webservices.py b/snapstore_client/tests/test_webservices.py
index fd51f7e..f6bf6bf 100644
--- a/snapstore_client/tests/test_webservices.py
+++ b/snapstore_client/tests/test_webservices.py
@@ -6,7 +6,6 @@ import sys
 import types
 from urllib.parse import urljoin
 
-from acceptable._doubles import set_service_locations
 import fixtures
 from requests.exceptions import HTTPError
 import responses
@@ -39,39 +38,37 @@ class WebservicesTests(TestCase):
 
     def setUp(self):
         super().setUp()
-        service_locations = config.read_config()['services']
-        set_service_locations(service_locations)
+        self.config = self.useFixture(testfixtures.ConfigFixture())
 
     @responses.activate
     def test_issue_store_admin_success(self):
-        devicegw_root = config.read_config()['services']['snapdevicegw']
-        issue_store_admin_url = urljoin(
-            devicegw_root, '/v2/auth/issue-store-admin')
+        gw_url = 'http://store.local/'
+        issue_store_admin_url = urljoin(gw_url, '/v2/auth/issue-store-admin')
         responses.add(
             'POST', issue_store_admin_url, status=200,
             json={'macaroon': 'dummy'})
 
-        self.assertEqual('dummy', webservices.issue_store_admin())
+        self.assertEqual('dummy', webservices.issue_store_admin(gw_url))
 
     @responses.activate
     def test_issue_store_admin_error(self):
         logger = self.useFixture(fixtures.FakeLogger())
-        devicegw_root = config.read_config()['services']['snapdevicegw']
-        issue_store_admin_url = urljoin(
-            devicegw_root, '/v2/auth/issue-store-admin')
+        gw_url = 'http://store.local/'
+        issue_store_admin_url = urljoin(gw_url, '/v2/auth/issue-store-admin')
         responses.add(
             'POST', issue_store_admin_url, status=400,
             json=factory.APIError.single('Something went wrong').to_dict())
 
-        self.assertRaises(HTTPError, webservices.issue_store_admin)
+        self.assertRaises(
+            HTTPError, webservices.issue_store_admin, gw_url)
         self.assertEqual(
             'Failed to issue store_admin macaroon:\nSomething went wrong\n',
             logger.output)
 
     @responses.activate
     def test_get_sso_discharge_success(self):
-        sso_root = config.read_config()['services']['sso']
-        discharge_url = urljoin(sso_root, '/api/v2/tokens/discharge')
+        sso_url = 'http://sso.local/'
+        discharge_url = urljoin(sso_url, '/api/v2/tokens/discharge')
         responses.add(
             'POST', discharge_url, status=200,
             json={'discharge_macaroon': 'dummy'})
@@ -79,7 +76,7 @@ class WebservicesTests(TestCase):
         self.assertEqual(
             'dummy',
             webservices.get_sso_discharge(
-                '[e-mail]', 'secret', 'caveat'))
+                sso_url, '[e-mail]', 'secret', 'caveat'))
         request = responses.calls[0].request
         self.assertEqual('application/json', request.headers['Content-Type'])
         self.assertEqual({
@@ -90,8 +87,8 @@ class WebservicesTests(TestCase):
 
     @responses.activate
     def test_get_sso_discharge_success_with_otp(self):
-        sso_root = config.read_config()['services']['sso']
-        discharge_url = urljoin(sso_root, '/api/v2/tokens/discharge')
+        sso_url = 'http://sso.local/'
+        discharge_url = urljoin(sso_url, '/api/v2/tokens/discharge')
         responses.add(
             'POST', discharge_url, status=200,
             json={'discharge_macaroon': 'dummy'})
@@ -99,7 +96,7 @@ class WebservicesTests(TestCase):
         self.assertEqual(
             'dummy',
             webservices.get_sso_discharge(
-                '[e-mail]', 'secret', 'caveat',
+                sso_url, '[e-mail]', 'secret', 'caveat',
                 one_time_password='123456'))
         request = responses.calls[0].request
         self.assertEqual('application/json', request.headers['Content-Type'])
@@ -112,8 +109,8 @@ class WebservicesTests(TestCase):
 
     @responses.activate
     def test_get_sso_discharge_twofactor_required(self):
-        sso_root = config.read_config()['services']['sso']
-        discharge_url = urljoin(sso_root, '/api/v2/tokens/discharge')
+        sso_url = 'http://sso.local/'
+        discharge_url = urljoin(sso_url, '/api/v2/tokens/discharge')
         responses.add(
             'POST', discharge_url, status=401,
             json={'error_list': [{'code': 'twofactor-required'}]})
@@ -121,32 +118,32 @@ class WebservicesTests(TestCase):
         self.assertRaises(
             exceptions.StoreTwoFactorAuthenticationRequired,
             webservices.get_sso_discharge,
-            '[e-mail]', 'secret', 'caveat')
+            sso_url, '[e-mail]', 'secret', 'caveat')
 
     @responses.activate
     def test_get_sso_discharge_structured_error(self):
-        sso_root = config.read_config()['services']['sso']
-        discharge_url = urljoin(sso_root, '/api/v2/tokens/discharge')
+        sso_url = 'http://sso.local/'
+        discharge_url = urljoin(sso_url, '/api/v2/tokens/discharge')
         responses.add(
             'POST', discharge_url, status=400,
             json=factory.APIError.single('Something went wrong').to_dict())
 
         e = self.assertRaises(
             exceptions.StoreAuthenticationError, webservices.get_sso_discharge,
-            '[e-mail]', 'secret', 'caveat')
+            sso_url, '[e-mail]', 'secret', 'caveat')
         self.assertEqual('Something went wrong', e.message)
 
     @responses.activate
     def test_get_sso_discharge_unstructured_error(self):
         logger = self.useFixture(fixtures.FakeLogger())
-        sso_root = config.read_config()['services']['sso']
-        discharge_url = urljoin(sso_root, '/api/v2/tokens/discharge')
+        sso_url = 'http://sso.local/'
+        discharge_url = urljoin(sso_url, '/api/v2/tokens/discharge')
         responses.add(
             'POST', discharge_url, status=503, body='Try again later.')
 
         self.assertRaises(
             HTTPError, webservices.get_sso_discharge,
-            '[e-mail]', 'secret', 'caveat')
+            sso_url, '[e-mail]', 'secret', 'caveat')
         self.assertEqual(
             'Failed to get SSO discharge:\n'
             '====================\n'
@@ -157,59 +154,58 @@ class WebservicesTests(TestCase):
     @responses.activate
     def test_get_overrides_success(self):
         logger = self.useFixture(fixtures.FakeLogger())
-        credentials = self.useFixture(testfixtures.CredentialsFixture())
         overrides = [factory.SnapDeviceGateway.Override()]
         # XXX cjwatson 2017-06-26: Use acceptable-generated double once it
         # exists.
+        store = config.Config().store_section('default')
         overrides_url = urljoin(
-            config.read_config()['services']['snapdevicegw'],
-            '/v2/metadata/overrides/mysnap')
+            store.get('gw_url'), '/v2/metadata/overrides/mysnap')
         responses.add('GET', overrides_url, status=200, json=overrides)
 
-        self.assertEqual(overrides, webservices.get_overrides('mysnap'))
+        self.assertEqual(overrides, webservices.get_overrides(
+            store, 'mysnap'))
         request = responses.calls[0].request
         self.assertThat(
             request.headers['Authorization'],
-            matchers.MacaroonHeaderVerifies(credentials.key))
+            matchers.MacaroonHeaderVerifies(self.config.key))
         self.assertNotIn('Failed to get overrides:', logger.output)
 
     @responses.activate
     def test_get_overrides_error(self):
         logger = self.useFixture(fixtures.FakeLogger())
-        self.useFixture(testfixtures.CredentialsFixture())
+        store = config.Config().store_section('default')
         overrides_url = urljoin(
-            config.read_config()['services']['snapdevicegw'],
-            '/v2/metadata/overrides/mysnap')
+            store.get('gw_url'), '/v2/metadata/overrides/mysnap')
         responses.add(
             'GET', overrides_url, status=400,
             json=factory.APIError.single('Something went wrong').to_dict())
 
-        self.assertRaises(HTTPError, webservices.get_overrides, 'mysnap')
+        self.assertRaises(
+            HTTPError, webservices.get_overrides, store, 'mysnap')
         self.assertEqual(
             'Failed to get overrides:\nSomething went wrong\n', logger.output)
 
     @responses.activate
     def test_set_overrides_success(self):
         logger = self.useFixture(fixtures.FakeLogger())
-        credentials = self.useFixture(testfixtures.CredentialsFixture())
         override = factory.SnapDeviceGateway.Override()
         # XXX cjwatson 2017-06-26: Use acceptable-generated double once it
         # exists.
-        overrides_url = urljoin(
-            config.read_config()['services']['snapdevicegw'],
-            '/v2/metadata/overrides')
+        store = config.Config().store_section('default')
+        overrides_url = urljoin(store.get('gw_url'), '/v2/metadata/overrides')
         responses.add('POST', overrides_url, status=200, json=[override])
 
-        self.assertEqual([override], webservices.set_overrides([{
-            'snap_name': override['snap_name'],
-            'revision': override['revision'],
-            'channel': override['channel'],
-            'series': override['series'],
-        }]))
+        self.assertEqual([override], webservices.set_overrides(
+            store, [{
+                'snap_name': override['snap_name'],
+                'revision': override['revision'],
+                'channel': override['channel'],
+                'series': override['series'],
+            }]))
         request = responses.calls[0].request
         self.assertThat(
             request.headers['Authorization'],
-            matchers.MacaroonHeaderVerifies(credentials.key))
+            matchers.MacaroonHeaderVerifies(self.config.key))
         self.assertEqual([{
             'snap_name': override['snap_name'],
             'revision': override['revision'],
@@ -221,22 +217,21 @@ class WebservicesTests(TestCase):
     @responses.activate
     def test_set_overrides_error(self):
         logger = self.useFixture(fixtures.FakeLogger())
-        self.useFixture(testfixtures.CredentialsFixture())
         override = factory.SnapDeviceGateway.Override()
         # XXX cjwatson 2017-06-26: Use acceptable-generated double once it
         # exists.
-        overrides_url = urljoin(
-            config.read_config()['services']['snapdevicegw'],
-            '/v2/metadata/overrides')
+        store = config.Config().store_section('default')
+        overrides_url = urljoin(store.get('gw_url'), '/v2/metadata/overrides')
         responses.add(
             'POST', overrides_url, status=400,
             json=factory.APIError.single('Something went wrong').to_dict())
 
-        self.assertRaises(HTTPError, webservices.set_overrides, {
-            'snap_name': override['snap_name'],
-            'revision': override['revision'],
-            'channel': override['channel'],
-            'series': override['series'],
-        })
+        self.assertRaises(HTTPError, lambda: webservices.set_overrides(
+            store, {
+                'snap_name': override['snap_name'],
+                'revision': override['revision'],
+                'channel': override['channel'],
+                'series': override['series'],
+            }))
         self.assertEqual(
             'Failed to set override:\nSomething went wrong\n', logger.output)
diff --git a/snapstore_client/tests/testfixtures.py b/snapstore_client/tests/testfixtures.py
index 5070d5a..78bf1dd 100644
--- a/snapstore_client/tests/testfixtures.py
+++ b/snapstore_client/tests/testfixtures.py
@@ -2,7 +2,6 @@
 
 import os.path
 from textwrap import dedent
-from urllib.parse import urlparse
 
 from fixtures import (
     Fixture,
@@ -11,23 +10,27 @@ from fixtures import (
 )
 from pymacaroons import Macaroon
 
-from snapstore_client import config
 
+class XDGConfigDirFixture(Fixture):
+    """Set up xdg to read/write config from temp dir."""
 
-class ConfigOverrideFixture(Fixture):
-
-    def __init__(self, new_config):
-        super().__init__()
-        self._new_config = new_config
+    path = None
 
     def _setUp(self):
-        self.addCleanup(config.read_config.override_for_test(self._new_config))
+        self.path = self.useFixture(TempDir()).path
+        self.useFixture(MonkeyPatch(
+            'xdg.BaseDirectory.xdg_config_home', self.path))
+        self.useFixture(MonkeyPatch(
+            'xdg.BaseDirectory.xdg_config_dirs', [self.path]))
 
 
-class CredentialsFixture(Fixture):
+class ConfigFixture(Fixture):
 
-    def __init__(self):
+    def __init__(self, empty=False):
         super().__init__()
+        self.empty = empty
+        self.gw_url = 'http://store.local/'
+        self.sso_url = 'http://sso.local/'
         self.key = 'random-key'
         self.root = Macaroon(key=self.key)
         self.root.add_third_party_caveat(
@@ -36,22 +39,20 @@ class CredentialsFixture(Fixture):
             location='login.example.com', identifier='payload', key='sso-key')
 
     def _setUp(self):
-        config_path = self.useFixture(TempDir()).path
-        credentials_path = os.path.join(
-            config_path, 'snapstore-client', 'credentials.cfg')
-        os.makedirs(os.path.dirname(credentials_path))
-        snapdevicegw_netloc = urlparse(
-            config.read_config()['services']['snapdevicegw']).netloc
-        with open(credentials_path, 'w') as credentials_file:
-            credentials = dedent("""\
-                [{snapdevicegw}]
+        xdg_config_path = self.useFixture(XDGConfigDirFixture()).path
+        app_config_path = os.path.join(xdg_config_path, 'snapstore-client')
+        os.makedirs(app_config_path)
+        if self.empty:
+            return
+        with open(os.path.join(app_config_path, 'config.ini'), 'w') as f:
+            f.write(dedent("""
+                [store:default]
+                gw_url = {gw_url}
+                sso_url = {sso_url}
                 root = {root}
                 unbound_discharge = {unbound_discharge}
-                """).format(
-                    snapdevicegw=snapdevicegw_netloc,
-                    root=self.root.serialize(),
-                    unbound_discharge=self.unbound_discharge.serialize(),
-                )
-            print(credentials, file=credentials_file)
-        self.useFixture(MonkeyPatch(
-            'xdg.BaseDirectory.xdg_config_dirs', [config_path]))
+            """).format(
+                gw_url=self.gw_url, sso_url=self.sso_url,
+                root=self.root.serialize(),
+                unbound_discharge=self.unbound_discharge.serialize(),
+            ))
diff --git a/snapstore_client/webservices.py b/snapstore_client/webservices.py
index fc8c460..fb1927a 100644
--- a/snapstore_client/webservices.py
+++ b/snapstore_client/webservices.py
@@ -8,20 +8,16 @@ import urllib.parse
 from pymacaroons import Macaroon
 import requests
 
-from snapstore_client import (
-    config,
-    exceptions,
-)
+from snapstore_client import exceptions
 
 
 logger = logging.getLogger(__name__)
 
 
-def issue_store_admin():
+def issue_store_admin(gw_url):
     """Ask the store to issue a store_admin macaroon."""
-    devicegw_root = config.read_config()['services']['snapdevicegw']
     issue_store_admin_url = urllib.parse.urljoin(
-        devicegw_root, '/v2/auth/issue-store-admin')
+        gw_url, '/v2/auth/issue-store-admin')
     resp = requests.post(issue_store_admin_url)
     if resp.status_code != 200:
         _print_error_message('issue store_admin macaroon', resp)
@@ -29,9 +25,10 @@ def issue_store_admin():
     return resp.json()['macaroon']
 
 
-def get_sso_discharge(email, password, caveat_id, one_time_password=None):
-    sso_root = config.read_config()['services']['sso']
-    discharge_url = urllib.parse.urljoin(sso_root, '/api/v2/tokens/discharge')
+def get_sso_discharge(sso_url, email, password, caveat_id,
+                      one_time_password=None):
+    discharge_url = urllib.parse.urljoin(
+        sso_url, '/api/v2/tokens/discharge')
     data = {'email': email, 'password': password, 'caveat_id': caveat_id}
     if one_time_password is not None:
         data['otp'] = one_time_password
@@ -56,9 +53,9 @@ def get_sso_discharge(email, password, caveat_id, one_time_password=None):
     return resp.json()['discharge_macaroon']
 
 
-def refresh_sso_discharge(unbound_discharge_raw):
-    sso_root = config.read_config()['services']['sso']
-    refresh_url = urllib.parse.urljoin(sso_root, '/api/v2/tokens/refresh')
+def refresh_sso_discharge(store, unbound_discharge_raw):
+    refresh_url = urllib.parse.urljoin(
+        store.get('sso_url'), '/api/v2/tokens/refresh')
     data = {'discharge_macaroon': unbound_discharge_raw}
     resp = requests.post(
         refresh_url, headers={'Accept': 'application/json'}, json=data)
@@ -78,12 +75,11 @@ def _deserialize_macaroon(name, value):
             'failed to deserialize {} macaroon'.format(name))
 
 
-def _get_macaroon_auth():
+def _get_macaroon_auth(store):
     """Return an Authorization header containing store macaroons."""
-    credentials = config.Credentials()
-    root_raw = credentials.get('root')
+    root_raw = store.get('root')
     root = _deserialize_macaroon('root', root_raw)
-    unbound_discharge_raw = credentials.get('unbound_discharge')
+    unbound_discharge_raw = store.get('unbound_discharge')
     unbound_discharge = _deserialize_macaroon(
         'unbound discharge', unbound_discharge_raw)
     bound_discharge = root.prepare_for_request(unbound_discharge)
@@ -99,27 +95,25 @@ def _raise_needs_refresh(response):
         raise exceptions.StoreMacaroonNeedsRefresh()
 
 
-def refresh_if_necessary(func, *args, **kwargs):
+def refresh_if_necessary(store, func, *args, **kwargs):
     """Make a request, refreshing macaroons if necessary."""
     try:
         return func(*args, **kwargs)
     except exceptions.StoreMacaroonNeedsRefresh:
-        credentials = config.Credentials()
         unbound_discharge = refresh_sso_discharge(
-            credentials.get('unbound_discharge'))
-        credentials.set('unbound_discharge', unbound_discharge)
-        credentials.save()
+            store.get('sso_url'), store.get('unbound_discharge'))
+        store.set('unbound_discharge', unbound_discharge)
+        store.save()
         return func(*args, **kwargs)
 
 
-def get_overrides(snap_name, series='16'):
+def get_overrides(store, snap_name, series='16'):
     """Get all overrides for a snap."""
-    devicegw_root = config.read_config()['services']['snapdevicegw']
     overrides_url = urllib.parse.urljoin(
-        devicegw_root,
+        store.get('gw_url'),
         '/v2/metadata/overrides/{}'.format(urllib.parse.quote_plus(snap_name)))
     headers = {
-        'Authorization': _get_macaroon_auth(),
+        'Authorization': _get_macaroon_auth(store),
         'X-Ubuntu-Series': series,
     }
     resp = requests.get(overrides_url, headers=headers)
@@ -130,12 +124,11 @@ def get_overrides(snap_name, series='16'):
     return resp.json()
 
 
-def set_overrides(overrides):
+def set_overrides(store, overrides):
     """Add or remove channel map overrides for a snap."""
-    devicegw_root = config.read_config()['services']['snapdevicegw']
     overrides_url = urllib.parse.urljoin(
-        devicegw_root, '/v2/metadata/overrides')
-    headers = {'Authorization': _get_macaroon_auth()}
+        store.get('gw_url'), '/v2/metadata/overrides')
+    headers = {'Authorization': _get_macaroon_auth(store)}
     resp = requests.post(overrides_url, headers=headers, json=overrides)
     _raise_needs_refresh(resp)
     if resp.status_code != 200: