Merge lp:~rharding/charmworld/proof-config-2 into lp:~juju-jitsu/charmworld/trunk

[Richard Harding]

Refactor the proof api code to make more usable.

Refactor the proof api code to make more usable.

https://codereview.appspot.com/15690049/

=== modified file 'charmworld/lib/proof.py'
--- charmworld/lib/proof.py	2013-10-18 18:32:48 +0000
+++ charmworld/lib/proof.py	2013-10-22 20:55:07 +0000
@@ -1,10 +1,4 @@
 """Helpers to proof charms and bundles."""
-import yaml
-
-from charmworld.models import (
-    BundledCharmDescription,
-    resolve_charm_from_description,
-)
 
 
 class ProofError(Exception):
@@ -14,33 +8,6 @@
         self.msg = msg
 
 
-class BundleProof(object):
-
-    @staticmethod
-    def check_parseable_deployer_file(data, format='yaml'):
-        try:
-            bundle_data = yaml.safe_load(data)
-        except yaml.YAMLError:
-            raise ProofError(
-                data,
-                'Could not parse the yaml provided.'
-            )
-        return bundle_data
-
-    @staticmethod
-    def check_service_exists(db, name, service_data, bundle_config):
-        charm_description = BundledCharmDescription(
-            'proof', service_data, bundle_config.get('series'))
-        charm_found = resolve_charm_from_description(db, charm_description)
-        if not charm_found:
-            raise ProofError(
-                charm_description.get_process(),
-                'Could not find charm: ' + name,
-            )
-        else:
-            return charm_found
-
-
 class CharmProof(object):
 
     @staticmethod
 
=== modified file 'charmworld/lib/tests/test_proof.py'
--- charmworld/lib/tests/test_proof.py	2013-10-18 18:57:16 +0000
+++ charmworld/lib/tests/test_proof.py	2013-10-22 20:55:07 +0000
@@ -1,11 +1,6 @@
-from mock import (
-    Mock,
-    patch,
-)
-import yaml
+from mock import Mock
 
 from charmworld.lib.proof import (
-    BundleProof,
     CharmProof,
     ProofError,
 )
@@ -13,71 +8,6 @@
 from charmworld.testing import TestCase
 
 
-class TestBundleProof(TestCase):
-    """Verify that a bundle can be proofed in charmworld."""
-
-    sample_deployer_file = """
-        {
-            "wiki": {
-                "services": {
-                    "wiki": {
-                        "charm": "mediawiki",
-                        "num_units": 2,
-                        "branch": "lp:charms/precise/mediawiki",
-                        "constraints": "mem=2"
-                    }
-                },
-                "series": "precise" }}"""
-
-    def test_check_parseable_yaml(self):
-        """A deployer file should be parseable as yaml."""
-
-        deployer_file = self.sample_deployer_file
-        result = BundleProof.check_parseable_deployer_file(deployer_file)
-        self.assertEqual(result['wiki']['services'].keys(), ['wiki'])
-
-    def test_failing_parsing_yaml_throws_proof_error(self):
-        """If the yaml is not parse the yaml thows a ProofError"""
-        deployer_file = '{'
-        with self.assertRaises(ProofError) as exc:
-            BundleProof.check_parseable_deployer_file(deployer_file)
-
-        self.assertEqual(
-            'Could not parse the yaml provided.',
-            exc.exception.msg
-        )
-        self.assertEqual(
-            deployer_file,
-            exc.exception.debug_info
-        )
-
-    @patch('charmworld.lib.proof.resolve_charm_from_description')
-    def test_service_not_found_raises_proof_error(self, resolver):
-        """If we cannot find a service specified it's a ProofError"""
-        resolver.return_value = None
-        deployer = yaml.load(self.sample_deployer_file)
-
-        with self.assertRaises(ProofError) as exc:
-            BundleProof.check_service_exists(
-                None,
-                'wiki',
-                deployer['wiki']['services']['wiki'],
-                deployer['wiki'])
-
-        self.assertEqual(
-            "Could not find charm: wiki",
-            exc.exception.msg
-        )
-        # We should have an array of logic behind the decision to look up the
-        # charm. Just check we've got some logic. This number might get
-        # tweaked, but we're just checking it made it to the exception, not
-        # what the reasons are.
-        self.assertEqual(
-            4,
-            len(exc.exception.debug_info)
-        )
-
-
 class TestCharmProof(TestCase):
 
     def make_fake_charm_config(self, options):
