Merge lp:~leonardr/lazr.restful/must-specify-version into lp:lazr.restful

[Leonard Richardson]

This is the first in a series of branches that will let us be much stricter about how the multi-version Launchpad web service is defined. Basically, we will set 'require_explicit_versions' in our web service configuration. This will make it impossible to publish an entry, a collection, a field, or a named operation without explicitly specifying in which version of the web service it first appears.

This first branch implements require_explicit_versions for the fields of entries. Basically, if require_explicit_versions is set, these common calls to exported() will give an error:

field = exported(Field())
field = exported(Field(), exported_as='a_field')
field = exported(Field(), ('2.0', exported_as='a_field'))

You must explicitly state which version is the first to contain this field, by using the 'as_of' keyword argument to exported():

field = exported(Field(), as_of='2.0')
field = exported(Field(), exported_as='a_field', as_of='beta')
field = exported(Field(), ('2.0', exported_as='a_field'), as_of='1.0')

= Effect on keyword arguments to exported() =

Previously, the keyword arguments such as 'as' affected the first version of the web service. We don't know the name of this version when exported() is called, because the IWebServiceConfiguration (which contains that information) hasn't been registered yet.

With 'as_of' in place, keyword arguments such as 'as' affect the first _published_ version of the web service, and we do know the name of that version--it's the value of 'as_of'. This lets us skip a confusing consolidation step later on, when we have both an implicit and an explicit definition of the web service.

