678 lines
22 KiB
C#
678 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using MapTo.Extensions;
|
|
using MapTo.Sources;
|
|
using MapTo.Tests.Extensions;
|
|
using MapTo.Tests.Infrastructure;
|
|
using Microsoft.CodeAnalysis;
|
|
using Microsoft.CodeAnalysis.CSharp;
|
|
using Microsoft.CodeAnalysis.CSharp.Syntax;
|
|
using Microsoft.CodeAnalysis.Text;
|
|
using Shouldly;
|
|
using Xunit;
|
|
using static MapTo.Extensions.GeneratorExecutionContextExtensions;
|
|
|
|
namespace MapTo.Tests
|
|
{
|
|
public class Tests
|
|
{
|
|
private const int Indent1 = 4;
|
|
private const int Indent2 = Indent1 * 2;
|
|
private const int Indent3 = Indent1 * 3;
|
|
private static readonly Location IgnoreLocation = Location.None;
|
|
|
|
private static readonly Dictionary<string, string> DefaultAnalyzerOptions = new()
|
|
{
|
|
[GetBuildPropertyName(nameof(SourceGenerationOptions.GenerateXmlDocument))] = "false"
|
|
};
|
|
|
|
private static readonly string ExpectedAttribute = $@"{Constants.GeneratedFilesHeader}
|
|
using System;
|
|
|
|
namespace MapTo
|
|
{{
|
|
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
|
|
public sealed class MapFromAttribute : Attribute
|
|
{{
|
|
public MapFromAttribute(Type sourceType)
|
|
{{
|
|
SourceType = sourceType;
|
|
}}
|
|
|
|
public Type SourceType {{ get; }}
|
|
}}
|
|
}}";
|
|
|
|
private record SourceGeneratorOptions(
|
|
bool UseMapToNamespace = false,
|
|
string SourceClassNamespace = "Test.Models",
|
|
int ClassPropertiesCount = 3,
|
|
int SourceClassPropertiesCount = 3,
|
|
Action<StringBuilder> PropertyBuilder = null,
|
|
Action<StringBuilder> SourcePropertyBuilder = null);
|
|
|
|
private static string GetSourceText(SourceGeneratorOptions options = null)
|
|
{
|
|
const string ns = "Test";
|
|
options ??= new SourceGeneratorOptions();
|
|
var hasDifferentSourceNamespace = options.SourceClassNamespace != ns;
|
|
var builder = new StringBuilder();
|
|
|
|
builder.AppendLine("//");
|
|
builder.AppendLine("// Test source code.");
|
|
builder.AppendLine("//");
|
|
builder.AppendLine();
|
|
|
|
if (options.UseMapToNamespace)
|
|
{
|
|
builder.AppendFormat("using {0};", Constants.RootNamespace).AppendLine();
|
|
}
|
|
|
|
builder
|
|
.AppendFormat("using {0};", options.SourceClassNamespace)
|
|
.AppendLine()
|
|
.AppendLine();
|
|
|
|
builder
|
|
.AppendFormat("namespace {0}", ns)
|
|
.AppendOpeningBracket();
|
|
|
|
if (hasDifferentSourceNamespace && options.UseMapToNamespace)
|
|
{
|
|
builder
|
|
.PadLeft(Indent1)
|
|
.AppendFormat("using {0};", options.SourceClassNamespace)
|
|
.AppendLine()
|
|
.AppendLine();
|
|
}
|
|
|
|
builder
|
|
.PadLeft(Indent1)
|
|
.AppendLine(options.UseMapToNamespace ? "[MapFrom(typeof(Baz))]": "[MapTo.MapFrom(typeof(Baz))]")
|
|
.PadLeft(Indent1).Append("public partial class Foo")
|
|
.AppendOpeningBracket(Indent1);
|
|
|
|
for (var i = 1; i <= options.ClassPropertiesCount; i++)
|
|
{
|
|
builder
|
|
.PadLeft(Indent2)
|
|
.AppendLine(i % 2 == 0 ? $"public int Prop{i} {{ get; set; }}" : $"public int Prop{i} {{ get; }}");
|
|
}
|
|
|
|
options.PropertyBuilder?.Invoke(builder);
|
|
|
|
builder
|
|
.AppendClosingBracket(Indent1, false)
|
|
.AppendClosingBracket()
|
|
.AppendLine()
|
|
.AppendLine();
|
|
|
|
builder
|
|
.AppendFormat("namespace {0}", options.SourceClassNamespace)
|
|
.AppendOpeningBracket()
|
|
.PadLeft(Indent1).Append("public class Baz")
|
|
.AppendOpeningBracket(Indent1);
|
|
|
|
for (var i = 1; i <= options.SourceClassPropertiesCount; i++)
|
|
{
|
|
builder
|
|
.PadLeft(Indent2)
|
|
.AppendLine(i % 2 == 0 ? $"public int Prop{i} {{ get; set; }}" : $"public int Prop{i} {{ get; }}");
|
|
}
|
|
|
|
options.SourcePropertyBuilder?.Invoke(builder);
|
|
|
|
builder
|
|
.AppendClosingBracket(Indent1, false)
|
|
.AppendClosingBracket();
|
|
|
|
return builder.ToString();
|
|
}
|
|
|
|
[Fact]
|
|
public void VerifyIgnorePropertyAttribute()
|
|
{
|
|
// Arrange
|
|
const string source = "";
|
|
var expectedAttribute = $@"
|
|
{Constants.GeneratedFilesHeader}
|
|
using System;
|
|
|
|
namespace MapTo
|
|
{{
|
|
[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
|
|
public sealed class IgnorePropertyAttribute : Attribute {{ }}
|
|
}}
|
|
".Trim();
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees.ShouldContainSource(IgnorePropertyAttributeSource.AttributeName, expectedAttribute);
|
|
}
|
|
|
|
[Fact]
|
|
public void VerifyMapToAttribute()
|
|
{
|
|
// Arrange
|
|
const string source = "";
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees.ShouldContainSource(MapFromAttributeSource.AttributeName, ExpectedAttribute);
|
|
}
|
|
|
|
[Fact]
|
|
public void When_FoundMatchingPropertyNameWithDifferentTypes_Should_ReportError()
|
|
{
|
|
// Arrange
|
|
var source = GetSourceText(new SourceGeneratorOptions(
|
|
true,
|
|
PropertyBuilder: builder =>
|
|
{
|
|
builder
|
|
.PadLeft(Indent2).AppendLine("public string Prop4 { get; set; }");
|
|
},
|
|
SourcePropertyBuilder: builder => builder.PadLeft(Indent2).AppendLine("public int Prop4 { get; set; }")));
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
|
|
|
|
// Assert
|
|
var expectedError = DiagnosticProvider.NoMatchingPropertyTypeFoundError(GetSourcePropertySymbol("Prop4", compilation));
|
|
|
|
diagnostics.ShouldBeUnsuccessful(expectedError);
|
|
}
|
|
|
|
[Fact]
|
|
public void When_IgnorePropertyAttributeIsSpecified_Should_NotGenerateMappingsForThatProperty()
|
|
{
|
|
// Arrange
|
|
var source = GetSourceText(new SourceGeneratorOptions(
|
|
true,
|
|
PropertyBuilder: builder =>
|
|
{
|
|
builder
|
|
.PadLeft(Indent2).AppendLine("[IgnoreProperty]")
|
|
.PadLeft(Indent2).AppendLine("public int Prop4 { get; set; }");
|
|
},
|
|
SourcePropertyBuilder: builder => builder.PadLeft(Indent2).AppendLine("public int Prop4 { get; set; }")));
|
|
|
|
var expectedResult = @"
|
|
partial class Foo
|
|
{
|
|
public Foo(Test.Models.Baz baz)
|
|
{
|
|
if (baz == null) throw new ArgumentNullException(nameof(baz));
|
|
|
|
Prop1 = baz.Prop1;
|
|
Prop2 = baz.Prop2;
|
|
Prop3 = baz.Prop3;
|
|
}
|
|
".Trim();
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees.Last().ToString().ShouldContain(expectedResult);
|
|
}
|
|
|
|
[Fact]
|
|
public void When_MappingsModifierOptionIsSetToInternal_Should_GenerateThoseMethodsWithInternalAccessModifier()
|
|
{
|
|
// Arrange
|
|
var source = GetSourceText();
|
|
var configOptions = new Dictionary<string, string>
|
|
{
|
|
[GetBuildPropertyName(nameof(SourceGenerationOptions.GeneratedMethodsAccessModifier))] = "Internal",
|
|
[GetBuildPropertyName(nameof(SourceGenerationOptions.GenerateXmlDocument))] = "false"
|
|
};
|
|
|
|
var expectedExtension = @"
|
|
internal static partial class BazToFooExtensions
|
|
{
|
|
internal static Foo ToFoo(this Test.Models.Baz baz)
|
|
{
|
|
return baz == null ? null : new Foo(baz);
|
|
}
|
|
}".Trim();
|
|
|
|
var expectedFactory = @"
|
|
internal static Foo From(Test.Models.Baz baz)
|
|
{
|
|
return baz == null ? null : new Foo(baz);
|
|
}".Trim();
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: configOptions);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
|
|
var syntaxTree = compilation.SyntaxTrees.Last().ToString();
|
|
syntaxTree.ShouldContain(expectedFactory);
|
|
syntaxTree.ShouldContain(expectedExtension);
|
|
}
|
|
|
|
[Fact]
|
|
public void When_MapToAttributeFound_Should_GenerateTheClass()
|
|
{
|
|
// Arrange
|
|
const string source = @"
|
|
using MapTo;
|
|
|
|
namespace Test
|
|
{
|
|
[MapFrom(typeof(Baz))]
|
|
public partial class Foo
|
|
{
|
|
public int Prop1 { get; set; }
|
|
}
|
|
|
|
public class Baz
|
|
{
|
|
public int Prop1 { get; set; }
|
|
}
|
|
}
|
|
";
|
|
|
|
const string expectedResult = @"
|
|
// <auto-generated />
|
|
using System;
|
|
|
|
namespace Test
|
|
{
|
|
partial class Foo
|
|
{
|
|
public Foo(Test.Baz baz)
|
|
{
|
|
if (baz == null) throw new ArgumentNullException(nameof(baz));
|
|
|
|
Prop1 = baz.Prop1;
|
|
}
|
|
";
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees.Last().ToString().ShouldStartWith(expectedResult.Trim());
|
|
}
|
|
|
|
[Fact]
|
|
public void When_MapToAttributeFoundWithoutMatchingProperties_Should_ReportError()
|
|
{
|
|
// Arrange
|
|
const string source = @"
|
|
using MapTo;
|
|
|
|
namespace Test
|
|
{
|
|
[MapFrom(typeof(Baz))]
|
|
public partial class Foo { }
|
|
|
|
public class Baz { public int Prop1 { get; set; } }
|
|
}
|
|
";
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source);
|
|
|
|
// Assert
|
|
var fooType = compilation.GetTypeByMetadataName("Test.Foo");
|
|
fooType.ShouldNotBeNull();
|
|
|
|
var bazType = compilation.GetTypeByMetadataName("Test.Baz");
|
|
bazType.ShouldNotBeNull();
|
|
|
|
var expectedDiagnostic = DiagnosticProvider.NoMatchingPropertyFoundError(fooType.Locations.Single(), fooType, bazType);
|
|
var error = diagnostics.FirstOrDefault(d => d.Id == expectedDiagnostic.Id);
|
|
error.ShouldNotBeNull();
|
|
}
|
|
|
|
[Fact]
|
|
public void When_MapToAttributeWithNamespaceFound_Should_GenerateTheClass()
|
|
{
|
|
// Arrange
|
|
const string source = @"
|
|
namespace Test
|
|
{
|
|
[MapTo.MapFrom(typeof(Baz))]
|
|
public partial class Foo { public int Prop1 { get; set; } }
|
|
|
|
public class Baz { public int Prop1 { get; set; } }
|
|
}
|
|
";
|
|
|
|
const string expectedResult = @"
|
|
// <auto-generated />
|
|
using System;
|
|
|
|
namespace Test
|
|
{
|
|
partial class Foo
|
|
{
|
|
public Foo(Test.Baz baz)
|
|
{
|
|
if (baz == null) throw new ArgumentNullException(nameof(baz));
|
|
|
|
Prop1 = baz.Prop1;
|
|
}
|
|
";
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees.Last().ToString().ShouldStartWith(expectedResult.Trim());
|
|
}
|
|
|
|
[Fact]
|
|
public void When_NoMapToAttributeFound_Should_GenerateOnlyTheAttribute()
|
|
{
|
|
// Arrange
|
|
const string source = "";
|
|
var expectedTypes = new[] { IgnorePropertyAttributeSource.AttributeName, MapFromAttributeSource.AttributeName, TypeConverterSource.InterfaceName };
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees
|
|
.Select(s => s.ToString())
|
|
.Where(s => !string.IsNullOrWhiteSpace(s.ToString()))
|
|
.All(s => expectedTypes.Any(s.Contains))
|
|
.ShouldBeTrue();
|
|
}
|
|
|
|
[Fact]
|
|
public void When_SourceTypeHasDifferentNamespace_Should_NotAddToUsings()
|
|
{
|
|
// Arrange
|
|
var source = GetSourceText(new SourceGeneratorOptions(SourceClassNamespace: "Bazaar"));
|
|
|
|
const string expectedResult = @"
|
|
// <auto-generated />
|
|
using System;
|
|
|
|
namespace Test
|
|
";
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees.Last().ToString().ShouldStartWith(expectedResult.Trim());
|
|
}
|
|
|
|
[Fact]
|
|
public void When_SourceTypeHasMatchingProperties_Should_CreateConstructorAndAssignSrcToDest()
|
|
{
|
|
// Arrange
|
|
var source = GetSourceText();
|
|
|
|
const string expectedResult = @"
|
|
partial class Foo
|
|
{
|
|
public Foo(Test.Models.Baz baz)
|
|
{
|
|
if (baz == null) throw new ArgumentNullException(nameof(baz));
|
|
|
|
Prop1 = baz.Prop1;
|
|
Prop2 = baz.Prop2;
|
|
Prop3 = baz.Prop3;
|
|
}
|
|
";
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees.Last().ToString().ShouldContain(expectedResult.Trim());
|
|
}
|
|
|
|
[Fact]
|
|
public void When_SourceTypeHasMatchingProperties_Should_CreateFromStaticMethod()
|
|
{
|
|
// Arrange
|
|
var source = GetSourceText();
|
|
|
|
const string expectedResult = @"
|
|
public static Foo From(Test.Models.Baz baz)
|
|
{
|
|
return baz == null ? null : new Foo(baz);
|
|
}
|
|
";
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees.Last().ToString().ShouldContain(expectedResult.Trim());
|
|
}
|
|
|
|
[Fact]
|
|
public void When_SourceTypeHasMatchingProperties_Should_GenerateToExtensionMethodOnSourceType()
|
|
{
|
|
// Arrange
|
|
var source = GetSourceText();
|
|
|
|
const string expectedResult = @"
|
|
public static partial class BazToFooExtensions
|
|
{
|
|
public static Foo ToFoo(this Test.Models.Baz baz)
|
|
{
|
|
return baz == null ? null : new Foo(baz);
|
|
}
|
|
}
|
|
";
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees.Last().ToString().ShouldContain(expectedResult.Trim());
|
|
}
|
|
|
|
[Fact]
|
|
public void VerifyTypeConverterInterface()
|
|
{
|
|
// Arrange
|
|
const string source = "";
|
|
var expectedInterface = $@"
|
|
{Constants.GeneratedFilesHeader}
|
|
|
|
namespace MapTo
|
|
{{
|
|
public interface ITypeConverter<in TSource, out TDestination>
|
|
{{
|
|
TDestination Convert(TSource source);
|
|
}}
|
|
}}
|
|
".Trim();
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees.ShouldContainSource(TypeConverterSource.InterfaceName, expectedInterface);
|
|
}
|
|
|
|
[Fact]
|
|
public void VerifyMapTypeConverterAttribute()
|
|
{
|
|
// Arrange
|
|
const string source = "";
|
|
var expectedInterface = $@"
|
|
{Constants.GeneratedFilesHeader}
|
|
using System;
|
|
|
|
namespace MapTo
|
|
{{
|
|
[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
|
|
public sealed class MapTypeConverterAttribute : Attribute
|
|
{{
|
|
public MapTypeConverterAttribute(Type converter)
|
|
{{
|
|
Converter = converter;
|
|
}}
|
|
|
|
public Type Converter {{ get; }}
|
|
}}
|
|
}}
|
|
".Trim();
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees.ShouldContainSource(MapTypeConverterAttributeSource.AttributeName, expectedInterface);
|
|
}
|
|
|
|
[Fact]
|
|
public void When_FoundMatchingPropertyNameWithDifferentImplicitlyConvertibleType_Should_GenerateTheProperty()
|
|
{
|
|
// Arrange
|
|
var source = GetSourceText(new SourceGeneratorOptions(
|
|
true,
|
|
PropertyBuilder: builder =>
|
|
{
|
|
builder
|
|
.PadLeft(Indent2).AppendLine("public long Prop4 { get; set; }");
|
|
},
|
|
SourcePropertyBuilder: builder => builder.PadLeft(Indent2).AppendLine("public int Prop4 { get; set; }")));
|
|
|
|
var expectedResult = @"
|
|
partial class Foo
|
|
{
|
|
public Foo(Test.Models.Baz baz)
|
|
{
|
|
if (baz == null) throw new ArgumentNullException(nameof(baz));
|
|
|
|
Prop1 = baz.Prop1;
|
|
Prop2 = baz.Prop2;
|
|
Prop3 = baz.Prop3;
|
|
Prop4 = baz.Prop4;
|
|
}
|
|
".Trim();
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees.Last().ToString().ShouldContain(expectedResult);
|
|
}
|
|
|
|
[Fact]
|
|
public void When_FoundMatchingPropertyNameWithIncorrectConverterType_ShouldReportError()
|
|
{
|
|
// Arrange
|
|
var source = GetSourceText(new SourceGeneratorOptions(
|
|
true,
|
|
PropertyBuilder: builder =>
|
|
{
|
|
builder
|
|
.PadLeft(Indent2).AppendLine("[IgnoreProperty]")
|
|
.PadLeft(Indent2).AppendLine("public long IgnoreMe { get; set; }")
|
|
.PadLeft(Indent2).AppendLine("[MapTypeConverter(typeof(Prop4Converter))]")
|
|
.PadLeft(Indent2).AppendLine("public long Prop4 { get; set; }");
|
|
},
|
|
SourcePropertyBuilder: builder => builder.PadLeft(Indent2).AppendLine("public string Prop4 { get; set; }")));
|
|
|
|
source += @"
|
|
namespace Test
|
|
{
|
|
using MapTo;
|
|
|
|
public class Prop4Converter: ITypeConverter<string, int>
|
|
{
|
|
public int Convert(string source) => int.Parse(source);
|
|
}
|
|
}
|
|
";
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
|
|
|
|
// Assert
|
|
var expectedError = DiagnosticProvider.InvalidTypeConverterGenericTypesError(GetSourcePropertySymbol("Prop4", compilation), GetSourcePropertySymbol("Prop4", compilation, "Baz"));
|
|
diagnostics.ShouldBeUnsuccessful(expectedError);
|
|
}
|
|
|
|
[Fact]
|
|
public void When_FoundMatchingPropertyNameWithConverterType_ShouldUseTheConverterToAssignProperties()
|
|
{
|
|
// Arrange
|
|
var source = GetSourceText(new SourceGeneratorOptions(
|
|
true,
|
|
PropertyBuilder: builder =>
|
|
{
|
|
builder
|
|
.PadLeft(Indent2).AppendLine("[MapTypeConverter(typeof(Prop4Converter))]")
|
|
.PadLeft(Indent2).AppendLine("public long Prop4 { get; set; }");
|
|
},
|
|
SourcePropertyBuilder: builder => builder.PadLeft(Indent2).AppendLine("public string Prop4 { get; set; }")));
|
|
|
|
source += @"
|
|
namespace Test
|
|
{
|
|
using MapTo;
|
|
|
|
public class Prop4Converter: ITypeConverter<string, long>
|
|
{
|
|
public long Convert(string source) => long.Parse(source);
|
|
}
|
|
}
|
|
";
|
|
|
|
const string expectedSyntax = "Prop4 = new Test.Prop4Converter().Convert(baz.Prop4);";
|
|
|
|
// Act
|
|
var (compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
|
|
|
|
// Assert
|
|
diagnostics.ShouldBeSuccessful();
|
|
compilation.SyntaxTrees.Last().ToString().ShouldContain(expectedSyntax);
|
|
}
|
|
|
|
private static PropertyDeclarationSyntax GetPropertyDeclarationSyntax(SyntaxTree syntaxTree, string targetPropertyName, string targetClass = "Foo")
|
|
{
|
|
return syntaxTree.GetRoot()
|
|
.DescendantNodes()
|
|
.OfType<ClassDeclarationSyntax>()
|
|
.Single(c => c.Identifier.ValueText == targetClass)
|
|
.DescendantNodes()
|
|
.OfType<PropertyDeclarationSyntax>()
|
|
.Single(p => p.Identifier.ValueText == targetPropertyName);
|
|
}
|
|
|
|
private static IPropertySymbol GetSourcePropertySymbol(string propertyName, Compilation compilation, string targetClass = "Foo")
|
|
{
|
|
var syntaxTree = compilation.SyntaxTrees.First();
|
|
var propSyntax = GetPropertyDeclarationSyntax(syntaxTree, propertyName, targetClass);
|
|
|
|
var semanticModel = compilation.GetSemanticModel(syntaxTree);
|
|
return semanticModel.GetDeclaredSymbol(propSyntax);
|
|
}
|
|
}
|
|
} |