@@ -130,7 +60,7 @@
         )
 
     def test_check_config_fails_when_option_does_not_exist(self):
-        """Bundles might attempt to set config values that are not valid"""
+        """Bundles might attempt to set config values that do not exist"""
         charm = Mock()
         charm.options = {'foo': {}}
         charm._id = 'precise/test'
 
=== modified file 'charmworld/models.py'
--- charmworld/models.py	2013-10-15 16:18:49 +0000
+++ charmworld/models.py	2013-10-22 20:55:07 +0000
@@ -19,6 +19,7 @@
 import random
 import re
 from xml.etree import ElementTree
+import yaml
 
 from bzrlib.branch import Branch
 from bzrlib.errors import NoSuchRevision
@@ -27,6 +28,7 @@
 import magic
 import pymongo
 
+from charmworld.lib.proof import ProofError
 from charmworld.lp import BASKET_SERIES
 from charmworld.utils import (
     configure_logging,
@@ -1444,6 +1446,21 @@
         return hashes.keys()
 
 
+class DeployerParser(object):
+
+    def __init__(self, data, format="yaml"):
+        try:
+            self.parsed = yaml.safe_load(data)
+        except yaml.YAMLError, exc:
+            raise ProofError(
+                [
+                    data,
+                    str(exc)
+                ],
+                'Could not parse the yaml provided.'
+            )
+
+
 def acquire_session_secret(database):
     """Return a secret to use for AuthTkt sessions.
 
@@ -1528,7 +1545,6 @@
         In the deployer, the charm key is given precedence. So we try to
         mimic that by only using the charm_url if charm is not defined.
         """
-        #
         if not charm and charm_url:
             charm = charm_url
 
 
=== modified file 'charmworld/tests/test_models.py'
--- charmworld/tests/test_models.py	2013-10-15 16:18:49 +0000
+++ charmworld/tests/test_models.py	2013-10-22 20:55:07 +0000
@@ -25,6 +25,7 @@
 import pymongo
 import yaml
 
+from charmworld.lib.proof import ProofError
 from charmworld.models import (
     acquire_session_secret,
     Bundle,
@@ -34,6 +35,7 @@
     CharmFileSet,
     CharmSource,
     construct_charm_id,
+    DeployerParser,
     FeaturedSource,
     find_charms,
     _find_charms,
@@ -1999,6 +2001,43 @@
         self.assertIsNone(description.revision)
 
 
+class TestDeployerParser(TestCase):
+
+    sample_deployer_file = """
+        {
+            "wiki": {
+                "services": {
+                    "wiki": {
+                        "charm": "mediawiki",
+                        "num_units": 2,
+                        "branch": "lp:charms/precise/mediawiki",
+                        "constraints": "mem=2"
+                    }
+                },
+                "series": "precise" }}"""
+
+    def test_parses_valid_yaml_file(self):
+        """A deployer file should be parseable as yaml."""
+        deployer_file = self.sample_deployer_file
+        deployer = DeployerParser(deployer_file)
+        self.assertEqual(deployer.parsed['wiki']['services'].keys(), ['wiki'])
+
+    def test_failing_parsing_yaml_throws_proof_error(self):
+        """If the yaml is not parse the yaml thows a ProofError"""
+        deployer_file = '{'
+        with self.assertRaises(ProofError) as exc:
+            DeployerParser(deployer_file)
+
+        self.assertEqual(
+            'Could not parse the yaml provided.',
+            exc.exception.msg
+        )
+        self.assertEqual(
+            deployer_file,
+            exc.exception.debug_info[0]
+        )
+
+
 class TestMakeBundleDoc(TestCase):
 
     def test_bundle_doc(self):
 
=== added directory 'charmworld/views/api'
=== renamed file 'charmworld/views/api.py' => 'charmworld/views/api/__init__.py'
--- charmworld/views/api.py	2013-10-22 00:33:12 +0000
+++ charmworld/views/api/__init__.py	2013-10-22 20:55:07 +0000
@@ -6,7 +6,6 @@
 )
 from email.utils import parseaddr
 from inspect import getargspec
-import json
 from os.path import (
     join,
 )
@@ -22,11 +21,7 @@
 from pyramid.view import view_config
 from webob import Response
 
-from charmworld.lib.proof import (
-    BundleProof,
-    CharmProof,
-    ProofError,
-)
+
 from charmworld.models import (
     Bundle,
     BundledCharmDescription,
@@ -47,37 +42,8 @@
     quote_key,
     timestamp,
 )
-
-
-def json_response(status, value, headers=[]):
-    """Return a JSON API response.
-
-    :param status: The HTTP status code to use.
-    :param value: A json-serializable value to use as the body, or None for
-        no body.
-    """
-    # If the value is an object, then it must be representable as a mapping.
-    if value is None:
-        body = ''
-    else:
-        while True:
-            try:
-                body = json.dumps(value, sort_keys=True, indent=2)
-            except TypeError:
-                # If the serialization wasn't possible, and the value wasn't
-                # already a dictionary, convert it to one and try again.
-                if not isinstance(value, dict):
-                    value = dict(value)
-                    continue
-            break
-
-    return Response(body,
-                    headerlist=[
-                        ('Content-Type', 'application/json'),
-                        ('Access-Control-Allow-Origin', '*'),
-                        ('Access-Control-Allow-Headers', 'X-Requested-With'),
-                    ] + headers,
-                    status_code=status)
+from charmworld.views.api.proof import proof_deployer
+from charmworld.views.utils import json_response
 
 
 @view_config(route_name="search-json-obsolete")
@@ -494,100 +460,6 @@
             bundle = Bundle.from_query(query, self.request.db)
         return bundle_id, trailing, bundle
 
-    def _proof_bundle(self, request):
-        """Check the bundle provided for proof errors."""
-        # The top level is for general deployer file errors.
-        response_data = {
-            'errors': [],
-            'error_messages': [],
-            'debug_info': [],
-        }
-        bundle_string = request.params.get('deployer_file')
-        bundle_format = request.params.get('bundle_format', 'yaml')
-        bundle_data = None
-
-        if not bundle_string:
-            response_data['error_messages'].append(
-                'No deployer file data received.')
-            return json_response(400, response_data)
-
-        try:
-            bundle_data = BundleProof.check_parseable_deployer_file(
-                bundle_string,
-                format=bundle_format)
-        except ProofError, exc:
-            # If we cannot parse the config file there's nothing more to do.
-            # Return immediately.
-            response_data['error_messages'].append(exc.msg)
-            response_data['debug_info'].append(exc.debug_info)
-            return json_response(400, response_data)
-
-        # Proof each bundle in the deployer file.
-        for bundle_name, bundle_config in bundle_data.items():
-            bundle_info = {
-                'name': bundle_name,
-                'services': {},
-                'relations': {},
-            }
-            found_charms = {}
-
-            # Verify we can find the charms at all.
-            for name, charm in bundle_config.get('services').items():
-                try:
-                    charm_found = BundleProof.check_service_exists(
-                        self.request.db, name, charm, bundle_config)
-                    found_charms[name] = Charm(charm_found)
-                except ProofError, exc:
-                    # We could not find the charm. No other verification can
-                    # happen.
-                    bundle_info['services'][name] = []
-                    bundle_info['services'][name].append({
-                        'message': exc.msg,
-                        'debug_info': exc.debug_info,
-                    })
-
-            # For the charms we did find in the system, verify that their
-            # config is valid for the values allowed by the charm we found.
-            for name, charm in found_charms.iteritems():
-                check_config = bundle_config['services'][name].get('options')
-                if not check_config:
-                    # There's no config specified to validate.
-                    continue
-                for test_key, test_value in check_config.iteritems():
-                    try:
-                        CharmProof.check_config(charm, test_key, test_value)
-                    except ProofError, exc:
-                        if name not in bundle_info['services']:
-                            bundle_info['services'][name] = []
-
-                        bundle_info['services'][name].append({
-                            'message': exc.msg,
-                            'debug_info': exc.debug_info,
-                        })
-
-            # If there are errors in this bundles services, make sure we
-            # append the info to the response data that gets sent back to the
-            # user.
-            if bundle_info['services'].keys():
-                response_data['errors'].append(bundle_info)
-
-        # Build up a root messages list of errors that can be used to help the
-        # client go through them all easily.
-        error_messages = []
-        if response_data['errors']:
-            for bundle in response_data['errors']:
-                prefix = bundle['name']
-                for service_name, service in bundle['services'].items():
-                    for err in service:
-                        msg = '%s: %s' % (prefix, err['message'])
-                        error_messages.append(msg)
-        if error_messages:
-            response_data['error_messages'].extend(error_messages)
-
-        # After proofing each deployer file return with any failure info
-        # found.
-        return json_response(200, response_data)
-
     def charm(self, path=None):
         """Retrieve a charm according to its API ID (the path prefix)."""
         if path is None:
@@ -634,7 +506,7 @@
         path = list(path)
 
         if path[0] == 'proof':
-            return self._proof_bundle(self.request)
+            return proof_deployer(self.request)
 
         bundle_id, trailing, bundle = self._find_bundle(path)
 
 
=== added file 'charmworld/views/api/proof.py'
--- charmworld/views/api/proof.py	1970-01-01 00:00:00 +0000
+++ charmworld/views/api/proof.py	2013-10-22 20:55:07 +0000
@@ -0,0 +1,145 @@
+from charmworld.lib.proof import (
+    CharmProof,
+    ProofError,
+)
+from charmworld.models import (
+    BundledCharmDescription,
+    DeployerParser,
+    Charm,
+    resolve_charm_from_description,
+)
+from charmworld.views.utils import json_response
+
+
+def _build_proof_response(response_data):
+    # Build up a root messages list of errors that can be used to help the
+    # client go through them all easily.
+    error_messages = []
+    if response_data['errors']:
+        for bundle in response_data['errors']:
+            prefix = bundle['name']
+            for service_name, service in bundle['services'].items():
+                for err in service:
+                    msg = '%s: %s' % (prefix, err['message'])
+                    error_messages.append(msg)
+    if error_messages:
+        response_data['error_messages'].extend(error_messages)
+    return response_data
+
+
+def _proof_bundles_charms_exist(db, bundle_info, services, series=None):
+    """Verify the charms the bundle requests to deploy exist in the db."""
+    found_charms = {}
+
+    # Verify we can find the charms at all.
+    for name, charm in services.items():
+        try:
+            charm_description = BundledCharmDescription(
+                'proof', charm, series)
+            charm_found = resolve_charm_from_description(
+                db, charm_description)
+            if not charm_found:
+                raise ProofError(
+                    charm_description.get_process(),
+                    'Could not find charm: ' + name,
+                )
+            else:
+                found_charms[name] = Charm(charm_found)
+        except ProofError, exc:
+            # We could not find the charm. No other verification can
+            # happen.
+            bundle_info['services'][name] = []
+            bundle_info['services'][name].append({
+                'message': exc.msg,
+                'debug_info': exc.debug_info,
+            })
+    return found_charms, bundle_info
+
+
+def _proof_charm_config(bundle_info, bundle_config, charm_name, charm):
+    """Given a charm, proof the config is valid for the charm found.
+
+    If the deployer attempts to set illegal or non-existant config values to
+    the charm treat these as proof errors.
+    """
+    check_config = bundle_config['services'][charm_name].get('options')
+    if not check_config:
+        # There's no config specified to validate.
+        return bundle_info
+    for test_key, test_value in check_config.iteritems():
+        try:
+            CharmProof.check_config(charm, test_key, test_value)
+        except ProofError, exc:
+            if charm_name not in bundle_info['services']:
+                bundle_info['services'][charm_name] = []
+
+            bundle_info['services'][charm_name].append({
+                'message': exc.msg,
+                'debug_info': exc.debug_info,
+            })
+    return bundle_info
+
+
+def proof_deployer(request):
+    """Check the bundle provided for proof errors."""
+    # The top level is for general deployer file errors.
+    # The errors here may be an error about the deployer file itself, or an
+    # object that describes the issues found with a bundle within the deployer
+    # file. errro_messages is added as a simple aggregate of all of the error
+    # messages found to make life easier for the proof cli tool.
+    response_data = {
+        'errors': [],
+        'error_messages': [],
+        'debug_info': [],
+    }
+    deployer_string = request.params.get('deployer_file')
+    deployer_format = request.params.get('deployer_format', 'yaml')
+
+    # Verify we have a valid deployer file that we can find and parse.
+    if not deployer_string:
+        response_data['error_messages'].append(
+            'No deployer file data received.')
+        return json_response(400, response_data)
+
+    try:
+        deployer = DeployerParser(deployer_string, format=deployer_format)
+        deployer_data = deployer.parsed
+    except ProofError, exc:
+        # If we cannot parse the config file there's nothing more to do.
+        # Return immediately.
+        response_data['error_messages'].append(exc.msg)
+        response_data['debug_info'].append(exc.debug_info)
+        return json_response(400, response_data)
+
+    # Proof each bundle found in the deployer file.
+    for bundle_name, bundle_config in deployer_data.items():
+        # Track all of the issues found in this info dict.
+        bundle_info = {
+            'name': bundle_name,
+            'services': {},
+            'relations': {},
+        }
+
+        # First, verify that we can locate the charms specified in this bundle
+        # in the charmworld database.
+        found_charms, bundle_info = _proof_bundles_charms_exist(
+            request.db,
+            bundle_info,
+            bundle_config.get('services'),
+            bundle_config.get('series'))
+
+        # For the charms we did find in the system, verify that their
+        # config is valid for the values allowed by the charm we found.
+        for name, charm in found_charms.iteritems():
+            bundle_info = _proof_charm_config(
+                bundle_info, bundle_config, name, charm)
+
+        # If there are errors in this bundles services, make sure we
+        # append the info to the response data that gets sent back to the
+        # user.
+        if bundle_info['services'].keys():
+            response_data['errors'].append(bundle_info)
+
+    # After proofing each deployer file return with any failure info
+    # found.
+    return json_response(200, _build_proof_response(response_data))
 
=== modified file 'charmworld/views/tests/test_api.py'
--- charmworld/views/tests/test_api.py	2013-10-22 00:55:23 +0000
+++ charmworld/views/tests/test_api.py	2013-10-22 20:55:07 +0000
@@ -9,7 +9,6 @@
 )
 import hashlib
 import json