The code for the consolidation step has been refactored to make it clearer (because I originally thought I'd have to use it), but its functionality should not have changed. I left the clearer code in place because, well, it's clearer.

= Test case refactoring =

A big chunk of code is me refactoring some (but not all) web service setup from WebServiceTestCase into the new class TestCaseWithWebServiceFixtures. This is useful in unit tests that need to test how web service interfaces and adapters are generated, but that don't need to actually set up a running web service.

I used this class in my new TestRequireExplicitVersions class, and changed the existing ContributingInterfacesTestCase to subclass this class instead of doing its own setup. This in turn required changing those tests to use the versions '1.0' and '2.0' (the ones defined by TestCaseWithWebServiceFixtures) instead of 'beta' and '1.0'.

As noted in the code, I couldn't get testtools.TestCase to play nicely with zope's Cleanup class, so I ended up writing a little helper to simulate testtools' version of assertRaises (which returns the raised exception so you can make more assertions about it).

[Aaron Bentley (abentley)]

I still think it would be nicer to allow a default to be provided for exported_as, per our IRC discussion, but it's not a deal-breaker.

There are some extra blank lines at 669 and 679, and it would be nice to document every test.

review: Approve

=== modified file 'src/lazr/restful/declarations.py'
--- src/lazr/restful/declarations.py	2011-03-02 20:08:58 +0000
+++ src/lazr/restful/declarations.py	2011-03-09 16:02:29 +0000
@@ -212,17 +212,14 @@
         The dictionary may contain the key 'exported', which controls
         whether or not to publish this field at all in the given
         version, and the key 'exported_as', which controls the name to
-        use when publishing the field. as=None means to use the
-        field's internal name.
+        use when publishing the field. exported_as=None means to use
+        the field's internal name.
+
+    :param as_of: The name of the earliest version to contain this field.
 
     :param exported_as: the name under which the field is published in
-        the entry in the earliest version of the web service. By
-        default, the field's internal name is used. This is a simpler
-        alternative to the 'versioned_annotations' parameter, for fields
-        whose names don't change in different versions.
-
-    :param exported: Whether or not the field should be published in
-        the earliest version of the web service.
+        the entry the first time it shows up (ie. in the 'as_of'
+        version). By default, the field's internal name is used.
 
     :raises TypeError: if called on an object which doesn't provide IField.
     :returns: The field with an added tagged value.
@@ -233,24 +230,37 @@
     if IObject.providedBy(field) and not IReference.providedBy(field):
         raise TypeError("Object exported; use Reference instead.")
 
-    # The first step is to turn the arguments into a
-    # VersionedDict. We'll start by collecting annotations for the
-    # earliest version, which we refer to as None because we don't
-    # know any of the real version strings yet.
+    # The first step is to turn the arguments into a VersionedDict
+    # describing the different ways this field is exposed in different
+    # versions.
     annotation_stack = VersionedDict()
-    annotation_stack.push(None)
+    first_version_name = kwparams.pop('as_of', None)
+    annotation_stack.push(first_version_name)
     annotation_stack['type'] = FIELD_TYPE
 
+    if first_version_name is not None:
+        # The user explicitly said to start publishing this field in a
+        # particular version.
+        annotation_stack['_as_of_was_used'] = True
+        annotation_stack['exported'] = True
+
     annotation_key_for_argument_key = {'exported_as' : 'as',
                                        'exported' : 'exported',
                                        'readonly' : 'readonly'}
 
     # If keyword parameters are present, they define the field's
-    # behavior for the first version. Incorporate them into the
-    # VersionedDict.
+    # behavior for the first exposed version. Incorporate them into
+    # the VersionedDict.
     for (key, annotation_key) in annotation_key_for_argument_key.items():
         if key in kwparams:
+            if (key == "exported" and kwparams[key] == False
+                and first_version_name is not None):
+                raise ValueError(
+                    ("as_of=%s says to export %s, but exported=False "
+                     "says not to.") % (
+                        first_version_name, field.__class__.__name__))
             annotation_stack[annotation_key] = kwparams.pop(key)
+
     # If any keywords are left over, raise an exception.
     if len(kwparams) > 0:
         raise TypeError("exported got an unexpected keyword "
@@ -275,7 +285,7 @@
     # We track the field's mutator information separately because it's
     # defined in the named operations, not in the fields. The last
     # thing we want to do is try to insert a foreign value into an
-    # already create annotation stack.
+    # already created annotation stack.
     field.setTaggedValue(LAZR_WEBSERVICE_MUTATORS, {})
 
     return field
@@ -1320,27 +1330,37 @@
     versioned_dict = field.queryTaggedValue(LAZR_WEBSERVICE_EXPORTED)
     mutator_annotations = field.queryTaggedValue(LAZR_WEBSERVICE_MUTATORS)
 
-    # If the first version is None and the second version is the
-    # earliest version, consolidate the two versions.
     earliest_version = versions[0]
     stack = versioned_dict.stack
 
-    if (len(stack) >= 2
-        and stack[0][0] is None and stack[1][0] == earliest_version):
-
-        # Make sure the implicit definition of the earliest version
-        # doesn't conflict with the explicit definition. The only
-        # exception is the 'as' value, which is implicitly defined
-        # by the system, not explicitly by the user.
-        for key, value in stack[1][1].items():
-            implicit_value = stack[0][1].get(key)
-            if (implicit_value != value and
-                not (key == 'as' and implicit_value == field.__name__)):
-                raise ValueError(
-                    error_prefix + 'Annotation "%s" has conflicting values '
-                    'for the earliest version: "%s" (from keyword arguments) '
-                    'and "%s" (defined explicitly).' % (
-                        key, implicit_value, value))
+    if (len(stack) >= 2 and stack[0][0] is None
+        and stack[1][0] == earliest_version):
+        # The behavior of the earliest version is defined with keyword
+        # arguments, but the first explicitly-defined version also
+        # refers to the earliest version. We need to consolidate the
+        # versions.
+        implicit_earliest_version = stack[0][1]
+        explicit_earliest_version = stack[1][1]
+        for key, value in explicit_earliest_version.items():
+            if key not in implicit_earliest_version:
+                # This key was defined for the earliest version using a
+                # configuration dictionary, but not defined at all
+                # using keyword arguments.  The configuration
+                # dictionary takes precedence.
+                continue
+            implicit_value = implicit_earliest_version[key]
+            if implicit_value == value:
+                # The two values are in sync.
+                continue
+            if key == 'as' and implicit_value == field.__name__:
+                # The implicit value was set by the system, not by the
+                # user. The later value will simply take precedence.
+                continue
+            raise ValueError(
+                error_prefix + 'Annotation "%s" has conflicting values '
+                'for the earliest version: "%s" (from keyword arguments) '
+                'and "%s" (defined explicitly).' % (
+                    key, implicit_value, value))
         stack[0][1].update(stack[1][1])
         stack.remove(stack[1])
 
@@ -1349,6 +1369,19 @@
     if stack[0][0] is None:
         stack[0] = (earliest_version, stack[0][1])
 
+    # If require_explicit_versions is set, make sure the first version
+    # to set 'exported' also sets '_as_of_was_used'.
+    if getUtility(IWebServiceConfiguration).require_explicit_versions:
+        for version, annotations in stack:
+            if annotations.get('exported', False):
+                if not annotations.get('_as_of_was_used', False):
+                    raise ValueError(
+                        error_prefix + (
+                            "Field was exported in version %s, but not"
+                            " by using as_of. The service configuration"
+                            " requires that you use as_of." % version))
+                break
+
     # Make sure there is at most one mutator for the earliest version.
     # If there is one, move it from the mutator-specific dictionary to
     # the normal tag stack.
@@ -1386,8 +1419,8 @@
     if stack[0][0] == earliest_version:
         new_stack = [stack[0]]
     else:
-        # The field is not initially published.
-        new_stack = (earliest_version, dict(published=False))
+        # The field is not initially exported.
+        new_stack = [(earliest_version, dict(exported=False))]
     most_recent_tags = new_stack[0][1]
     most_recent_mutator_tags = earliest_mutator
     for version in versions[1:]:
 
=== modified file 'src/lazr/restful/docs/webservice-declarations.txt'
--- src/lazr/restful/docs/webservice-declarations.txt	2011-02-16 15:41:04 +0000
+++ src/lazr/restful/docs/webservice-declarations.txt	2011-03-09 16:02:29 +0000
@@ -847,6 +847,55 @@
 Generating the webservice
 =========================
 
+Setup
+-----
+
+Before we can continue, we must define a web service configuration
+object. Each web service needs to have one of these registered
+utilities providing basic information about the web service. This one
+is just a dummy.
+
+    >>> from lazr.restful.testing.helpers import TestWebServiceConfiguration
+    >>> from zope.component import provideUtility
+    >>> from lazr.restful.interfaces import IWebServiceConfiguration
+    >>> class MyWebServiceConfiguration(TestWebServiceConfiguration):
+    ...     active_versions = ["beta", "1.0", "2.0", "3.0"]
+    ...     last_version_with_mutator_named_operations = "1.0"
+    ...     first_version_with_total_size_link = "2.0"
+    ...     code_revision = "1.0b"
+    ...     default_batch_size = 50
+    >>> provideUtility(MyWebServiceConfiguration(), IWebServiceConfiguration)
+
+We must also set up the ability to create versioned requests. This web
+service has four versions: 'beta', '1.0', '2.0', and '3.0'.  We'll
+need a marker interface for every version, registered as a utility
+under the name of the version.
+
+Each version interface subclasses the previous version's
+interface. This lets a request use a resource definition for the
+previous version if it hasn't changed since then.
+
+    >>> from zope.component import getSiteManager
+    >>> from lazr.restful.interfaces import IWebServiceVersion
+    >>> class ITestServiceRequestBeta(IWebServiceVersion):
+    ...     pass
+    >>> class ITestServiceRequest10(ITestServiceRequestBeta):
+    ...     pass
+    >>> class ITestServiceRequest20(ITestServiceRequest10):
+    ...     pass
+    >>> class ITestServiceRequest30(ITestServiceRequest20):
+    ...     pass
+    >>> sm = getSiteManager()
+    >>> for marker, name in [(ITestServiceRequestBeta, 'beta'),
+    ...                      (ITestServiceRequest10, '1.0'),
+    ...                      (ITestServiceRequest20, '2.0'),
+    ...                      (ITestServiceRequest30, '3.0')]:
+    ...     sm.registerUtility(marker, IWebServiceVersion, name=name)
+
+    >>> from lazr.restful.testing.webservice import FakeRequest
+    >>> request = FakeRequest(version='beta')
+
+
 Entry
 -----
 
@@ -968,51 +1017,6 @@
     ...         self.base_price = base_price
     ...         self.inventory_number = inventory_number
 
-Before we can continue, we must define a web service configuration
-object. Each web service needs to have one of these registered
-utilities providing basic information about the web service. This one
-is just a dummy.
-
-    >>> from lazr.restful.testing.helpers import TestWebServiceConfiguration
-    >>> from zope.component import provideUtility
-    >>> from lazr.restful.interfaces import IWebServiceConfiguration
-    >>> class MyWebServiceConfiguration(TestWebServiceConfiguration):
-    ...     active_versions = ["beta", "1.0", "2.0", "3.0"]
-    ...     last_version_with_mutator_named_operations = "1.0"
-    ...     first_version_with_total_size_link = "2.0"
-    ...     code_revision = "1.0b"
-    ...     default_batch_size = 50
-    >>> provideUtility(MyWebServiceConfiguration(), IWebServiceConfiguration)
-
-We must also set up the ability to create versioned requests. This web
-service has four versions: 'beta', '1.0', '2.0', and '3.0'.  We'll
-need a marker interface for every version, registered as a utility
-under the name of the version.
-
-Each version interface subclasses the previous version's
-interface. This lets a request use a resource definition for the
-previous version if it hasn't changed since then.
-
-    >>> from zope.component import getSiteManager
-    >>> from lazr.restful.interfaces import IWebServiceVersion
-    >>> class ITestServiceRequestBeta(IWebServiceVersion):
-    ...     pass
-    >>> class ITestServiceRequest10(ITestServiceRequestBeta):
-    ...     pass
-    >>> class ITestServiceRequest20(ITestServiceRequest10):
-    ...     pass
-    >>> class ITestServiceRequest30(ITestServiceRequest20):
-    ...     pass
-    >>> sm = getSiteManager()
-    >>> for marker, name in [(ITestServiceRequestBeta, 'beta'),
-    ...                      (ITestServiceRequest10, '1.0'),
-    ...                      (ITestServiceRequest20, '2.0'),
-    ...                      (ITestServiceRequest30, '3.0')]:
-    ...     sm.registerUtility(marker, IWebServiceVersion, name=name)
-
-    >>> from lazr.restful.testing.webservice import FakeRequest
-    >>> request = FakeRequest(version='beta')
-
 Now we can turn a Book object into something that implements
 IBookEntry.
 
@@ -1047,6 +1051,7 @@
       ...
     TypeError: 'IBookSet' isn't exported as an entry.
 
+
 Collection
 ----------
 
 
=== modified file 'src/lazr/restful/interfaces/_rest.py'
--- src/lazr/restful/interfaces/_rest.py	2011-03-02 18:49:23 +0000
+++ src/lazr/restful/interfaces/_rest.py	2011-03-09 16:02:29 +0000
@@ -514,6 +514,13 @@
         default = {}
         )
 
+    require_explicit_versions = Bool(
+        default=False,
+        description=u"""If true, each exported field and named
+        operation must explicitly declare the first version in which
+        it appears. If false, fields and operations are published in
+        all versions.""")
+
     last_version_with_mutator_named_operations = TextLine(
         default=None,
         description=u"""In earlier versions of lazr.restful, mutator methods
 
=== modified file 'src/lazr/restful/testing/helpers.py'
--- src/lazr/restful/testing/helpers.py	2011-02-17 14:56:25 +0000
+++ src/lazr/restful/testing/helpers.py	2011-03-09 16:02:29 +0000
@@ -70,6 +70,7 @@
     code_revision = "1.0b"
     default_batch_size = 50
     hostname = 'example.com'
+    require_explicit_versions = False
 
     def get_request_user(self):
         return 'A user'
 
=== modified file 'src/lazr/restful/testing/webservice.py'
--- src/lazr/restful/testing/webservice.py	2011-02-17 14:56:25 +0000
+++ src/lazr/restful/testing/webservice.py	2011-03-09 16:02:29 +0000
@@ -28,8 +28,9 @@
 import simplejson
 import sys
 from types import ModuleType
+import unittest
 import urllib
-import unittest
+
 from urlparse import urljoin
 import wsgi_intercept
 
@@ -448,15 +449,15 @@
     """A marker interface for requests to the '2.0' web service."""
 
 
-class WebServiceTestCase(CleanUp, unittest.TestCase):
-    """A test case for web service operations."""
+class TestCaseWithWebServiceFixtures(CleanUp, unittest.TestCase):
+    """A test case that needs to have some aspects of a web service set up.
 
-    testmodule_objects = []
+    If the test case is testing a real web service, use
+    WebServiceTestCase instead.
+    """
 
     def setUp(self):
-        """Set the component registry with the given model."""
-        super(WebServiceTestCase, self).setUp()
-
+        super(TestCaseWithWebServiceFixtures, self).setUp()
         # Register a simple configuration object.
         webservice_configuration = WebServiceTestConfiguration()
         sm = getGlobalSiteManager()
@@ -471,7 +472,18 @@
         sm.registerUtility(
             IWebServiceTestRequest20, IWebServiceVersion, name='2.0')
 
+
+class WebServiceTestCase(TestCaseWithWebServiceFixtures):
+    """A test case for web service operations."""
+
+    testmodule_objects = []
+
+    def setUp(self):
+        """Set the component registry with the given model."""
+        super(WebServiceTestCase, self).setUp()
+
         # Register a service root resource
+        sm = getGlobalSiteManager()
         service_root = ServiceRootResource()
         sm.registerUtility(service_root, IServiceRootResource)
 
 
=== modified file 'src/lazr/restful/tests/test_declarations.py'
--- src/lazr/restful/tests/test_declarations.py	2011-01-21 21:08:43 +0000
+++ src/lazr/restful/tests/test_declarations.py	2011-03-09 16:02:29 +0000
@@ -1,5 +1,3 @@
-import unittest
-
 from zope.component import (
     adapts, getMultiAdapter, getSiteManager, getUtility, provideUtility)
 from zope.component.interfaces import ComponentLookupError
@@ -10,9 +8,15 @@
 from zope.security.management import endInteraction, newInteraction
 
 from lazr.restful.declarations import (
-    export_as_webservice_entry, exported, export_read_operation,
-    export_write_operation, mutator_for, operation_for_version,
-    operation_parameters)
+    export_as_webservice_entry,
+    exported,
+    export_read_operation,
+    export_write_operation,
+    generate_entry_interfaces,
+    mutator_for,
+    operation_for_version,
+    operation_parameters,
+    )
 from lazr.restful.fields import Reference
 from lazr.restful.interfaces import (
     IEntry, IResourceGETOperation, IWebServiceConfiguration,
@@ -22,32 +26,30 @@
     AttemptToContributeToNonExportedInterface,
     ConflictInContributingInterfaces, find_interfaces_and_contributors)
 from lazr.restful._resource import EntryAdapterUtility, EntryResource
-from lazr.restful.testing.webservice import FakeRequest
+from lazr.restful.testing.webservice import (
+    FakeRequest,
+    TestCaseWithWebServiceFixtures,
+    )
 from lazr.restful.testing.helpers import (
     create_test_module, TestWebServiceConfiguration, register_test_module)
 
 
-class ContributingInterfacesTestCase(unittest.TestCase):
+class ContributingInterfacesTestCase(TestCaseWithWebServiceFixtures):
     """Tests for interfaces that contribute fields/operations to others."""
 
     def setUp(self):
-        provideUtility(
-            TestWebServiceConfiguration(), IWebServiceConfiguration)
+        super(ContributingInterfacesTestCase, self).setUp()
         sm = getSiteManager()
-        sm.registerUtility(
-            ITestServiceRequestBeta, IWebServiceVersion, name='beta')
-        sm.registerUtility(
-            ITestServiceRequest10, IWebServiceVersion, name='1.0')
         sm.registerAdapter(ProductToHasBugsAdapter)
         sm.registerAdapter(ProjectToHasBugsAdapter)
         sm.registerAdapter(ProductToHasBranchesAdapter)
         sm.registerAdapter(DummyFieldMarshaller)
-        self.beta_request = FakeRequest(version='beta')
-        alsoProvides(
-            self.beta_request, getUtility(IWebServiceVersion, name='beta'))
         self.one_zero_request = FakeRequest(version='1.0')
         alsoProvides(
             self.one_zero_request, getUtility(IWebServiceVersion, name='1.0'))
+        self.two_zero_request = FakeRequest(version='2.0')
+        alsoProvides(
+            self.two_zero_request, getUtility(IWebServiceVersion, name='2.0'))
         self.product = Product()
         self.project = Project()
 
@@ -59,7 +61,7 @@
         # access .bug_count.
         self.product._bug_count = 10
         register_test_module('testmod', IProduct, IHasBugs)
-        adapter = getMultiAdapter((self.product, self.beta_request), IEntry)
+        adapter = getMultiAdapter((self.product, self.one_zero_request), IEntry)
         self.assertEqual(adapter.bug_count, 10)
 
     def test_operations(self):
@@ -68,46 +70,46 @@
         self.product._bug_count = 10
         register_test_module('testmod', IProduct, IHasBugs)
         adapter = getMultiAdapter(
-            (self.product, self.beta_request),
+            (self.product, self.one_zero_request),
             IResourceGETOperation, name='getBugsCount')
         self.assertEqual(adapter(), '10')
 
     def test_contributing_interface_with_differences_between_versions(self):
-        # In the 'beta' version, IHasBranches.development_branches is exported
-        # with its original name whereas for the '1.0' version it's exported
-        # as 'development_branch_10'.
+        # In the '1.0' version, IHasBranches.development_branches is exported
+        # with its original name whereas for the '2.0' version it's exported
+        # as 'development_branch_20'.
         self.product._dev_branch = Branch('A product branch')
         register_test_module('testmod', IProduct, IHasBranches)
-        adapter = getMultiAdapter((self.product, self.beta_request), IEntry)
+        adapter = getMultiAdapter((self.product, self.one_zero_request), IEntry)
         self.assertEqual(adapter.development_branch, self.product._dev_branch)
 
         adapter = getMultiAdapter(
-            (self.product, self.one_zero_request), IEntry)
+            (self.product, self.two_zero_request), IEntry)
         self.assertEqual(
-            adapter.development_branch_10, self.product._dev_branch)
+            adapter.development_branch_20, self.product._dev_branch)
 
     def test_mutator_for_just_one_version(self):
-        # On the 'beta' version, IHasBranches contributes a read only
-        # development_branch field, but on version '1.0' that field can be
+        # On the '1.0' version, IHasBranches contributes a read only
+        # development_branch field, but on version '2.0' that field can be
         # modified as we define a mutator for it.
         self.product._dev_branch = Branch('A product branch')
         register_test_module('testmod', IProduct, IHasBranches)
-        adapter = getMultiAdapter((self.product, self.beta_request), IEntry)
+        adapter = getMultiAdapter((self.product, self.one_zero_request), IEntry)
         try:
             adapter.development_branch = None
         except AttributeError:
             pass
         else:
             self.fail('IHasBranches.development_branch should be read-only '
-                      'on the beta version')
+                      'on the 1.0 version')
 
         adapter = getMultiAdapter(
-            (self.product, self.one_zero_request), IEntry)
-        self.assertEqual(
-            adapter.development_branch_10, self.product._dev_branch)
-        adapter.development_branch_10 = None
-        self.assertEqual(
-            adapter.development_branch_10, None)
+            (self.product, self.two_zero_request), IEntry)
+        self.assertEqual(
+            adapter.development_branch_20, self.product._dev_branch)
+        adapter.development_branch_20 = None
+        self.assertEqual(
+            adapter.development_branch_20, None)
 
     def test_contributing_to_multiple_interfaces(self):
         # Check that the webservice adapter for both IProduct and IProject
@@ -115,10 +117,10 @@
         self.product._bug_count = 10
         self.project._bug_count = 100
         register_test_module('testmod', IProduct, IProject, IHasBugs)
-        adapter = getMultiAdapter((self.product, self.beta_request), IEntry)
+        adapter = getMultiAdapter((self.product, self.one_zero_request), IEntry)
         self.assertEqual(adapter.bug_count, 10)
 
-        adapter = getMultiAdapter((self.project, self.beta_request), IEntry)
+        adapter = getMultiAdapter((self.project, self.one_zero_request), IEntry)
         self.assertEqual(adapter.bug_count, 100)
 
     def test_multiple_contributing_interfaces(self):
@@ -127,7 +129,7 @@
         self.product._bug_count = 10
         self.product._dev_branch = Branch('A product branch')
         register_test_module('testmod', IProduct, IHasBugs, IHasBranches)
-        adapter = getMultiAdapter((self.product, self.beta_request), IEntry)
+        adapter = getMultiAdapter((self.product, self.one_zero_request), IEntry)
         self.assertEqual(adapter.bug_count, 10)
         self.assertEqual(adapter.development_branch, self.product._dev_branch)
 
@@ -139,7 +141,7 @@
         class Empty:
             implements(IEmpty)
         register_test_module('testmod', IEmpty)
-        entry_resource = EntryResource(Empty(), self.beta_request)
+        entry_resource = EntryResource(Empty(), self.one_zero_request)
         self.assertEquals({}, entry_resource.entry._orig_interfaces)
         self.assertEquals([], entry_resource.redacted_fields)
 
@@ -148,7 +150,7 @@
         # interface where the field is defined and adapt the context to that
         # interface before accessing that field.
         register_test_module('testmod', IProduct, IHasBugs, IHasBranches)
-        entry_resource = EntryResource(self.product, self.beta_request)
+        entry_resource = EntryResource(self.product, self.one_zero_request)
         self.assertEquals([], entry_resource.redacted_fields)
 
     def test_redacted_fields_with_permission_checker(self):
@@ -161,7 +163,7 @@
             secure_product = ProxyFactory(
                 self.product,
                 checker=MultiChecker([(IProduct, 'zope.Public')]))
-            entry_resource = EntryResource(secure_product, self.beta_request)
+            entry_resource = EntryResource(secure_product, self.one_zero_request)
             self.assertEquals([], entry_resource.redacted_fields)
         finally:
             endInteraction()
@@ -183,7 +185,7 @@
         register_test_module('testmod', IProduct, IHasBranches)
         self.assertRaises(
             ComponentLookupError,
-            getMultiAdapter, (dummy, self.beta_request), IEntry)
+            getMultiAdapter, (dummy, self.one_zero_request), IEntry)
 
     def test_cannot_contribute_to_non_exported_interface(self):
         # A contributing interface can only contribute to exported interfaces.
@@ -218,7 +220,7 @@
         # different adapters, its type name is that of the main interface and
         # not one of its contributors.
         register_test_module('testmod', IProduct, IHasBugs)
-        adapter = getMultiAdapter((self.product, self.beta_request), IEntry)
+        adapter = getMultiAdapter((self.product, self.one_zero_request), IEntry)
         self.assertEqual(
             'product', EntryAdapterUtility(adapter.__class__).singular_type)
 
@@ -308,13 +310,13 @@
     not_exported = TextLine(title=u'Not exported')
     development_branch = exported(
         Reference(schema=IBranch, readonly=True),
-        ('1.0', dict(exported_as='development_branch_10')),
-        ('beta', dict(exported_as='development_branch')))
+        ('2.0', dict(exported_as='development_branch_20')),
+        ('1.0', dict(exported_as='development_branch')))
 
     @mutator_for(development_branch)
     @export_write_operation()
     @operation_parameters(value=TextLine())
-    @operation_for_version('1.0')
+    @operation_for_version('2.0')
     def set_dev_branch(value):
         pass
 
@@ -342,7 +344,135 @@
     adapts(Interface, IHTTPRequest)
 
 
-class ITestServiceRequestBeta(IWebServiceVersion):
-    pass
-class ITestServiceRequest10(IWebServiceVersion):
-    pass
+# Classes for TestReqireExplicitVersions
+
+class IFieldExportedWithoutAsOf(Interface):
+    export_as_webservice_entry()
+
+    field = exported(TextLine(), exported=True)
+
+
+class IFieldExportedToEarliestVersionUsingAsOf(Interface):
+    export_as_webservice_entry()
+
+    field = exported(TextLine(), as_of='1.0')
+
+
+class IFieldExportedToLatestVersionUsingAsOf(Interface):
+    export_as_webservice_entry()
+
+    field = exported(TextLine(), as_of='2.0')
+
+
+class IFieldDefiningAttributesBeforeAsOf(Interface):
+    export_as_webservice_entry()
+
+    field = exported(TextLine(), ('1.0', dict(exported=True)),
+                     as_of='2.0')
+
+class IFieldAsOfNonexistentVersion(Interface):
+    export_as_webservice_entry()
+
+    field = exported(TextLine(), as_of='nosuchversion')
+
+
+class IFieldDoubleDefinition(Interface):
+    export_as_webservice_entry()
+
+    field = exported(TextLine(), ('2.0', dict(exported_as='name2')),
+                     exported_as='name2', as_of='2.0')
+
+
+class TestRequireExplicitVersions(TestCaseWithWebServiceFixtures):
+    """Test behavior when require_explicit_versions is True."""
+
+    def setUp(self):
+        super(TestRequireExplicitVersions, self).setUp()
+        self.utility = getUtility(IWebServiceConfiguration)
+        self.utility.require_explicit_versions = True
+
+    def _assertRaises(self, exception, func, *args, **kwargs):
+        # Approximate the behavior of testtools assertRaises, which
+        # returns the raised exception. I couldn't get
+        # testtools.TestCase to play nicely with zope's Cleanup class.
+        self.assertRaises(exception, func, *args, **kwargs)
+        try:
+            func(*args, **kwargs)
+        except Exception, e:
+            return e
+
+    def test_field_exported_as_of_earlier_version_is_exported_in_subsequent_versions(self):
+
+        interfaces = generate_entry_interfaces(
+            IFieldExportedToEarliestVersionUsingAsOf, [],
+            *self.utility.active_versions)
+        interface_10 = interfaces[0][1]
+        interface_20 = interfaces[1][1]
+        self.assertEquals(interface_10.names(), ['field'])
+        self.assertEquals(interface_20.names(), ['field'])
+
+    def test_field_exported_as_of_later_version_is_not_exported_in_earlier_versions(self):
+
+        interfaces = generate_entry_interfaces(
+            IFieldExportedToLatestVersionUsingAsOf, [],
+            *self.utility.active_versions)
+        interface_10 = interfaces[0][1]
+        interface_20 = interfaces[1][1]
+        self.assertEquals(interface_10.names(), [])
+        self.assertEquals(interface_20.names(), ['field'])
+
+    def test_field_not_exported_using_as_of_fails(self):
+        exception = self._assertRaises(
+            ValueError, generate_entry_interfaces,
+            IFieldExportedWithoutAsOf, [], *self.utility.active_versions)
+        self.assertEquals(
+            str(exception),
+            ('Field "field" in interface "IFieldExportedWithoutAsOf": '
+             'Field was exported in version 1.0, but not by using as_of. '
+             'The service configuration requires that you use as_of.')
+            )
+
+
+    def test_field_cannot_be_both_exported_and_not_exported(self):
+        # If you use the as_of keyword argument, you can't also set
+        # the exported keyword argument to False.
+        exception = self._assertRaises(
+            ValueError, exported, TextLine(), as_of='1.0', exported=False)
+        self.assertEquals(
+                str(exception),
+                ('as_of=1.0 says to export TextLine, but exported=False '
+                 'says not to.'))
+
+    def test_field_exported_as_of_nonexistent_version_fails(self):
+        exception = self._assertRaises(
+            ValueError, generate_entry_interfaces,
+            IFieldAsOfNonexistentVersion, [],
+            *self.utility.active_versions)
+        self.assertEquals(
+            str(exception),
+            ('Field "field" in interface "IFieldAsOfNonexistentVersion": '
+             'Unrecognized version "nosuchversion".'))
+
+    def test_field_exported_with_duplicate_attributes_fails(self):
+        # You can't provide a dictionary of attributes for the
+        # version specified in as_of.
+        exception = self._assertRaises(
+            ValueError, generate_entry_interfaces,
+            IFieldDoubleDefinition, [], *self.utility.active_versions)
+        self.assertEquals(
+            str(exception),
+            ('Field "field" in interface "IFieldDoubleDefinition": '
+             'Duplicate annotations for version "2.0".'))
+
+    def test_field_with_annotations_that_precede_as_of_fails(self):
+        # You can't provide a dictionary of attributes for a version
+        # preceding the version specified in as_of.
+        exception = self._assertRaises(
+            ValueError, generate_entry_interfaces,
+            IFieldDefiningAttributesBeforeAsOf, [],
+            *self.utility.active_versions)
+        self.assertEquals(
+            str(exception),
+            ('Field "field" in interface '
+             '"IFieldDefiningAttributesBeforeAsOf": Version "1.0" defined '
+             'after the later version "2.0".'))