public async Task VerifyGetFixesWhenUsingSystemDoesNotExist()
{
var code = File.ReadAllText(
$@"Targets\{nameof(IsBusinessObjectSerializableMakeSerializableCodeFixTests)}.{(nameof(this.VerifyGetFixesWhenUsingSystemDoesNotExist))}.cs");
var document = TestHelpers.Create(code);
var tree = await document.GetSyntaxTreeAsync();
var diagnostics = await TestHelpers.GetDiagnosticsAsync(code, new IsBusinessObjectSerializableAnalyzer());
var sourceSpan = diagnostics[0].Location.SourceSpan;
var actions = new List<CodeAction>();
var codeActionRegistration = new Action<CodeAction, ImmutableArray<Diagnostic>>(
(a, _) => { actions.Add(a); });
var fix = new IsBusinessObjectSerializableMakeSerializableCodeFix();
var codeFixContext = new CodeFixContext(document, diagnostics[0],
codeActionRegistration, new CancellationToken(false));
await fix.RegisterCodeFixesAsync(codeFixContext);
Assert.AreEqual(2, actions.Count, nameof(actions.Count));
await TestHelpers.VerifyActionAsync(actions,
IsBusinessObjectSerializableMakeSerializableCodeFixConstants.AddSystemSerializableDescription, document,
tree, $"{Environment.NewLine}[System.Serializable]");
await TestHelpers.VerifyActionAsync(actions,
IsBusinessObjectSerializableMakeSerializableCodeFixConstants.AddSerializableAndUsingDescription, document,
tree, $"using System;{Environment.NewLine}{Environment.NewLine}[Serializable]");
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
if (context.CancellationToken.IsCancellationRequested)
{
return;
}
var diagnostic = context.Diagnostics.First();
var classNode = root.FindNode(diagnostic.Location.SourceSpan) as ClassDeclarationSyntax;
if (context.CancellationToken.IsCancellationRequested)
{
return;
}
if (root.HasUsing(IsBusinessObjectSerializableMakeSerializableCodeFixConstants.SystemNamespace))
{
IsBusinessObjectSerializableMakeSerializableCodeFix.AddCodeFixWhenSystemUsingExists(
context, root, diagnostic, classNode);
}
else
{
IsBusinessObjectSerializableMakeSerializableCodeFix.AddCodeFixWhenSystemUsingDoesNotExist(
context, root, diagnostic, classNode);
}
}
private static void AddCodeFix(CodeFixContext context, SyntaxNode root,
Diagnostic diagnostic, ClassDeclarationSyntax classNode)
{
var newRoot = IsBusinessObjectSerializableMakeSerializableCodeFix.AddAttribute(
root, classNode, IsBusinessObjectSerializableMakeSerializableCodeFixConstants.SerializableName);
if (!root.HasUsing(IsBusinessObjectSerializableMakeSerializableCodeFixConstants.SystemNamespace))
{
newRoot = (newRoot as CompilationUnitSyntax).AddUsings(
SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(
IsBusinessObjectSerializableMakeSerializableCodeFixConstants.SystemNamespace)));
}
if (!root.HasUsing(IsBusinessObjectSerializableMakeSerializableCodeFixConstants.CslaSerializationNamespace))
{
newRoot = (newRoot as CompilationUnitSyntax).AddUsings(
SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(
IsBusinessObjectSerializableMakeSerializableCodeFixConstants.CslaSerializationNamespace)));
}
context.RegisterCodeFix(
CodeAction.Create(
IsBusinessObjectSerializableMakeSerializableCodeFixConstants.AddSerializableAndUsingDescription,
_ => Task.FromResult <Document>(context.Document.WithSyntaxRoot(newRoot))), diagnostic);
}
public void VerifyGetFixableDiagnosticIds()
{
var fix = new IsBusinessObjectSerializableMakeSerializableCodeFix();
var ids = fix.FixableDiagnosticIds.ToList();
Assert.AreEqual(1, ids.Count, nameof(ids.Count));
Assert.AreEqual(IsBusinessObjectSerializableConstants.DiagnosticId, ids[0],
nameof(IsBusinessObjectSerializableConstants.DiagnosticId));
}
public void VerifyGetFixableDiagnosticIds()
{
var fix = new IsBusinessObjectSerializableMakeSerializableCodeFix();
var ids = fix.FixableDiagnosticIds.ToList();
Assert.AreEqual(1, ids.Count, nameof(ids.Count));
Assert.AreEqual(ids[0], Constants.AnalyzerIdentifiers.IsBusinessObjectSerializable,
nameof(Constants.AnalyzerIdentifiers.IsBusinessObjectSerializable));
}
private static void AddCodeFixWhenSystemUsingExists(CodeFixContext context, SyntaxNode root,
Diagnostic diagnostic, ClassDeclarationSyntax classNode)
{
var newRoot = IsBusinessObjectSerializableMakeSerializableCodeFix.AddAttribute(
root, classNode, IsBusinessObjectSerializableMakeSerializableCodeFixConstants.SerializableName);
context.RegisterCodeFix(
CodeAction.Create(
IsBusinessObjectSerializableMakeSerializableCodeFixConstants.AddSerializableDescription,
_ => Task.FromResult <Document>(context.Document.WithSyntaxRoot(newRoot))), diagnostic);
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
context.CancellationToken.ThrowIfCancellationRequested();
var diagnostic = context.Diagnostics.First();
var classNode = root.FindNode(diagnostic.Location.SourceSpan) as ClassDeclarationSyntax;
context.CancellationToken.ThrowIfCancellationRequested();
IsBusinessObjectSerializableMakeSerializableCodeFix.AddCodeFix(
context, root, diagnostic, classNode);
}
private static void AddCodeFixWhenSystemUsingDoesNotExist(CodeFixContext context, SyntaxNode root,
Diagnostic diagnostic, ClassDeclarationSyntax classNode)
{
var qualifiedRoot = IsBusinessObjectSerializableMakeSerializableCodeFix.AddAttribute(
root, classNode, IsBusinessObjectSerializableMakeSerializableCodeFixConstants.SerializableFullName);
context.RegisterCodeFix(
CodeAction.Create(
IsBusinessObjectSerializableMakeSerializableCodeFixConstants.AddSystemSerializableDescription,
_ => Task.FromResult <Document>(context.Document.WithSyntaxRoot(qualifiedRoot))), diagnostic);
var unqualifiedRoot = IsBusinessObjectSerializableMakeSerializableCodeFix.AddAttribute(
root, classNode, IsBusinessObjectSerializableMakeSerializableCodeFixConstants.SerializableName);
unqualifiedRoot = (unqualifiedRoot as CompilationUnitSyntax).AddUsings(
SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(
IsBusinessObjectSerializableMakeSerializableCodeFixConstants.SystemNamespace)));
context.RegisterCodeFix(
CodeAction.Create(
IsBusinessObjectSerializableMakeSerializableCodeFixConstants.AddSerializableAndUsingDescription,
_ => Task.FromResult <Document>(context.Document.WithSyntaxRoot(unqualifiedRoot))), diagnostic);
}