-import yaml
 
 from mock import patch
 
@@ -41,11 +40,11 @@
 )
 from charmworld.testing import factory
 from charmworld.testing import (
-    load_data_file,
     ViewTestBase,
     WebTestBase,
 )
 from charmworld.utils import quote_key
+from charmworld.views.tests.test_proof import TestBundleProof
 
 
 class TestObsoletedApis(WebTestBase):
@@ -868,176 +867,12 @@
         self.assertEqual(302, response.status_code)
         self.assertEqual('/static/img/bundle.svg', response.location)
 
-    def test_bundle_proof_no_deployer_file(self):
-        request = self.make_request('bundle', remainder='/proof')
-        response = self.api_class(request)()
-        self.assertEqual(400, response.status_code)
-        self.assertEqual(
-            'No deployer file data received.',
-            response.json_body['error_messages'][0])
-
-    def test_bundle_proof_invalid_deployer_file(self):
-        request = self.make_request('bundle', remainder='/proof')
-        request.params = {
-            'deployer_file': '{'
-        }
-        response = self.api_class(request)()
-        self.assertEqual(400, response.status_code)
-        self.assertIn(
-            'Could not parse',
-            response.json_body['error_messages'][0])
-
-    def test_bundle_proof_charm_exists(self):
-        deployer_file = load_data_file('sample_bundle/bundles.yaml')
-
-        request = self.make_request('bundle', remainder='/proof')
-        request.params = {
-            'deployer_file': deployer_file
-        }
-
-        response = self.api_class(request)()
-        self.assertEqual(200, response.status_code)
-        results = response.json_body
-        self.assertEqual(1, len(results['errors']))
-        self.assertEqual(4, len(results['errors'][0]['services'].keys()))
-        self.assertIn(
-            'Could not find ',
-            results['errors'][0]['services']['db'][0]['message'])
-
-        # And each failure has a list of 'process' information.
-        self.assertIn(
-            'debug_info',
-            results['errors'][0]['services']['db'][0].keys())
-
-    def test_bundle_proof_valid(self):
-        # We have to create the charm so that we can verify it exists.
-        _id, charm = factory.makeCharm(
-            self.db,
-            description=''
-        )
-
-        # and we'll cheat and just find it straight by the store url.
-        charm = Charm(charm)
-        store_url = charm.store_url
-
-        bundle_config = {
-            'wiki': {
-                'services': {
-                    'charm': {
-                        'charm_url': str(store_url)
-                    }
-                }
-            }
-        }
-
-        request = self.make_request('bundle', remainder='/proof')
-        request.params = {
-            'deployer_file': yaml.dump(bundle_config)
-        }
-        response = self.api_class(request)()
-        self.assertEqual(200, response.status_code)
-        results = response.json_body
-        self.assertEqual(0, len(results['errors']))
-
-    def test_bundle_proof_invalid_config_type(self):
-        # We have to create the charm so that we can verify it exists.
-        _id, charm = factory.makeCharm(
-            self.db,
-            description=''
-        )
-
-        # and we'll cheat and just find it straight by the store url.
-        charm = Charm(charm)
-        store_url = charm.store_url
-
-        bundle_config = {
-            'wiki': {
-                'services': {
-                    'charm': {
-                        'charm_url': str(store_url),
-                        'options': {
-                            'script-interval': 'invalid'
-                        }
-                    }
-                }
-            }
-        }
-
-        request = self.make_request('bundle', remainder='/proof')
-        request.params = {
-            'deployer_file': yaml.dump(bundle_config)
-        }
-        response = self.api_class(request)()
-        self.assertEqual(200, response.status_code)
-        results = response.json_body
-        self.assertEqual(1, len(results['errors']))
-        self.assertEqual(1, len(results['error_messages']))
-
-        # Note that the View will prefix the error message from the proof with
-        # the bundle name to help identify where the error message came from.
-        self.assertEqual(
-            'wiki: script-interval is not of type int.',
-            results['error_messages'][0]
-        )
-
-    def test_bundle_proof_supports_multiple_errors(self):
-        _id, charm = factory.makeCharm(
-            self.db,
-            description=''
-        )
-
-        # and we'll cheat and just find it straight by the store url.
-        charm = Charm(charm)
-        store_url = charm.store_url
-
-        bundle_config = {
-            'wiki': {
-                'services': {
-                    'charm': {
-                        'charm_url': str(store_url),
-                        'options': {
-                            'script-interval': 'invalid',
-                            'no-exist': 'hah invalid',
-                        }
-                    },
-                    'fail': {
-                        'name': 'will-fail'
-                    }
-                }
-            }
-        }
-
-        request = self.make_request('bundle', remainder='/proof')
-        request.params = {
-            'deployer_file': yaml.dump(bundle_config)
-        }
-        response = self.api_class(request)()
-        self.assertEqual(200, response.status_code)
-        results = response.json_body
-        self.assertEqual(1, len(results['errors']))
-        self.assertEqual(3, len(results['error_messages']))
-
-        # One message from not finding a charm.
-        self.assertEqual(
-            'wiki: Could not find charm: fail',
-            results['error_messages'][0]
-        )
-        # The other two from checking the config of the other charm.
-        self.assertEqual(
-            'wiki: script-interval is not of type int.',
-            results['error_messages'][1]
-        )
-        self.assertEqual(
-            'wiki: The charm has no option for: no-exist',
-            results['error_messages'][2]
-        )
-
-
-class TestAPI3Bundles(TestAPIBundles, API3Mixin):
+
+class TestAPI3Bundles(TestAPIBundles, API3Mixin, TestBundleProof):
     """Test API 3 bundle endpoint."""
 
 
