Added a versioned AttributeRoutingConvention, which skips processing for controllers with API versions that do not have corresponding models in the underlying EDM

Author: Chris Martinez

src/Microsoft.AspNet.OData.Versioning/System.Web.OData/HttpConfigurationExtensions.cs

@@ -21,7 +21,6 @@
     /// </summary>
     public static class HttpConfigurationExtensions
     {
-        private const string UnsupportedVersionRouteNameFormat = "{0}-UnsupportedVersion-{1}";
         private const string ResolverSettingsKey = "System.Web.OData.ResolverSettingsKey";
         private static readonly Lazy<Action<DefaultODataPathHandler, object>> setResolverSettings = new Lazy<Action<DefaultODataPathHandler, object>>( GetResolverSettingsMutator );
 
@@ -208,27 +207,23 @@ public static IReadOnlyList<ODataRoute> MapVersionedODataRoutes(
             routeConventions.Insert( 0, null );
 
             var odataRoutes = new List<ODataRoute>();
-            var unversionedRouteConstraints = new List<ODataPathRouteConstraint>();
 
             foreach ( var model in models )
             {
                 var versionedRouteName = routeName;
                 var apiVersion = model.GetAnnotationValue<ApiVersionAnnotation>( model )?.ApiVersion;
                 var routeConstraint = default( ODataPathRouteConstraint );
 
-                routeConventions[0] = new AttributeRoutingConvention( model, configuration );
-
-                var unversionedRouteConstraint = new ODataPathRouteConstraint( pathHandler, model, versionedRouteName, routeConventions.ToArray() );
+                routeConventions[0] = new VersionedAttributeRoutingConvention( model, configuration );
 
                 if ( apiVersion == null )
                 {
-                    routeConstraint = unversionedRouteConstraint;
+                    routeConstraint = new ODataPathRouteConstraint( pathHandler, model, versionedRouteName, routeConventions.ToArray() );
                 }
                 else
                 {
                     versionedRouteName += "-" + apiVersion.ToString();
                     routeConstraint = new VersionedODataPathRouteConstraint( pathHandler, model, versionedRouteName, routeConventions.ToArray(), apiVersion );
-                    unversionedRouteConstraints.Add( unversionedRouteConstraint );
                 }
 
                 var route = new ODataRoute( routePrefix, routeConstraint );
@@ -237,12 +232,6 @@ public static IReadOnlyList<ODataRoute> MapVersionedODataRoutes(
                 odataRoutes.Add( route );
             }
 
-            for ( var i = 0; i < unversionedRouteConstraints.Count; i++ )
-            {
-                var routeConstraint = unversionedRouteConstraints[i];
-                routes.Add( UnsupportedVersionRouteNameFormat.FormatInvariant( routeName, i ), new ODataRoute( routePrefix, routeConstraint ) );
-            }
-
             return odataRoutes;
         }
 
@@ -353,8 +342,7 @@ public static ODataRoute MapVersionedODataRoute(
 
             configuration.SetResolverSettings( pathHandler );
             model.SetAnnotationValue( model, new ApiVersionAnnotation( apiVersion ) );
-            routeConventions.Insert( 0, null );
-            routeConventions[0] = new AttributeRoutingConvention( model, configuration );
+            routeConventions.Insert( 0, new VersionedAttributeRoutingConvention( model, configuration ) );
 
             var routeConstraint = new VersionedODataPathRouteConstraint( pathHandler, model, routeName, routeConventions.ToArray(), apiVersion );
             var route = new ODataRoute( routePrefix, routeConstraint );
@@ -364,4 +352,4 @@ public static ODataRoute MapVersionedODataRoute(
             return route;
         }
     }
-}
+}

src/Microsoft.AspNet.OData.Versioning/Web.OData/Routing/VersionedAttributeRoutingConvention.cs

