public async Task AddFileFromTemplateAsync_Throws_If_Template_Processing_Has_Exceptions()
{
var mockFilesLocator = new Mock <IFilesLocator>();
var mockTemplating = new Mock <ITemplating>();
var mockFileSystem = new MockFileSystem();
var templateName = "TemplateName";
var templatePath = "C:\template.cshtml";
var templateContent = "TemplateContent";
var processingException = new TemplateProcessingException(new[] { "Error1" }, string.Empty);
mockFilesLocator.Setup(fl => fl.GetFilePath(templateName, It.IsAny <IEnumerable <string> >()))
.Returns(templatePath);
mockFileSystem.WriteAllText(templatePath, templateContent);
mockTemplating.Setup(templating => templating.RunTemplateAsync(templateContent, null))
.Returns(Task.FromResult(new TemplateResult()
{
ProcessingException = processingException
}));
var codeGeneratorActionService = new CodeGeneratorActionsService(
mockTemplating.Object, mockFilesLocator.Object, mockFileSystem);
var ex = await Assert.ThrowsAsync <InvalidOperationException>(async() =>
await codeGeneratorActionService.AddFileFromTemplateAsync("Dummy",
templateName,
new[] { "TemplateFolder1", "TemplateFolder2" },
null));
Assert.Equal("There was an error running the template " + templatePath + ": Template Processing Failed:Error1", ex.Message);
}
public async Task AddFileFromTemplateAsync_Writes_If_Template_Processing_Is_Successful()
{
var mockFilesLocator = new Mock <IFilesLocator>();
var mockTemplating = new Mock <ITemplating>();
var mockFileSystem = new MockFileSystem();
var templateName = "TemplateName";
var templatePath = "C:\template.cshtml";
var templateContent = "TemplateContent";
var outputPath = @"C:\Output.txt";
var generatedText = "GeneratedText";
mockFilesLocator.Setup(fl => fl.GetFilePath(templateName, It.IsAny <IEnumerable <string> >()))
.Returns(templatePath);
mockFileSystem.WriteAllText(templatePath, templateContent);
mockTemplating.Setup(templating => templating.RunTemplateAsync(templateContent, null))
.Returns(Task.FromResult(new TemplateResult()
{
ProcessingException = null,
GeneratedText = generatedText
}));
var codeGeneratorActionService = new CodeGeneratorActionsService(
mockTemplating.Object, mockFilesLocator.Object, mockFileSystem);
await codeGeneratorActionService.AddFileFromTemplateAsync(outputPath,
templateName,
new[] { "TemplateFolder1", "TemplateFolder2" },
null);
Assert.True(mockFileSystem.FileExists(outputPath));
Assert.Equal(generatedText, mockFileSystem.ReadAllText(outputPath));
}
public override async Task Generate(CommandLineGeneratorModel controllerGeneratorModel)
{
Contract.Assert(!String.IsNullOrEmpty(controllerGeneratorModel.ModelClass));
string outputPath = ValidateAndGetOutputPath(controllerGeneratorModel);
var modelTypeAndContextModel = await ValidateModelAndGetMetadata(controllerGeneratorModel);
if (string.IsNullOrEmpty(controllerGeneratorModel.ControllerName))
{
//Todo: Pluralize model name
controllerGeneratorModel.ControllerName = modelTypeAndContextModel.ModelType.Name + Constants.ControllerSuffix;
}
var templateModel = new ControllerWithContextTemplateModel(modelTypeAndContextModel.ModelType, modelTypeAndContextModel.DbContextFullName)
{
ControllerName = controllerGeneratorModel.ControllerName,
AreaName = string.Empty, //ToDo
UseAsync = controllerGeneratorModel.UseAsync,
ControllerNamespace = GetControllerNamespace(),
ModelMetadata = modelTypeAndContextModel.ContextProcessingResult.ModelMetadata
};
await CodeGeneratorActionsService.AddFileFromTemplateAsync(outputPath, GetTemplateName(controllerGeneratorModel), TemplateFolders, templateModel);
Logger.LogMessage("Added Controller : " + outputPath.Substring(ApplicationInfo.ApplicationBasePath.Length));
await GenerateViewsIfRequired(controllerGeneratorModel, modelTypeAndContextModel, templateModel.ControllerRootName);
if (modelTypeAndContextModel.ContextProcessingResult.ContextProcessingStatus == ContextProcessingStatus.ContextAddedButRequiresConfig)
{
throw new Exception(string.Format("{0} {1}", CodeGenerators.Mvc.MessageStrings.ScaffoldingSuccessful_unregistered,
CodeGenerators.Mvc.MessageStrings.Scaffolding_additionalSteps));
}
}
public override async Task Generate(CommandLineGeneratorModel controllerGeneratorModel)
{
if (!string.IsNullOrEmpty(controllerGeneratorModel.ControllerName))
{
if (!controllerGeneratorModel.ControllerName.EndsWith(Constants.ControllerSuffix, StringComparison.Ordinal))
{
controllerGeneratorModel.ControllerName = controllerGeneratorModel.ControllerName + Constants.ControllerSuffix;
}
}
else
{
throw new ArgumentException("Controller name is required for an Empty Controller");
}
var layoutDependencyInstaller = ActivatorUtilities.CreateInstance <MvcLayoutDependencyInstaller>(ServiceProvider);
await layoutDependencyInstaller.Execute();
var templateModel = new ClassNameModel(className: controllerGeneratorModel.ControllerName, namespaceName: GetControllerNamespace());
var templateName = "EmptyController.cshtml";
var outputPath = ValidateAndGetOutputPath(controllerGeneratorModel);
await CodeGeneratorActionsService.AddFileFromTemplateAsync(outputPath, templateName, TemplateFolders, templateModel);
Logger.LogMessage("Added Controller : " + outputPath.Substring(ApplicationEnvironment.ApplicationBasePath.Length));
await layoutDependencyInstaller.InstallDependencies();
}
public override async Task Generate(CommandLineGeneratorModel controllerGeneratorModel)
{
Contract.Assert(!String.IsNullOrEmpty(controllerGeneratorModel.ModelClass));
string outputPath = ValidateAndGetOutputPath(controllerGeneratorModel);
var modelTypeAndContextModel = await ValidateModelAndGetMetadata(controllerGeneratorModel);
if (string.IsNullOrEmpty(controllerGeneratorModel.ControllerName))
{
//Todo: Pluralize model name
controllerGeneratorModel.ControllerName = modelTypeAndContextModel.ModelType.Name + Constants.ControllerSuffix;
}
var templateModel = new ControllerWithContextTemplateModel(modelTypeAndContextModel.ModelType, modelTypeAndContextModel.DbContextFullName)
{
ControllerName = controllerGeneratorModel.ControllerName,
AreaName = string.Empty, //ToDo
UseAsync = controllerGeneratorModel.UseAsync,
ControllerNamespace = GetControllerNamespace(),
ModelMetadata = modelTypeAndContextModel.ContextProcessingResult.ModelMetadata
};
await CodeGeneratorActionsService.AddFileFromTemplateAsync(outputPath, GetTemplateName(controllerGeneratorModel), TemplateFolders, templateModel);
Logger.LogMessage("Added Controller : " + outputPath.Substring(ApplicationEnvironment.ApplicationBasePath.Length));
await GenerateViewsIfRequired(controllerGeneratorModel, modelTypeAndContextModel, templateModel.ControllerRootName);
if (modelTypeAndContextModel.ContextProcessingResult.ContextProcessingStatus == ContextProcessingStatus.ContextAddedButRequiresConfig)
{
throw new Exception("Scaffolding generated all the code but the new context created could be registered using dependency injection." +
"There may be additional steps required for the generated code to work. Refer to <forward-link>");
}
}
public override async Task Generate(CommandLineGeneratorModel controllerGeneratorModel)
{
if (!string.IsNullOrEmpty(controllerGeneratorModel.ControllerName))
{
if (!controllerGeneratorModel.ControllerName.EndsWith(Constants.ControllerSuffix, StringComparison.Ordinal))
{
controllerGeneratorModel.ControllerName = controllerGeneratorModel.ControllerName + Constants.ControllerSuffix;
}
}
else
{
throw new ArgumentException(GetRequiredNameError);
}
ValidateNameSpaceName(controllerGeneratorModel);
var layoutDependencyInstaller = ActivatorUtilities.CreateInstance <MvcLayoutDependencyInstaller>(ServiceProvider);
await layoutDependencyInstaller.Execute();
var namespaceName = string.IsNullOrEmpty(controllerGeneratorModel.ControllerNamespace)
? GetDefaultControllerNamespace(controllerGeneratorModel.RelativeFolderPath)
: controllerGeneratorModel.ControllerNamespace;
var templateModel = new ClassNameModel(className: controllerGeneratorModel.ControllerName, namespaceName: namespaceName);
var outputPath = ValidateAndGetOutputPath(controllerGeneratorModel);
await CodeGeneratorActionsService.AddFileFromTemplateAsync(outputPath, GetTemplateName(controllerGeneratorModel), TemplateFolders, templateModel);
Logger.LogMessage(string.Format(MessageStrings.AddedController, outputPath.Substring(ApplicationInfo.ApplicationBasePath.Length)));
await layoutDependencyInstaller.InstallDependencies();
}
public async Task AddFileFromTemplateAsync_Throws_If_Template_Processing_Has_Exceptions()
{
var mockFilesLocator = new Mock<IFilesLocator>();
var mockTemplating = new Mock<ITemplating>();
var mockFileSystem = new MockFileSystem();
var templateName = "TemplateName";
var templatePath = "C:\template.cshtml";
var templateContent = "TemplateContent";
var processingException = new TemplateProcessingException(new[] { "Error1" }, string.Empty);
mockFilesLocator.Setup(fl => fl.GetFilePath(templateName, It.IsAny<IEnumerable<string>>()))
.Returns(templatePath);
mockFileSystem.WriteAllText(templatePath, templateContent);
mockTemplating.Setup(templating => templating.RunTemplateAsync(templateContent, null))
.Returns(Task.FromResult(new TemplateResult()
{
ProcessingException = processingException
}));
var codeGeneratorActionService = new CodeGeneratorActionsService(
mockTemplating.Object, mockFilesLocator.Object, mockFileSystem);
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () =>
await codeGeneratorActionService.AddFileFromTemplateAsync("Dummy",
templateName,
new[] { "TemplateFolder1", "TemplateFolder2" },
null));
Assert.Equal("There was an error running the template " + templatePath + ": Template Processing Failed:Error1", ex.Message);
}
public override async Task Generate(CommandLineGeneratorModel controllerGeneratorModel)
{
Contract.Assert(!String.IsNullOrEmpty(controllerGeneratorModel.ModelClass));
ValidateNameSpaceName(controllerGeneratorModel);
string outputPath = ValidateAndGetOutputPath(controllerGeneratorModel);
_areaName = GetAreaName(ApplicationInfo.ApplicationBasePath, outputPath);
var modelTypeAndContextModel = await ModelMetadataUtilities.ValidateModelAndGetEFMetadata(
controllerGeneratorModel,
EntityFrameworkService,
ModelTypesLocator,
_areaName
);
if (string.IsNullOrEmpty(controllerGeneratorModel.ControllerName))
{
//Todo: Pluralize model name
controllerGeneratorModel.ControllerName = modelTypeAndContextModel.ModelType.Name + Constants.ControllerSuffix;
}
var namespaceName = string.IsNullOrEmpty(controllerGeneratorModel.ControllerNamespace)
? GetDefaultControllerNamespace(controllerGeneratorModel.RelativeFolderPath)
: controllerGeneratorModel.ControllerNamespace;
var templateModel = new ControllerWithContextTemplateModel(modelTypeAndContextModel.ModelType, modelTypeAndContextModel.DbContextFullName)
{
ControllerName = controllerGeneratorModel.ControllerName,
AreaName = _areaName,
UseAsync = controllerGeneratorModel.UseAsync, // This is no longer used for controllers with context.
ControllerNamespace = namespaceName,
ModelMetadata = modelTypeAndContextModel.ContextProcessingResult.ModelMetadata
};
await CodeGeneratorActionsService.AddFileFromTemplateAsync(
outputPath,
GetTemplateName(controllerGeneratorModel),
TemplateFolders,
templateModel
);
Logger.LogMessage("Added Controller : " + outputPath.Substring(ApplicationInfo.ApplicationBasePath.Length));
await GenerateViewsIfRequired(
controllerGeneratorModel,
modelTypeAndContextModel,
templateModel.ControllerRootName
);
if (modelTypeAndContextModel.ContextProcessingResult.ContextProcessingStatus
== ContextProcessingStatus.ContextAddedButRequiresConfig)
{
throw new Exception(string.Format("{0} {1}", MessageStrings.ScaffoldingSuccessful_unregistered,
MessageStrings.Scaffolding_additionalSteps));
}
}
public async Task AddFileFromTemplateAsync_Throws_If_Template_Is_Not_Found()
{
var mockFilesLocator = new Mock<IFilesLocator>();
var mockTemplating = new Mock<ITemplating>();
var codeGeneratorActionService = new CodeGeneratorActionsService(
mockTemplating.Object, mockFilesLocator.Object);
var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () =>
await codeGeneratorActionService.AddFileFromTemplateAsync("Dummy",
"Template",
new[] { "TemplateFolder1", "TemplateFolder2" },
null));
Assert.Equal("Template file Template not found within search paths TemplateFolder1;TemplateFolder2", ex.Message);
}
public async Task AddFileFromTemplateAsync_Throws_If_Template_Is_Not_Found()
{
var mockFilesLocator = new Mock <IFilesLocator>();
var mockTemplating = new Mock <ITemplating>();
var codeGeneratorActionService = new CodeGeneratorActionsService(
mockTemplating.Object, mockFilesLocator.Object, DefaultFileSystem.Instance);
var ex = await Assert.ThrowsAsync <InvalidOperationException>(async() =>
await codeGeneratorActionService.AddFileFromTemplateAsync("Dummy",
"Template",
new[] { "TemplateFolder1", "TemplateFolder2" },
null));
Assert.Equal("Template file Template not found within search paths TemplateFolder1;TemplateFolder2", ex.Message);
}
private async Task GenerateViewsIfRequired(CommandLineGeneratorModel controllerGeneratorModel,
ModelTypeAndContextModel modelTypeAndContextModel,
string controllerRootName)
{
if (!controllerGeneratorModel.IsRestController && !controllerGeneratorModel.NoViews)
{
var layoutDependencyInstaller = ActivatorUtilities.CreateInstance <MvcLayoutDependencyInstaller>(ServiceProvider);
await layoutDependencyInstaller.Execute();
foreach (var viewTemplate in _views)
{
var viewName = viewTemplate == "List" ? "Index" : viewTemplate;
// ToDo: This is duplicated from ViewGenerator.
bool isLayoutSelected = controllerGeneratorModel.UseDefaultLayout ||
!String.IsNullOrEmpty(controllerGeneratorModel.LayoutPage);
var viewTemplateModel = new ViewGeneratorTemplateModel()
{
ViewDataTypeName = modelTypeAndContextModel.ModelType.FullName,
ViewDataTypeShortName = modelTypeAndContextModel.ModelType.Name,
ViewName = viewName,
LayoutPageFile = controllerGeneratorModel.LayoutPage,
IsLayoutPageSelected = isLayoutSelected,
IsPartialView = false,
ReferenceScriptLibraries = controllerGeneratorModel.ReferenceScriptLibraries,
ModelMetadata = modelTypeAndContextModel.ContextProcessingResult.ModelMetadata,
JQueryVersion = "1.10.2"
};
// Todo: Need logic for areas
var viewOutputPath = Path.Combine(
ApplicationInfo.ApplicationBasePath,
Constants.ViewsFolderName,
controllerRootName,
viewName + Constants.ViewExtension);
await CodeGeneratorActionsService.AddFileFromTemplateAsync(viewOutputPath,
viewTemplate + Constants.RazorTemplateExtension, TemplateFolders, viewTemplateModel);
Logger.LogMessage("Added View : " + viewOutputPath.Substring(ApplicationInfo.ApplicationBasePath.Length));
}
await layoutDependencyInstaller.InstallDependencies();
}
}
internal async Task Generate(CommandLineGeneratorModel model)
{
DocumentationViewModel viewModel = new DocumentationViewModel();
viewModel.Attributes = new List <AttributeInfo>();
viewModel.Interfaces = new List <InterfaceInfo>();
viewModel.BaseControllers = new List <BaseControllerInfo>();
viewModel.Models = new List <ModelInfo>();
ParseAttributes(viewModel);
ParseInterfaces(viewModel);
ParseBaseControllers(viewModel);
ParseModels(viewModel);
var viewOutputPath = Path.Combine(
ApplicationEnvironment.ApplicationBasePath,
"Views",
"Home",
"Documentation.cshtml");
await CodeGeneratorActionsService.AddFileFromTemplateAsync(viewOutputPath,
"StaticDocumentationBuilder.cshtml", TemplateFolders, viewModel);
}
public async Task AddFileFromTemplateAsync_Writes_If_Template_Processing_Is_Successful()
{
var mockFilesLocator = new Mock<IFilesLocator>();
var mockTemplating = new Mock<ITemplating>();
var mockFileSystem = new MockFileSystem();
var templateName = "TemplateName";
var templatePath = "C:\template.cshtml";
var templateContent = "TemplateContent";
var outputPath = @"C:\Output.txt";
var generatedText = "GeneratedText";
mockFilesLocator.Setup(fl => fl.GetFilePath(templateName, It.IsAny<IEnumerable<string>>()))
.Returns(templatePath);
mockFileSystem.WriteAllText(templatePath, templateContent);
mockTemplating.Setup(templating => templating.RunTemplateAsync(templateContent, null))
.Returns(Task.FromResult(new TemplateResult()
{
ProcessingException = null,
GeneratedText = generatedText
}));
var codeGeneratorActionService = new CodeGeneratorActionsService(
mockTemplating.Object, mockFilesLocator.Object, mockFileSystem);
await codeGeneratorActionService.AddFileFromTemplateAsync(outputPath,
templateName,
new[] { "TemplateFolder1", "TemplateFolder2" },
null);
Assert.True(mockFileSystem.FileExists(outputPath));
Assert.Equal(generatedText, mockFileSystem.ReadAllText(outputPath));
}
