public void CanProcessFailedPostAction()
{
var engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
var postActionProcessor = new CaptureMePostAction(expectedResult: false);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), postActionProcessor);
var postAction = new MockPostAction();
MockCreationResult creationResult = new MockCreationResult(new List <IPostAction>()
{
postAction
});
MockCreationEffects creationEffects = new MockCreationEffects();
var templateCreationResult = new TemplateCreationResult(
CreationResultStatus.Success,
"TestTemplate",
null,
creationResult,
"TestPath",
creationEffects);
PostActionDispatcher dispatcher = new PostActionDispatcher(
engineEnvironmentSettings,
new NewCommandCallbacks(),
() => string.Empty);
var result = dispatcher.Process(templateCreationResult, isDryRun: false, AllowRunScripts.Prompt);
Assert.Equal(PostActionExecutionStatus.Failure, result);
Assert.Equal(engineEnvironmentSettings, postActionProcessor.Calls.Single().EngineEnvironmentSettings);
Assert.Equal(postAction, postActionProcessor.Calls.Single().PostAction);
Assert.Equal(creationEffects, postActionProcessor.Calls.Single().CreationEffects);
Assert.Equal(creationResult, postActionProcessor.Calls.Single().CreationResult);
Assert.Equal("TestPath", postActionProcessor.Calls.Single().OutputPath);
}
public void CanDryRunSuccessPostAction()
{
var engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
var postActionProcessor = new CaptureMePostAction(expectedResult: true);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), postActionProcessor);
var postAction = new MockPostAction();
MockCreationEffects creationEffects = new MockCreationEffects();
var templateCreationResult = new TemplateCreationResult(
CreationResultStatus.Success,
"TestTemplate",
null,
null,
"TestPath",
creationEffects);
PostActionDispatcher dispatcher = new PostActionDispatcher(
engineEnvironmentSettings,
new NewCommandCallbacks(),
() => string.Empty);
var result = dispatcher.Process(templateCreationResult, isDryRun: true, AllowRunScripts.Prompt);
Assert.Equal(PostActionExecutionStatus.Success, result);
Assert.Empty(postActionProcessor.Calls);
}
public void CanProcessPostActionThrowingException()
{
var engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), new ThrowExceptionPostAction());
var postAction = new MockPostAction();
MockCreationResult creationResult = new MockCreationResult(new List <IPostAction>()
{
postAction
});
MockCreationEffects creationEffects = new MockCreationEffects();
var templateCreationResult = new TemplateCreationResult(
CreationResultStatus.Success,
"TestTemplate",
null,
creationResult,
"TestPath",
creationEffects);
PostActionDispatcher dispatcher = new PostActionDispatcher(
engineEnvironmentSettings,
new NewCommandCallbacks(),
() => string.Empty);
var result = dispatcher.Process(templateCreationResult, isDryRun: false, AllowRunScripts.Yes);
Assert.Equal(PostActionExecutionStatus.Failure, result);
}
public void CanContinueOnErrorWhenConfigured()
{
var engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
var trueProcessorGuid = Guid.NewGuid();
var falseProcessorGuid = Guid.NewGuid();
var trueProcessor = new CaptureMePostAction(expectedResult: true, guid: trueProcessorGuid);
var falseProcessor = new CaptureMePostAction(expectedResult: false, guid: falseProcessorGuid);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), trueProcessor);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), falseProcessor);
var postAction1 = new MockPostAction
{
ActionId = falseProcessorGuid,
ContinueOnError = true
};
var postAction2 = new MockPostAction
{
ActionId = trueProcessorGuid,
ContinueOnError = true
};
MockCreationResult creationResult = new MockCreationResult(new List <IPostAction>()
{
postAction1, postAction2
});
MockCreationEffects creationEffects = new MockCreationEffects();
var templateCreationResult = new TemplateCreationResult(
CreationResultStatus.Success,
"TestTemplate",
null,
creationResult,
"TestPath",
creationEffects);
PostActionDispatcher dispatcher = new PostActionDispatcher(
engineEnvironmentSettings,
new NewCommandCallbacks(),
() => string.Empty);
var result = dispatcher.Process(templateCreationResult, isDryRun: false, AllowRunScripts.Yes);
// in case continue on error is true, success status is returned on failure
Assert.Equal(PostActionExecutionStatus.Success, result);
//2 post actions were executed
Assert.Equal(1, trueProcessor.Calls.Count);
Assert.Equal(1, falseProcessor.Calls.Count);
Assert.Equal(postAction1, falseProcessor.Calls[0].PostAction);
Assert.Equal(postAction2, trueProcessor.Calls[0].PostAction);
}
public void CanProcessRunScriptPostActionAndSuccessPostAction_WhenRunScriptPrompt_No()
{
var engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
var postActionProcessor = new CaptureMePostAction(expectedResult: true);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), postActionProcessor);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), new ProcessStartPostActionProcessor());
var postAction1 = new MockPostAction
{
ActionId = ProcessStartPostActionProcessor.ActionProcessorId,
//the post action will fail, but that is OK for test purpose
Args = new Dictionary <string, string>()
{
{ "executable", "do-not-exist" }
},
ContinueOnError = true
};
var postAction2 = new MockPostAction
{
ActionId = Guid.Empty, //CaptureMePostAction
ContinueOnError = true
};
MockCreationResult creationResult = new MockCreationResult(new List <IPostAction>()
{
postAction1, postAction2
});
MockCreationEffects creationEffects = new MockCreationEffects();
var templateCreationResult = new TemplateCreationResult(
CreationResultStatus.Success,
"TestTemplate",
null,
creationResult,
Path.GetTempPath(),
creationEffects);
PostActionDispatcher dispatcher = new PostActionDispatcher(
engineEnvironmentSettings,
new NewCommandCallbacks(),
() => "N"); // the user forbids to run post action
var result = dispatcher.Process(templateCreationResult, isDryRun: false, AllowRunScripts.Prompt);
Assert.Equal(PostActionExecutionStatus.Cancelled, result);
Assert.NotEqual(PostActionExecutionStatus.Failure, result);
Assert.Single(postActionProcessor.Calls);
Assert.Equal(postAction2, postActionProcessor.Calls.Single().PostAction);
}
public void CanProcessRunScriptPostAction_DryRun()
{
var engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
engineEnvironmentSettings.Components.AddComponent(typeof(IPostActionProcessor), new ProcessStartPostActionProcessor());
var postAction = new MockPostAction
{
ActionId = ProcessStartPostActionProcessor.ActionProcessorId,
//the post action will fail, but that is OK for test purpose
Args = new Dictionary <string, string>()
{
{ "executable", "do-not-exist" }
}
};
MockCreationResult creationResult = new MockCreationResult(new List <IPostAction>()
{
postAction
});
MockCreationEffects creationEffects = new MockCreationEffects();
var templateCreationResult = new TemplateCreationResult(
CreationResultStatus.Success,
"TestTemplate",
null,
creationResult,
Path.GetTempPath(),
creationEffects);
PostActionDispatcher dispatcher = new PostActionDispatcher(
engineEnvironmentSettings,
new NewCommandCallbacks(),
() => "N"); // the user forbids to run post action
//run script setting doesn't matter for dry run
var result = dispatcher.Process(templateCreationResult, isDryRun: true, AllowRunScripts.Prompt);
Assert.Equal(PostActionExecutionStatus.Success, result);
result = dispatcher.Process(templateCreationResult, isDryRun: true, AllowRunScripts.Yes);
Assert.Equal(PostActionExecutionStatus.Success, result);
result = dispatcher.Process(templateCreationResult, isDryRun: true, AllowRunScripts.No);
Assert.Equal(PostActionExecutionStatus.Success, result);
}
private static int Main(string[] args)
{
string profileDir = GetHomeDirectory();
string hivePath = Path.Combine(profileDir, ".templateengine", HostName, HostVersion);
ITemplateEngineHost host = CreateHost(HostName, HostVersion);
EnvironmentSettings = new EngineEnvironmentSettings(host, x => new SettingsLoader(x), hivePath);
EnvironmentSettings.SettingsLoader.Components.OfType <IIdentifiedComponent>().ToList();
_paths = new Paths(EnvironmentSettings);
//NOTE: With the base directory virtualized, packages cannot be installed from NuGet,
// only local packages and folders
EnvironmentSettings.Host.VirtualizeDirectory(_paths.User.Content);
EnvironmentSettings.Host.VirtualizeDirectory(_paths.User.Packages);
_settingsLoader = (SettingsLoader)EnvironmentSettings.SettingsLoader;
_hostDataLoader = new HostSpecificDataLoader(EnvironmentSettings.SettingsLoader);
CommandLineParser parser = new CommandLineParser(args)
.AddOptionWithConstrainedValue("--operation", new[]
{
"list",
"create"
})
.AddOptionWithValue("--require")
.AddOptionWithValue("--source");
if (!parser.TryGetValues("--require", out IReadOnlyList <string> requireDirectives) ||
!parser.TryGetSingleValue("--operation", out string operation))
{
Console.SetOut(Console.Error);
Console.WriteLine("ERROR: Expected \"--require\" and/or \"--operation\" parameter.");
return(-1);
}
IInstaller installer = new Installer(EnvironmentSettings);
if (!parser.TryGetValues("--source", out IReadOnlyList <string> sources))
{
sources = null;
}
installer.InstallPackages(requireDirectives, sources?.ToList());
//All required templates/components/lang packs have now been configured
//Desired operation information starts at args[commandArgsStart]
_templateCreator = new TemplateCreator(EnvironmentSettings);
IReadOnlyList <TemplateInfo> rawTemplates = _settingsLoader.UserTemplateCache.TemplateInfo;
var templates = new JArray();
foreach (var rawTemplate in rawTemplates)
{
var template = JObject.FromObject(rawTemplate);
template.Add("Parameters", JArray.FromObject(rawTemplate.Parameters));
templates.Add(template);
}
if (string.Equals(operation, "list"))
{
Console.WriteLine(templates);
return(0);
}
parser = parser.AddOptionWithValue("--identity");
if (!parser.TryGetSingleValue("--identity", out string identity))
{
Console.SetOut(Console.Error);
Console.WriteLine("ERROR: Expected \"--identity\" parameter.");
return(-1);
}
TemplateInfo info = rawTemplates.FirstOrDefault(x => string.Equals(x.Identity, identity, StringComparison.Ordinal));
if (info == null)
{
Console.SetOut(Console.Error);
Console.WriteLine("ERROR: Failed to find template with identity \"{0}\".", identity);
return(-1);
}
if (string.Equals(operation, "create"))
{
Dictionary <string, string> templateArgs = new Dictionary <string, string>(StringComparer.Ordinal);
foreach (ITemplateParameter x in info.Parameters)
{
if (x.DataType != null && x.DataType.StartsWith("bool", StringComparison.OrdinalIgnoreCase))
{
parser = parser.AddOptionWithBooleanValue($"--arg:{x.Name}", string.IsNullOrEmpty(x.DefaultValue) || string.Equals(x.DefaultValue, "true"));
}
else if (x.DataType != null && x.DataType.Equals("choice", StringComparison.OrdinalIgnoreCase))
{
parser = parser.AddOptionWithConstrainedValue($"--arg:{x.Name}", x.Choices.Keys.ToList());
}
else
{
parser = parser.AddOptionWithValue($"--arg:{x.Name}");
}
if (parser.TryGetSingleValue($"--arg:{x.Name}", out string val))
{
templateArgs[x.Name] = val;
}
}
TemplateCreationResult result = _templateCreator.InstantiateAsync(info, null, null, null, templateArgs, true, false, null).Result;
if (result.Status == CreationResultStatus.Success)
{
PostActionDispatcher postActionDispatcher = new PostActionDispatcher(EnvironmentSettings, result, AllowPostActionsSetting.Yes, false);
postActionDispatcher.Process(null);
}
Console.WriteLine(JObject.FromObject(result));
return((int)result.Status);
}
return(0);
}
