add tests for extracting names

Author: ash.blade

src/EnumClass.Core/EnumInfoFactory.cs

@@ -31,17 +31,19 @@ public static EnumInfo CreateFromNamedTypeSymbol(INamedTypeSymbol enumSymbol,
  var members = enumSymbol.GetMembers();
 
  var attributeInfo = ExtractEnumClassAttributeCtorInfo(enumSymbol, enumClassAttribute);
- var fullyQualifiedEnumName = SymbolDisplay.ToDisplayString(enumSymbol, SymbolDisplayFormat.FullyQualifiedFormat);
- var generatedClassName = GetClassName(enumSymbol, attributeInfo);
- var resultNamespace = GetResultNamespace(enumSymbol, attributeInfo);
  var underlyingType = GetUnderlyingType(enumSymbol);
  var accessibility = GetAccessibility(enumSymbol);
- var fullyQualifiedClassName = $"global::{resultNamespace}.{generatedClassName}";
 
- var className = new ManuallySpecifiedSymbolName(fullyQualifiedClassName, generatedClassName);
- var enumName = new ManuallySpecifiedSymbolName(fullyQualifiedEnumName, enumSymbol.Name);
+ var resultNamespace = GetResultNamespace(enumSymbol, attributeInfo);
  var @namespace = new ManuallySpecifiedSymbolName($"global::{resultNamespace}", resultNamespace);
 
+ var generatedClassName = GetClassName(enumSymbol, attributeInfo);
+ var fullyQualifiedClassName = $"global::{resultNamespace}.{generatedClassName}";
+ var className = new ManuallySpecifiedSymbolName(fullyQualifiedClassName, generatedClassName);
+ 
+ var fullyQualifiedEnumName = SymbolDisplay.ToDisplayString(enumSymbol, SymbolDisplayFormat.FullyQualifiedFormat);
+ var enumName = new ManuallySpecifiedSymbolName(fullyQualifiedEnumName, enumSymbol.Name);
+
  var memberInfos = members
  .OfType<IFieldSymbol>()
  .Combine(new EnumMemberInfoCreationContext(className, @namespace, enumName)) 

src/EnumClass.Core/EnumMemberInfoFactory.cs

@@ -31,7 +31,7 @@ internal static class EnumMemberInfoFactory
 
  // Class name is equivalent to enum member name
  var enumClassName = $"{fieldSymbol.Name}EnumValue";
- var fullyQualifiedEnumClassName = $"{fieldSymbol.ContainingNamespace.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}.EnumClass.{enumClassName}";
+ var fullyQualifiedEnumClassName = $"{context.EnumClassName.FullyQualified}.{enumClassName}";
 
  var fullyQualifiedMemberName = $"{context.EnumName.FullyQualified}.{fieldSymbol.Name}";
  var memberName = fieldSymbol.Name;

src/EnumClass.Core/Models/EnumMemberInfo.cs

@@ -26,7 +26,7 @@ public class EnumMemberInfo
  /// Name of enum value we constructing.
  /// This is fully qualified, with 'global::' prefix
  /// </summary>
- public string FullyQualifiedEnumValue => _memberName.FullyQualified;
+ public string FullyQualifiedEnumMemberName => _memberName.FullyQualified;
 
  /// <summary>
  /// Name of enum member we constructing.

src/EnumClass.Generator/EnumClassIncrementalGenerator.cs

@@ -314,7 +314,7 @@ private static void GenerateAllEnumClasses(Compilation
  builder.AppendLine(" {");
 
  // Generate constructor
- builder.AppendFormat(" public {0}(): base({1}) {{ }}\n", member.ClassName, member.FullyQualifiedEnumValue);
+ builder.AppendFormat(" public {0}(): base({1}) {{ }}\n", member.ClassName, member.FullyQualifiedEnumMemberName);
 
  // Override default ToString() 
  builder.AppendLine(" public override string ToString()");

tests/Generator/EnumClass.Generator.Tests/EnumClass.Generator.Tests.csproj

@@ -29,6 +29,7 @@
  <ItemGroup>
  <ProjectReference Include="..\..\..\src\EnumClass.Attributes\EnumClass.Attributes.csproj" />
  <ProjectReference Include="..\..\..\src\EnumClass.Generator\EnumClass.Generator.csproj" />
+ <ProjectReference Include="..\..\..\src\EnumClass.Core\EnumClass.Core.csproj" />
  </ItemGroup>
 
 </Project>

tests/Generator/EnumClass.Generator.Tests/EnumClassGenerationTests.cs

@@ -1,6 +1,7 @@
 using System.Reflection;
 using System.Runtime.InteropServices;
 using EnumClass.Attributes;
+using EnumClass.Core;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 

tests/Generator/EnumClass.Generator.Tests/EnumInfoFactoryTests.cs

@@ -0,0 +1,146 @@
+using System.Reflection;
+using EnumClass.Attributes;
+using EnumClass.Core;
+using EnumClass.Core.Models;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace EnumClass.Generator.Tests;
+
+public class EnumInfoFactoryTests
+{
+ public const string SampleEnumCode = @"using EnumClass.Attributes;
+
+namespace Test;
+
+[EnumClass]
+public enum SampleEnum
+{
+ One = 1,
+ Two = 2,
+ Three = 3
+}";
+
+ private List<EnumInfo> GetEnumInfos(params string[] sourceCodes)
+ {
+ var compilation = CSharpCompilation.Create("Test", 
+ syntaxTrees: sourceCodes.Select(x => CSharpSyntaxTree.ParseText(x)),
+ references: new[]
+ {
+ MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
+ MetadataReference.CreateFromFile(typeof(EnumClassAttribute).Assembly.Location),
+ MetadataReference.CreateFromFile(typeof(EnumInfo).Assembly.Location),
+ MetadataReference.CreateFromFile(Assembly.GetCallingAssembly().Location),
+ MetadataReference.CreateFromFile(typeof(string).Assembly.Location),
+ MetadataReference.CreateFromFile(Assembly.Load(new AssemblyName("System.Runtime")).Location),
+ MetadataReference.CreateFromFile(Assembly.Load(new AssemblyName("netstandard")).Location),
+ }, 
+ options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+ 
+ CSharpGeneratorDriver.Create(new EnumClassIncrementalGenerator())
+ .RunGeneratorsAndUpdateCompilation(compilation, out var resultCompilation, out var d);
+
+ // Pass SourceProductionContext safely,
+ // because there no errors expected
+ return EnumInfoFactory.GetAllEnumInfosFromCompilation(resultCompilation, new SourceProductionContext())!;
+ }
+
+ [Fact]
+ public void GetAllEnumsFromCompilation__WithSingleMarkedEnum__ShouldReturnListWithSingleElement()
+ {
+ var enums = GetEnumInfos(SampleEnumCode);
+ Assert.Single(enums);
+ }
+
+ [Fact]
+ public void GetAllEnumsFromCompilation__WithSingleMarkedEnumAnd3Members__ShouldReturnSingleEnumInfoWith3EnumMemberInfo()
+ {
+ var e = GetEnumInfos(SampleEnumCode).First();
+ Assert.Equal(3, e.Members.Length);
+ }
+
+ [Fact]
+ public void ShouldCorrectlyExtractClassName()
+ {
+ var e = GetEnumInfos(SampleEnumCode).First();
+ Assert.Equal("SampleEnum", e.ClassName);
+ }
+
+ [Fact]
+ public void ShouldCorrectlyExtractFullyQualifiedMemberClassNames()
+ {
+ var expected = new HashSet<string>()
+ {
+ "global::Test.EnumClass.SampleEnum.OneEnumValue",
+ "global::Test.EnumClass.SampleEnum.TwoEnumValue",
+ "global::Test.EnumClass.SampleEnum.ThreeEnumValue",
+ };
+ var e = GetEnumInfos(SampleEnumCode).First();
+ var actual = e.Members.Select(x => x.FullyQualifiedClassName).ToHashSet();
+ Assert.Equal(expected, actual);
+ }
+
+ [Fact]
+ public void ShouldCorrectlyExtractMemberClassNames()
+ {
+ var expected = new HashSet<string>()
+ {
+ "OneEnumValue",
+ "TwoEnumValue",
+ "ThreeEnumValue",
+ };
+ var e = GetEnumInfos(SampleEnumCode).First();
+ var actual = e.Members.Select(x => x.ClassName).ToHashSet();
+ Assert.Equal(expected, actual);
+ }
+
+ [Fact]
+ public void ShouldCorrectlyExtractFullyQualifiedEnumName()
+ {
+ var expected = "global::Test.SampleEnum";
+ var e = GetEnumInfos(SampleEnumCode).First();
+ var actual = e.FullyQualifiedEnumName;
+ Assert.Equal(expected, actual);
+ }
+
+ [Fact]
+ public void ShouldCorrectlyExtractFullyQualifiedEnumMemberValueName()
+ {
+ var expected = new HashSet<string>()
+ {
+ "global::Test.SampleEnum.One",
+ "global::Test.SampleEnum.Two",
+ "global::Test.SampleEnum.Three",
+ };
+ var e = GetEnumInfos(SampleEnumCode).First();
+ var actual = e.Members.Select(x => x.FullyQualifiedEnumMemberName).ToHashSet();
+ Assert.Equal(expected, actual);
+ }
+
+ [Fact]
+ public void ShouldCorrectlyExtractNamespace()
+ {
+ var expected = "Test.EnumClass";
+ var actual = GetEnumInfos(SampleEnumCode).First().Namespace;
+ Assert.Equal(expected, actual);
+ }
+
+ public const string SecondEnumCode = @"using EnumClass.Attributes;
+
+namespace Test;
+
+[EnumClass]
+public enum SecondEnum
+{
+ Nope,
+ Yes,
+ No
+}";
+ 
+ [Fact]
+ public void GetAllEnumsFromCompilation_With2MarkedEnums_ShouldReturnListWith2Elements()
+ {
+ var enums = GetEnumInfos(SampleEnumCode, SecondEnumCode);
+ Assert.Equal(2, enums.Count);
+ }
+}