public async Task GenerateStructAsync_GeneratesStruct_WithJsonConverter()
{
// Arrange
var context = new EntityIdGenerationContext(
SyntaxFactory.StructDeclaration("EntityId"),
typeConverter: false,
jsonNetConverter: true);
// Act
var @struct = await Int32EntityIdSyntaxGenerator.GenerateStructAsync(context);
// Assert
Assert.NotNull(@struct);
Assert.Equal("EntityId", @struct.Identifier.ValueText);
AssertHasModifier(@struct, SyntaxKind.ReadOnlyKeyword);
AssertHasAttribute(@struct, "System.Diagnostics.DebuggerDisplay",
attribute =>
{
Assert.Equal("(\"{DebuggerToString(),nq}\")", attribute.ArgumentList.ToString());
}
);
AssertDoesNotHaveAttribute(@struct, "System.ComponentModel.TypeConverter");
AssertHasAttribute(@struct, "Newtonsoft.Json.JsonConverter",
attribute =>
{
Assert.Equal("(typeof(EntityIdJsonConverter))", attribute.ArgumentList.ToString());
}
);
}
protected SyntaxList <AttributeListSyntax> GenerateAttributes(EntityIdGenerationContext context)
{
var attributes = new List <AttributeSyntax>();
if (context.TypeConverter)
{
attributes.Add(
// TypeConverter(typeof({name}TypeConverter))
Attribute(
Name("TypeConverter", "System.ComponentModel"),
new[]
{
TypeOfAttributeArgument($"{context.Name}TypeConverter")
}
)
);
}
if (context.JsonNetConverter)
{
attributes.Add(
// JsonConverter(typeof({name}JsonConverter))
Attribute(
Name("JsonConverter", "Newtonsoft.Json"),
new[]
{
TypeOfAttributeArgument($"{context.Name}JsonConverter")
}
)
);
}
return(List(Attributes(attributes)));
}
public async Task GenerateStructAsync_GeneratesStruct_WithEmptyField()
{
// Arrange
var context = new EntityIdGenerationContext(
SyntaxFactory.StructDeclaration("EntityId"),
typeConverter: false,
jsonNetConverter: false);
// Act
var @struct = await Int32EntityIdSyntaxGenerator.GenerateStructAsync(context);
// Assert
AssertHasField(
@struct,
name: "Empty",
type: "EntityId",
(member, variable) =>
{
AssertHasModifier(member, SyntaxKind.PublicKeyword);
AssertHasModifier(member, SyntaxKind.StaticKeyword);
AssertHasModifier(member, SyntaxKind.ReadOnlyKeyword);
Assert.NotNull(variable.Initializer);
Assert.Equal("= new EntityId()", variable.Initializer.ToString());
});
}
protected async Task <StructDeclarationSyntax> GenerateStructAsync(EntityIdGenerationContext context)
{
// MA - Generate the majority of the syntax from a template.
var @struct = await FromTemplate <StructDeclarationSyntax>(
DataTemplateProvider,
$"{context.TemplatePrefix}EntityIdStruct",
new
{
name = context.Name
});
// MA - Merge attributes and members based on configuration.
return(@struct
.WithAttributeLists(
UnifyAttributesLists(@struct.AttributeLists, GenerateAttributes(context))
)
.WithMembers(
UnifyMembers(@struct.Members, await GenerateMembersAsync(context))
));
}
private async Task <MemberDeclarationSyntax> GetSyntaxAsync(StructDeclarationSyntax @struct)
{
var context = new EntityIdGenerationContext(
@struct,
_backingType,
typeConverter: _generateTypeConverter,
jsonNetConverter: _generateJsonNetConverter);
EntityIdSyntaxGeneratorBase generator = null;
if (_backingType == typeof(int))
{
generator = new Int32EntityIdSyntaxGenerator();
}
if (generator is object)
{
return(await generator.GenerateSyntaxAsync(context));
}
throw new InvalidOperationException($"The backing type {_backingType} is not supported for entity ID generation.");
}
public async Task GenerateStructAsync_GeneratesStruct_WithValueProperty()
{
// Arrange
var context = new EntityIdGenerationContext(
SyntaxFactory.StructDeclaration("EntityId"),
typeConverter: false,
jsonNetConverter: false);
// Act
var @struct = await Int32EntityIdSyntaxGenerator.GenerateStructAsync(context);
// Assert
AssertHasProperty(
@struct,
name: "Value",
type: "int",
(member) =>
{
AssertHasModifier(member, SyntaxKind.PublicKeyword);
AssertHasAccessor(member, SyntaxKind.GetAccessorDeclaration);
AssertDoesNotHaveAccessor(member, SyntaxKind.SetAccessorDeclaration);
});
}
/// <summary> /// Generates the required syntax representing a backed entity ID /// </summary> /// <param name="context">The entitity ID generation context.</param> /// <returns>The struct declaration syntax.</returns> public abstract Task <StructDeclarationSyntax> GenerateSyntaxAsync(EntityIdGenerationContext context);
protected async Task <SyntaxList <MemberDeclarationSyntax> > GenerateMembersAsync(EntityIdGenerationContext context)
{
var members = new List <MemberDeclarationSyntax>();
var templateData = new
{
name = context.Name
};
if (context.TypeConverter)
{
var typeConverter = await CodeGen.FromTemplate <ClassDeclarationSyntax>(
DataTemplateProvider,
$"{context.TemplatePrefix}EntityIdStructTypeConverter",
templateData);
members.Add(typeConverter);
}
if (context.JsonNetConverter)
{
var jsonConverter = await CodeGen.FromTemplate <ClassDeclarationSyntax>(
DataTemplateProvider,
$"{context.TemplatePrefix}EntityIdStructJsonConverter",
templateData);
members.Add(jsonConverter);
}
return(List(members));
}
/// <inheritdoc /> public override Task <StructDeclarationSyntax> GenerateSyntaxAsync(EntityIdGenerationContext context) => GenerateStructAsync(context);