-class TestAPI2Bundles(TestAPIBundles, API2Mixin):
+class TestAPI2Bundles(TestAPIBundles, API2Mixin, TestBundleProof):
     """Test API 2 bundle endpoint."""
 
 
 
=== added file 'charmworld/views/tests/test_proof.py'
--- charmworld/views/tests/test_proof.py	1970-01-01 00:00:00 +0000
+++ charmworld/views/tests/test_proof.py	2013-10-22 20:55:07 +0000
@@ -0,0 +1,175 @@
+import yaml
+
+from charmworld.models import Charm
+from charmworld.testing import (
+    factory,
+    load_data_file,
+)
+
+
+class TestBundleProof:
+    """Verify that a bundle can be proofed in charmworld."""
+
+    def test_bundle_proof_no_deployer_file(self):
+        request = self.make_request('bundle', remainder='/proof')
+        response = self.api_class(request)()
+        self.assertEqual(400, response.status_code)
+        self.assertEqual(
+            'No deployer file data received.',
+            response.json_body['error_messages'][0])
+
+    def test_bundle_proof_invalid_deployer_file(self):
+        request = self.make_request('bundle', remainder='/proof')
+        request.params = {
+            'deployer_file': '{'
+        }
+        response = self.api_class(request)()
+        self.assertEqual(400, response.status_code)
+        self.assertIn(
+            'Could not parse',
+            response.json_body['error_messages'][0])
+
+    def test_bundle_proof_charm_exists(self):
+        deployer_file = load_data_file('sample_bundle/bundles.yaml')
+
+        request = self.make_request('bundle', remainder='/proof')
+        request.params = {
+            'deployer_file': deployer_file
+        }
+
+        response = self.api_class(request)()
+        self.assertEqual(200, response.status_code)
+        results = response.json_body
+        self.assertEqual(1, len(results['errors']))
+        self.assertEqual(4, len(results['errors'][0]['services'].keys()))
+        self.assertIn(
+            'Could not find ',
+            results['errors'][0]['services']['db'][0]['message'])
+
+        # And each failure has a list of 'process' information.
+        self.assertIn(
+            'debug_info',
+            results['errors'][0]['services']['db'][0].keys())
+
+    def test_bundle_proof_valid(self):
+        # We have to create the charm so that we can verify it exists.
+        _id, charm = factory.makeCharm(
+            self.db,
+            description=''
+        )
+
+        # and we'll cheat and just find it straight by the store url.
+        charm = Charm(charm)
+        store_url = charm.store_url
+
+        bundle_config = {
+            'wiki': {
+                'services': {
+                    'charm': {
+                        'charm_url': str(store_url)
+                    }
+                }
+            }
+        }
+
+        request = self.make_request('bundle', remainder='/proof')
+        request.params = {
+            'deployer_file': yaml.dump(bundle_config)
+        }
+        response = self.api_class(request)()
+        self.assertEqual(200, response.status_code)
+        results = response.json_body
+        self.assertEqual(0, len(results['errors']))
+
+    def test_bundle_proof_invalid_config_type(self):
+        # We have to create the charm so that we can verify it exists.
+        _id, charm = factory.makeCharm(
+            self.db,
+            description=''
+        )
+
+        # and we'll cheat and just find it straight by the store url.
+        charm = Charm(charm)
+        store_url = charm.store_url
+
+        bundle_config = {
+            'wiki': {
+                'services': {
+                    'charm': {
+                        'charm_url': str(store_url),
+                        'options': {
+                            'script-interval': 'invalid'
+                        }
+                    }
+                }
+            }
+        }
+
+        request = self.make_request('bundle', remainder='/proof')
+        request.params = {
+            'deployer_file': yaml.dump(bundle_config)
+        }
+        response = self.api_class(request)()
+        self.assertEqual(200, response.status_code)
+        results = response.json_body
+        self.assertEqual(1, len(results['errors']))
+        self.assertEqual(1, len(results['error_messages']))
+
+        # Note that the View will prefix the error message from the proof with
+        # the bundle name to help identify where the error message came from.
+        self.assertEqual(
+            'wiki: script-interval is not of type int.',
+            results['error_messages'][0]
+        )
+
+    def test_bundle_proof_supports_multiple_errors(self):
+        _id, charm = factory.makeCharm(
+            self.db,
+            description=''
+        )
+
+        # and we'll cheat and just find it straight by the store url.
+        charm = Charm(charm)
+        store_url = charm.store_url
+
+        bundle_config = {
+            'wiki': {
+                'services': {
+                    'charm': {
+                        'charm_url': str(store_url),
+                        'options': {
+                            'script-interval': 'invalid',
+                            'no-exist': 'hah invalid',
+                        }
+                    },
+                    'fail': {
+                        'name': 'will-fail'
+                    }
+                }
+            }
+        }
+
+        request = self.make_request('bundle', remainder='/proof')
+        request.params = {
+            'deployer_file': yaml.dump(bundle_config)
+        }
+        response = self.api_class(request)()
+        self.assertEqual(200, response.status_code)
+        results = response.json_body
+        self.assertEqual(1, len(results['errors']))
+        self.assertEqual(3, len(results['error_messages']))
+
+        # One message from not finding a charm.
+        self.assertEqual(
+            'wiki: Could not find charm: fail',
+            results['error_messages'][0]
+        )
+        # The other two from checking the config of the other charm.
+        self.assertEqual(
+            'wiki: script-interval is not of type int.',
+            results['error_messages'][1]
+        )
+        self.assertEqual(
+            'wiki: The charm has no option for: no-exist',
+            results['error_messages'][2]
+        )
 
=== added file 'charmworld/views/utils.py'
--- charmworld/views/utils.py	1970-01-01 00:00:00 +0000
+++ charmworld/views/utils.py	2013-10-22 20:55:07 +0000
@@ -0,0 +1,33 @@
+import json
+from webob import Response
+
+
+def json_response(status, value, headers=[]):
+    """Return a JSON API response.
+
+    :param status: The HTTP status code to use.
+    :param value: A json-serializable value to use as the body, or None for
+        no body.
+    """
+    # If the value is an object, then it must be representable as a mapping.
+    if value is None:
+        body = ''
+    else:
+        while True:
+            try:
+                body = json.dumps(value, sort_keys=True, indent=2)
+            except TypeError:
+                # If the serialization wasn't possible, and the value wasn't
+                # already a dictionary, convert it to one and try again.
+                if not isinstance(value, dict):
+                    value = dict(value)
+                    continue
+            break
+
+    return Response(body,
+                    headerlist=[
+                        ('Content-Type', 'application/json'),
+                        ('Access-Control-Allow-Origin', '*'),
+                        ('Access-Control-Allow-Headers', 'X-Requested-With'),
+                    ] + headers,
+                    status_code=status)