public void ConstructMiddlewareConstructor_Produces_Expected_Result_When_Additonal_Statements_Present()
{
var additionalStatements = new[] { SyntaxHelperSetupFixture.AdditionalStatement };
var actualConstructorText = MiddlewareSyntaxHelper.ConstructMiddlewareConstructor(MiddlewareClassName, additionalStatements).NormalizeWhitespace().ToFullString();
Assert.AreEqual(ExpectedModifiedMiddlewareConstructorText, actualConstructorText);
}
public void ConstructMiddlewareInvokeMethod_Producers_Expected_Result_When_Post_Handle_Statements_Present()
{
var additionalStatements = new[] { SyntaxHelperSetupFixture.AdditionalStatement };
var actualInvokeText = MiddlewareSyntaxHelper.ConstructMiddlewareInvokeMethod(postHandleStatements: additionalStatements).NormalizeWhitespace().ToFullString();
Assert.AreEqual(ExpectedPostHandledInvokeText, actualInvokeText);
}
public void AddMiddlewareFields_Produces_Expected_Basic_Result()
{
var expectedDeclarationStrings = new[] { ExpectedDelegateFieldDeclarationText };
var actualDeclarationStrings = MiddlewareSyntaxHelper.AddMiddlewareFields().Select(declaration => declaration.NormalizeWhitespace().ToFullString());
Assert.AreEqual(expectedDeclarationStrings, actualDeclarationStrings);
}
private void HandleLifecycleMethod(MethodDeclarationSyntax methodDeclaration, WebFormsAppLifecycleEvent lifecycleEvent)
{
var statements = methodDeclaration.Body.Statements;
var lambdaExpression = LifecycleManagerService.ContentIsPreHandle(lifecycleEvent) ?
MiddlewareSyntaxHelper.ConstructMiddlewareLambda(preHandleStatements: statements) :
MiddlewareSyntaxHelper.ConstructMiddlewareLambda(postHandleStatements: statements);
_lifecycleManager.RegisterMiddlewareLambda(lifecycleEvent, lambdaExpression);
}
public StatementSyntax GetPipelineAdditionStatement()
{
if (WasSplit)
{
return(MiddlewareSyntaxHelper.ConstructMiddlewareRegistrationSyntax(NewClassName, LifecycleEvent.ToString(), OriginClassName));
}
return(MiddlewareSyntaxHelper.ConstructMiddlewareRegistrationSyntax(NewClassName, LifecycleEvent.ToString()));
}
public void AddMiddlewareFields_Produces_Expected_Result_When_Additional_Fields_Present()
{
var additionalFieldDeclarations = new[] { SyntaxHelperSetupFixture.AdditionalFieldDeclaration };
var expectedDeclarationStrings = new[] { ExpectedDelegateFieldDeclarationText, SyntaxHelperSetupFixture.AdditionalFieldText };
var actualDeclarationStrings = MiddlewareSyntaxHelper.AddMiddlewareFields(additionalFieldDeclarations)
.Select(declaration => declaration.NormalizeWhitespace().ToFullString());
Assert.AreEqual(expectedDeclarationStrings, actualDeclarationStrings);
}
public void ConstructMiddlewareClass_Produces_Expected_Fully_Modified_Result()
{
var additionalStatements = new[] { SyntaxHelperSetupFixture.AdditionalStatement };
var modifiedStartupClass = MiddlewareSyntaxHelper.ConstructMiddlewareClass(
middlewareClassName: MiddlewareClassName,
constructorAdditionalStatements: additionalStatements,
preHandleStatements: additionalStatements,
postHandleStatements: additionalStatements,
additionalFieldDeclarations: new[] { SyntaxHelperSetupFixture.AdditionalFieldDeclaration },
additionalPropertyDeclarations: new[] { SyntaxHelperSetupFixture.AdditionalPropertyDeclaration },
additionalMethodDeclarations: new[] { SyntaxHelperSetupFixture.AdditionalMethodDeclaration });
Assert.AreEqual(ExpectedFullyModifiedMiddlewareClassText, modifiedStartupClass.NormalizeWhitespace().ToFullString());
}
public StatementSyntax GetPipelineAdditionStatement()
{
return(MiddlewareSyntaxHelper.ConstructMiddlewareLambdaRegistrationSyntax(MiddlewareLambda, LifecycleEvent.ToString()));
}
public void ConstructMiddlewareClass_Produces_Expected_Basic_Result()
{
Assert.AreEqual(ExpectedBasicMiddlewareClassText, MiddlewareSyntaxHelper.ConstructMiddlewareClass(MiddlewareClassName).NormalizeWhitespace().ToFullString());
}
public void ConstructMiddlewareLambdaRegistrationSyntax_Correctly_Builds_Basic_Lambda_Registration()
{
var registration = MiddlewareSyntaxHelper.ConstructMiddlewareLambdaRegistrationSyntax(MiddlewareSyntaxHelper.ConstructMiddlewareLambda());
Assert.AreEqual(ExpectedMiddlewareLambdaRegistrationString, registration.NormalizeWhitespace().ToFullString());
}
public void ConstructMiddlewareLambda_Correctly_Builds_Basic_Lambda()
{
Assert.AreEqual(ExpectedMiddlwareLambdaText, MiddlewareSyntaxHelper.ConstructMiddlewareLambda().NormalizeWhitespace().ToFullString());
}
public void ConstructMiddlewareInvokeMethod_Producers_Expected_Basic_Result()
{
Assert.AreEqual(ExpectedBasicInvokeText, MiddlewareSyntaxHelper.ConstructMiddlewareInvokeMethod().NormalizeWhitespace().ToFullString());
}
public override Task <IEnumerable <FileInformation> > MigrateClassAsync()
{
LogStart();
_metricsContext.CollectActionMetrics(WebFormsActionType.ClassConversion, ActionName);
var className = _originalDeclarationSyntax.Identifier.ToString();
var namespaceName = _originalClassSymbol.ContainingNamespace?.ToDisplayString();
// NOTE: Removed temporarily until usings can be better determined, at the moment, too
// many are being removed
//var requiredNamespaceNames = _sourceFileSemanticModel
// .GetNamespacesReferencedByType(_originalDeclarationSyntax)
// .Select(namespaceSymbol => namespaceSymbol.ToDisplayString());
var requiredNamespaceNames = _sourceFileSemanticModel.GetOriginalUsingNamespaces()
.Union(MiddlewareSyntaxHelper.RequiredNamespaces);
requiredNamespaceNames = CodeSyntaxHelper.RemoveFrameworkUsings(requiredNamespaceNames);
// Make this call once now so we don't have to keep doing it later
var originalDescendantNodes = _originalDeclarationSyntax.DescendantNodes();
var keepableMethods = originalDescendantNodes.OfType <MethodDeclarationSyntax>();
var processRequestMethod = keepableMethods.Where(method => LifecycleManagerService.IsProcessRequestMethod(method)).SingleOrDefault();
IEnumerable <StatementSyntax> preHandleStatements;
if (processRequestMethod != null)
{
preHandleStatements = processRequestMethod.Body.Statements.AddComment(string.Format(Constants.CodeOriginCommentTemplate, Constants.ProcessRequestMethodName));
keepableMethods = keepableMethods.Where(method => !method.IsEquivalentTo(processRequestMethod));
_lifecycleManager.RegisterMiddlewareClass(WebFormsAppLifecycleEvent.RequestHandlerExecute, className, namespaceName, className, false);
}
else
{
preHandleStatements = new[]
{
CodeSyntaxHelper.GetBlankLine().AddComment(string.Format(Constants.IdentificationFailureCommentTemplate, ProcessRequestDiscovery, InvokePopulationOperation))
};
}
// We have completed any possible registration by this point
_lifecycleManager.NotifyMiddlewareSourceProcessed();
var fileText = string.Empty;
try
{
var middlewareClassDeclaration = MiddlewareSyntaxHelper.ConstructMiddlewareClass(
middlewareClassName: className,
shouldContinueAfterInvoke: false,
constructorAdditionalStatements: originalDescendantNodes.OfType <ConstructorDeclarationSyntax>().FirstOrDefault()?.Body?.Statements,
preHandleStatements: preHandleStatements,
additionalFieldDeclarations: originalDescendantNodes.OfType <FieldDeclarationSyntax>(),
additionalPropertyDeclarations: originalDescendantNodes.OfType <PropertyDeclarationSyntax>(),
additionalMethodDeclarations: keepableMethods);
var namespaceNode = CodeSyntaxHelper.BuildNamespace(namespaceName, middlewareClassDeclaration);
fileText = CodeSyntaxHelper.GetFileSyntaxAsString(namespaceNode, CodeSyntaxHelper.BuildUsingStatements(requiredNamespaceNames));
}
catch (Exception e)
{
LogHelper.LogError(e, $"{Rules.Config.Constants.WebFormsErrorTag}Failed to construct new HttpHandler file content from {OriginalClassName} class at {_fullPath}");
}
DoCleanUp();
LogEnd();
// Http modules are turned into middleware and so we use a new middleware directory
var newRelativePath = FilePathHelper.RemoveDuplicateDirectories(Path.Combine(Constants.MiddlewareDirectoryName, FilePathHelper.AlterFileName(_relativePath, newFileName: className)));
// TODO: Potentially remove certain folders from beginning of relative path
var result = new[] { new FileInformation(newRelativePath, Encoding.UTF8.GetBytes(fileText)) };
return(Task.FromResult((IEnumerable <FileInformation>)result));
}
