Addressed review feedback

Author: Bart Koelman

docs/usage/routing.md

@@ -86,7 +86,7 @@ public class OrderLineController : JsonApiController<OrderLine, int>
 }
 ```
 
-## Advanced usage: Custom routing convention
+## Advanced usage: custom routing convention
 
 It is possible to replace the built-in routing convention with a [custom routing convention](https://docs.microsoft.com/en-us/aspnet/core/mvc/controllers/application-model?view=aspnetcore-3.1#sample-custom-routing-convention) by registering an implementation of `IJsonApiRoutingConvention`.
 

src/JsonApiDotNetCore.SourceGenerators/ControllerSourceGenerator.cs

@@ -45,10 +45,10 @@ public void Execute(GeneratorExecutionContext context)
             }
 
             INamedTypeSymbol resourceAttributeType = context.Compilation.GetTypeByMetadataName("JsonApiDotNetCore.Resources.Annotations.ResourceAttribute");
-            INamedTypeSymbol openIdentifiableInterface = context.Compilation.GetTypeByMetadataName("JsonApiDotNetCore.Resources.IIdentifiable`1");
+            INamedTypeSymbol identifiableOpenInterface = context.Compilation.GetTypeByMetadataName("JsonApiDotNetCore.Resources.IIdentifiable`1");
             INamedTypeSymbol loggerFactoryInterface = context.Compilation.GetTypeByMetadataName("Microsoft.Extensions.Logging.ILoggerFactory");
 
-            if (resourceAttributeType == null || openIdentifiableInterface == null || loggerFactoryInterface == null)
+            if (resourceAttributeType == null || identifiableOpenInterface == null || loggerFactoryInterface == null)
             {
                 return;
             }
@@ -90,18 +90,18 @@ public void Execute(GeneratorExecutionContext context)
 
                 string controllerNamespace = GetControllerNamespace(controllerNamespaceArgument, resourceType);
 
-                INamedTypeSymbol closedIdentifiableInterface = FirstOrDefault(resourceType.AllInterfaces, openIdentifiableInterface,
+                INamedTypeSymbol identifiableClosedInterface = FirstOrDefault(resourceType.AllInterfaces, identifiableOpenInterface,
                     (@interface, openInterface) => @interface.IsGenericType &&
                         SymbolEqualityComparer.Default.Equals(@interface.ConstructedFrom, openInterface));
 
-                if (closedIdentifiableInterface == null)
+                if (identifiableClosedInterface == null)
                 {
                     var diagnostic = Diagnostic.Create(MissingInterfaceWarning, typeDeclarationSyntax.GetLocation(), resourceType.Name);
                     context.ReportDiagnostic(diagnostic);
                     continue;
                 }
 
-                ITypeSymbol idType = closedIdentifiableInterface.TypeArguments[0];
+                ITypeSymbol idType = identifiableClosedInterface.TypeArguments[0];
                 string controllerName = $"{resourceType.Name.Pluralize()}Controller";
                 JsonApiEndpointsCopy endpointsToGenerate = (JsonApiEndpointsCopy?)(int?)endpointsArgument.Value ?? JsonApiEndpointsCopy.All;
 

src/JsonApiDotNetCore.SourceGenerators/JsonApiEndpointsCopy.cs

@@ -4,7 +4,7 @@ namespace JsonApiDotNetCore.SourceGenerators
 {
     // IMPORTANT: A copy of this type exists in the JsonApiDotNetCore project. Keep these in sync when making changes.
     [Flags]
-    internal enum JsonApiEndpointsCopy
+    public enum JsonApiEndpointsCopy
     {
         None = 0,
         GetCollection = 1,

test/SourceGeneratorTests/JsonApiEndpointsCopyTests.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using FluentAssertions;
+using JsonApiDotNetCore.Controllers;
+using JsonApiDotNetCore.SourceGenerators;
+using Xunit;
+
+namespace SourceGeneratorTests
+{
+    public sealed class JsonApiEndpointsCopyTests
+    {
+        [Fact]
+        public void Enum_underlying_types_are_identical()
+        {
+            Type sourceType = Enum.GetUnderlyingType(typeof(JsonApiEndpoints));
+            Type copyType = Enum.GetUnderlyingType(typeof(JsonApiEndpointsCopy));
+
+            copyType.Should().Be(sourceType);
+        }
+
+        [Fact]
+        public void Enum_attributes_in_order_are_identical()
+        {
+            Attribute[] sourceAttributes = typeof(JsonApiEndpoints).GetCustomAttributes().ToArray();
+            Attribute[] copyAttributes = typeof(JsonApiEndpointsCopy).GetCustomAttributes().ToArray();
+
+            copyAttributes.Should().BeEquivalentTo(sourceAttributes, options => options.WithStrictOrdering());
+        }
+
+        [Fact]
+        public void Enum_member_names_in_order_are_identical()
+        {
+            const BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly;
+
+            string[] sourceNames = typeof(JsonApiEndpoints).GetMembers(bindingFlags).Select(memberInfo => memberInfo.Name).ToArray();
+            string[] copyNames = typeof(JsonApiEndpointsCopy).GetMembers(bindingFlags).Select(memberInfo => memberInfo.Name).ToArray();
+
+            copyNames.Should().BeEquivalentTo(sourceNames, options => options.WithStrictOrdering());
+        }
+
+        [Fact]
+        public void Enum_member_values_are_identical()
+        {
+            IEnumerable<int> sourceValues = Enum.GetValues<JsonApiEndpoints>().Select(value => (int)value).ToArray();
+            int[] copyValues = Enum.GetValues<JsonApiEndpointsCopy>().Select(value => (int)value).ToArray();
+
+            copyValues.Should().BeEquivalentTo(sourceValues, options => options.WithStrictOrdering());
+        }
+    }
+}