@@ -0,0 +1,84 @@
+namespace Microsoft.Web.OData.Routing
+{
+    using Http;
+    using Microsoft.OData.Edm;
+    using System.Collections.Generic;
+    using System.Diagnostics.Contracts;
+    using System.Linq;
+    using System.Web.Http;
+    using System.Web.Http.Controllers;
+    using System.Web.OData.Routing;
+    using System.Web.OData.Routing.Conventions;
+
+    /// <summary>
+    /// Represents an OData attribute routing convention with additional support for API versioning.
+    /// </summary>
+    public class VersionedAttributeRoutingConvention : AttributeRoutingConvention
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VersionedAttributeRoutingConvention"/> class.
+        /// </summary>
+        /// <param name="model">The <see cref="IEdmModel">EDM model</see> associated with the routing convention.</param>
+        /// <param name="configuration">The current <see cref="HttpConfiguration">HTTP configuration</see>.</param>
+        public VersionedAttributeRoutingConvention( IEdmModel model, HttpConfiguration configuration )
+            : base( model, configuration )
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VersionedAttributeRoutingConvention"/> class.
+        /// </summary>
+        /// <param name="model">The <see cref="IEdmModel">EDM model</see> associated with the routing convention.</param>
+        /// <param name="configuration">The current <see cref="HttpConfiguration">HTTP configuration</see>.</param>
+        /// <param name="pathTemplateHandler">The <see cref="IODataPathTemplateHandler">OData path template handler</see> associated with the routing convention.</param>
+        public VersionedAttributeRoutingConvention( IEdmModel model, HttpConfiguration configuration, IODataPathTemplateHandler pathTemplateHandler )
+            : base( model, configuration, pathTemplateHandler )
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VersionedAttributeRoutingConvention"/> class.
+        /// </summary>
+        /// <param name="model">The <see cref="IEdmModel">EDM model</see> associated with the routing convention.</param>
+        /// <param name="controllers">The <see cref="IEnumerable{T}">sequence</see> of <see cref="HttpControllerDescriptor">controller descriptors</see>
+        public VersionedAttributeRoutingConvention( IEdmModel model, IEnumerable<HttpControllerDescriptor> controllers )
+            : base( model, controllers )
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VersionedAttributeRoutingConvention"/> class.
+        /// </summary>
+        /// <param name="model">The <see cref="IEdmModel">EDM model</see> associated with the routing convention.</param>
+        /// <param name="controllers">The <see cref="IEnumerable{T}">sequence</see> of <see cref="HttpControllerDescriptor">controller descriptors</see>
+        /// associated with the routing convention.</param>
+        /// <param name="pathTemplateHandler">The <see cref="IODataPathTemplateHandler">OData path template handler</see> associated with the routing convention.</param>
+        public VersionedAttributeRoutingConvention( IEdmModel model, IEnumerable<HttpControllerDescriptor> controllers, IODataPathTemplateHandler pathTemplateHandler )
+            : base( model, controllers, pathTemplateHandler )
+        {
+        }
+
+        /// <summary>
+        /// Returns a value indicating whether the specified controller should be mapped using attribute routing conventions.
+        /// </summary>
+        /// <param name="controller">The <see cref="HttpControllerDescriptor">controller descriptor</see> to evaluate.</param>
+        /// <returns>True if the <paramref name="controller"/> should be mapped as an OData controller; otherwise, false.</returns>
+        /// <remarks>This method will match any OData controller that is API version-neutral or has a declared API version that
+        /// matches the API version applied to the associated <see cref="P:Model">model</see>.</remarks>
+        public override bool ShouldMapController( HttpControllerDescriptor controller )
+        {
+            Contract.Assume( controller != null );
+
+            var versionModel = controller.GetApiVersionModel();
+
+            if ( versionModel.IsApiVersionNeutral )
+            {
+                return true;
+            }
+
+            var apiVersion = Model.GetAnnotationValue<ApiVersion>( Model );
+
+            return apiVersion != null && versionModel.DeclaredApiVersions.Contains( apiVersion );
+        }
+    }
+}

test/Microsoft.AspNet.OData.Versioning.Tests/Web.OData/Routing/VersionedAttributeRoutingConventionTest.cs

@@ -0,0 +1,79 @@
+namespace Microsoft.Web.OData.Routing
+{
+    using Builder;
+    using FluentAssertions;
+    using Http;
+    using Microsoft.OData.Edm;
+    using Moq;
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Web.Http;
+    using System.Web.Http.Controllers;
+    using System.Web.Http.Dispatcher;
+    using System.Web.OData;
+    using System.Web.OData.Builder;
+    using Xunit;
+
+    public class VersionedAttributeRoutingConventionTest
+    {
+        [ApiVersionNeutral]
+        private sealed class NeutralController : ODataController
+        {
+        }
+
+        [ApiVersion( "1.0" )]
+        private sealed class ControllerV1 : ODataController
+        {
+        }
+
+        private static IEdmModel CreateModel( HttpConfiguration configuration, Type controllerType )
+        {
+            var controllerTypeResolver = new Mock<IHttpControllerTypeResolver>();
+            var controllerTypes = new List<Type>() { controllerType };
+
+            controllerTypeResolver.Setup( ctr => ctr.GetControllerTypes( It.IsAny<IAssembliesResolver>() ) ).Returns( controllerTypes );
+            configuration.Services.Replace( typeof( IHttpControllerTypeResolver ), controllerTypeResolver.Object );
+
+            var builder = new VersionedODataModelBuilder( configuration );
+
+            return builder.GetEdmModels().Single();
+        }
+
+        [Fact]
+        public void should_map_controller_should_return_true_for_versionX2Dneutral_controller()
+        {
+            // arrange
+            var model = new ODataModelBuilder().GetEdmModel();
+            var controller = new HttpControllerDescriptor( new HttpConfiguration(), string.Empty, typeof( NeutralController ) );
+            var convention = new VersionedAttributeRoutingConvention( model, new HttpControllerDescriptor[0] );
+
+            model.SetAnnotationValue( model, new ApiVersion( 1, 0 ) );
+
+            // act
+            var result = convention.ShouldMapController( controller );
+
+            // assert
+            result.Should().BeTrue();
+        }
+
+        [Theory]
+        [InlineData( 1, true )]
+        [InlineData( 2, false )]
+        public void should_map_controller_should_return_expected_result_for_controller_version( int majorVersion, bool expected )
+        {
+            // arrange
+            var model = new ODataModelBuilder().GetEdmModel();
+            var controller = new HttpControllerDescriptor( new HttpConfiguration(), string.Empty, typeof( ControllerV1 ) );
+            var convention = new VersionedAttributeRoutingConvention( model, new HttpControllerDescriptor[0] );
+
+            model.SetAnnotationValue( model, new ApiVersion( majorVersion, 0 ) );
+
+            // act
+            var result = convention.ShouldMapController( controller );
+
+            // assert
+            result.Should().Be( expected );
+        }
+    }
+}