public BridgeScriptHost(ICakeEngine engine, ICakeContext context, IExecutionStrategy strategy, ICakeReportPrinter reporter, ICakeArguments arguments)
: base(engine, context)
{
Strategy = strategy;
Reporter = reporter;
Arguments = arguments;
}
public void Setup()
{
_settings = new GraphiteSettings()
{
Host = "192.0.2.0",
HttpApiPort = 10,
BatchSize = 500,
ThrowExceptions = true
};
_log = new FakeLog();
_configuration = new FakeConfiguration();
_environment = new FakeEnvironment(PlatformFamily.Windows)
{
WorkingDirectory = new DirectoryPath(Environment.CurrentDirectory)
};
_fileSystem = new FakeFileSystem(_environment);
_globber = new Globber(_fileSystem, _environment);
var mockArguments = new Mock <ICakeArguments>();
mockArguments.Setup(x => x.GetArgument(It.IsAny <string>())).Returns(string.Empty);
mockArguments.Setup(x => x.HasArgument(It.IsAny <string>())).Returns(false);
_arguments = mockArguments.Object;
_toolLocator = new ToolLocator(_environment, new ToolRepository(_environment), new ToolResolutionStrategy(_fileSystem, _environment, _globber, _configuration));
_processRunner = new ProcessRunner(_fileSystem, _environment, _log, _toolLocator, _configuration);
var mockDataService = new Mock <ICakeDataService>();
mockDataService.Setup(x => x.Add(It.IsAny <string>()));
_dataService = mockDataService.Object;
_context = new CakeContext(_fileSystem, _environment, _globber, _log, _arguments, _processRunner, new WindowsRegistry(), _toolLocator, _dataService, _configuration);
}
/// <summary>
/// Initializes a new instance of the <see cref="CakeEngine"/> class.
/// </summary>
/// <param name="fileSystem">The file system.</param>
/// <param name="environment">The environment.</param>
/// <param name="log">The log.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="globber">The globber.</param>
/// <param name="processRunner">The process runner.</param>
public CakeEngine(IFileSystem fileSystem, ICakeEnvironment environment, ICakeLog log,
ICakeArguments arguments, IGlobber globber, IProcessRunner processRunner)
{
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
if (environment == null)
{
throw new ArgumentNullException("environment");
}
if (log == null)
{
throw new ArgumentNullException("log");
}
if (arguments == null)
{
throw new ArgumentNullException("arguments");
}
if (globber == null)
{
throw new ArgumentNullException("globber");
}
if (processRunner == null)
{
throw new ArgumentNullException("processRunner");
}
_fileSystem = fileSystem;
_environment = environment;
_log = log;
_arguments = arguments;
_globber = globber;
_processRunner = processRunner;
_tasks = new List <CakeTask>();
}
/// <summary>
/// Builds arguments for Storyteller
/// </summary>
/// <param name="command">Storyteller Command (Open or Run)</param>
/// <param name="projectPath">Storyteller project path</param>
/// <param name="arguments">Arguments pass in by cake</param>
/// <param name="settings"><see cref="StorytellerSettings"/> object</param>
/// <returns></returns>
public ProcessArgumentBuilder BuildArguments(StorytellerCommand command,
string projectPath,
ICakeArguments arguments,
StorytellerSettings settings = null)
{
var dict = new Dictionary <string, string>();
if (settings != null)
{
//settings
var props = typeof(StorytellerSettings).GetProperties();
foreach (var prop in props)
{
var attrs = prop.GetCustomAttributes(false);
foreach (var attr in attrs)
{
var stFlagAttr = attr as StorytellerFlag;
if (stFlagAttr != null)
{
var value = prop.GetValue(settings, null);
if (value != null)
{
dict.Add(stFlagAttr.Flag, value.ToString());
}
}
}
}
}
//arguments
if (arguments != null)
{
_stArguments.ForEach(arg =>
{
if (arguments.HasArgument(arg))
{
dict[arg] = arguments.GetArgument(arg);
}
});
}
var builder = new ProcessArgumentBuilder();
builder.Append(command.ToString().ToLower());
builder.Append(projectPath);
foreach (var pair in dict)
{
if (pair.Value == "True" || string.IsNullOrEmpty(pair.Value))
{
builder.Append("--" + pair.Key);
}
else
{
builder.Append("--" + pair.Key + " " + pair.Value);
}
}
return(builder);
}
public static Func <string, T, T> BuildWithDefaultValue <T>(ICakeArguments arguments, ICakeEnvironment environment, string prefix)
{
ValidateParams(arguments, environment, prefix);
return((paramName, defaultValue) =>
{
var paramValue = GetValue(arguments, environment, prefix, paramName);
return paramValue != null?TypeConverter.ConvertTo <T>(paramValue) : defaultValue;
});
}
private static void ValidateParams(ICakeArguments arguments, ICakeEnvironment environment, string prefix)
{
Guard.Argument(arguments, nameof(arguments)).NotNull();
Guard.Argument(environment, nameof(environment)).NotNull();
Guard.Argument(prefix, nameof(prefix))
.NotNull()
.NotEmpty()
.NotWhiteSpace();
}
public static Func <string, T> BuildRequired <T>(ICakeArguments arguments, ICakeEnvironment environment, string prefix)
{
ValidateParams(arguments, environment, prefix);
return(paramName =>
{
var paramValue = GetValue(arguments, environment, prefix, paramName);
return paramValue != null
? TypeConverter.ConvertTo <T>(paramValue)
: throw new CakeException($"Argument '{paramName}' or environment variable '{GetEnvVarName(prefix, paramName)}' were not set.");
});
}
/// <summary>
/// Initializes a new instance of the <see cref="CakeContext"/> class.
/// </summary>
/// <param name="fileSystem">The file system.</param>
/// <param name="environment">The environment.</param>
/// <param name="globber">The globber.</param>
/// <param name="log">The log.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="processRunner">The process runner.</param>
/// <param name="toolResolvers">The tool resolvers.</param>
/// <param name="registry">The registry.</param>
public CakeContext(
IFileSystem fileSystem,
ICakeEnvironment environment,
IGlobber globber,
ICakeLog log,
ICakeArguments arguments,
IProcessRunner processRunner,
IEnumerable <IToolResolver> toolResolvers,
IRegistry registry)
{
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
if (environment == null)
{
throw new ArgumentNullException("environment");
}
if (globber == null)
{
throw new ArgumentNullException("globber");
}
if (log == null)
{
throw new ArgumentNullException("log");
}
if (arguments == null)
{
throw new ArgumentNullException("arguments");
}
if (processRunner == null)
{
throw new ArgumentNullException("processRunner");
}
if (toolResolvers == null)
{
throw new ArgumentNullException("toolResolvers");
}
_fileSystem = fileSystem;
_environment = environment;
_globber = globber;
_log = log;
_arguments = arguments;
_processRunner = processRunner;
// Create the tool resolver lookup table.
_toolResolverLookup = toolResolvers.ToLookup(
key => key.Name, value => value,
StringComparer.OrdinalIgnoreCase);
_registry = registry;
}
private static Dictionary <string, string> GetArgumentsDictionary(ICakeArguments arguments)
{
var obj = arguments.GetType()
.GetProperty(ArgumentsPropertyName)
?.GetValue(arguments, null);
if (obj == null)
{
throw new CakeException("Something went wrong while getting a list of arguments. "
+ "Using this method is not recommended.");
}
return((Dictionary <string, string>)obj);
}
public void Setup()
{
_environment = FakeEnvironment.CreateWindowsEnvironment();
_log = new FakeLog();
_arguments = Substitute.For <ICakeArguments>();
_appVeyor = Substitute.For <IAppVeyorProvider>();
_azure = Substitute.For <ITFBuildProvider>();
_appEnvironment = new AppVeyorEnvironmentInfo(_environment);
_appVeyor.Environment.Returns(_appEnvironment);
_globber = Substitute.For <IGlobber>();
_fileSystem = new FakeFileSystem(_environment);
_processRunner = Substitute.For <IProcessRunner>();
_toolLocator = Substitute.For <IToolLocator>();
}
/// <summary>
/// Initializes a new instance of the <see cref="CakeContext"/> class.
/// </summary>
/// <param name="fileSystem">The file system.</param>
/// <param name="environment">The environment.</param>
/// <param name="globber">The globber.</param>
/// <param name="log">The log.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="processRunner">The process runner.</param>
/// <param name="registry">The registry.</param>
/// <param name="tools">The tool locator.</param>
public CakeContext(
IFileSystem fileSystem,
ICakeEnvironment environment,
IGlobber globber,
ICakeLog log,
ICakeArguments arguments,
IProcessRunner processRunner,
IRegistry registry,
IToolLocator tools)
{
if (fileSystem == null)
{
throw new ArgumentNullException(nameof(fileSystem));
}
if (environment == null)
{
throw new ArgumentNullException(nameof(environment));
}
if (globber == null)
{
throw new ArgumentNullException(nameof(globber));
}
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
if (arguments == null)
{
throw new ArgumentNullException(nameof(arguments));
}
if (processRunner == null)
{
throw new ArgumentNullException(nameof(processRunner));
}
if (tools == null)
{
throw new ArgumentNullException(nameof(tools));
}
FileSystem = fileSystem;
Environment = environment;
Globber = globber;
Log = log;
Arguments = arguments;
ProcessRunner = processRunner;
Registry = registry;
Tools = tools;
}
/// <summary>
/// Initializes a new instance of the <see cref="CakeContext"/> class.
/// </summary>
/// <param name="fileSystem">The file system.</param>
/// <param name="environment">The environment.</param>
/// <param name="globber">The globber.</param>
/// <param name="log">The log.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="processRunner">The process runner.</param>
/// <param name="registry">The registry.</param>
/// <param name="tools">The tool locator.</param>
public CakeContext(
IFileSystem fileSystem,
ICakeEnvironment environment,
IGlobber globber,
ICakeLog log,
ICakeArguments arguments,
IProcessRunner processRunner,
IRegistry registry,
IToolLocator tools)
{
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
if (environment == null)
{
throw new ArgumentNullException("environment");
}
if (globber == null)
{
throw new ArgumentNullException("globber");
}
if (log == null)
{
throw new ArgumentNullException("log");
}
if (arguments == null)
{
throw new ArgumentNullException("arguments");
}
if (processRunner == null)
{
throw new ArgumentNullException("processRunner");
}
if (tools == null)
{
throw new ArgumentNullException("tools");
}
_fileSystem = fileSystem;
_environment = environment;
_globber = globber;
_log = log;
_arguments = arguments;
_processRunner = processRunner;
_registry = registry;
_tools = tools;
}
public ScriptHostFixture()
{
FileSystem = Substitute.For <IFileSystem>();
Environment = Substitute.For <ICakeEnvironment>();
Log = Substitute.For <ICakeLog>();
Globber = Substitute.For <IGlobber>();
Arguments = Substitute.For <ICakeArguments>();
Engine = Substitute.For <ICakeEngine>();
Engine.FileSystem.Returns(FileSystem);
Engine.Environment.Returns(Environment);
Engine.Log.Returns(Log);
Engine.Globber.Returns(Globber);
Engine.Arguments.Returns(Arguments);
Engine.RunTarget(Arg.Any <string>()).Returns(new CakeReport());
}
private ICakeContext GetMoqContext(
HelperFixture fixture,
IGlobber globber,
IRegistry registry,
ICakeArguments args)
{
var log = new FakeLog();
var contextMock = new Mock <ICakeContext>();
contextMock.SetupGet(t => t.FileSystem).Returns(fixture.FileSystem);
contextMock.SetupGet(t => t.Environment).Returns(fixture.Environment);
contextMock.SetupGet(t => t.Globber).Returns(globber);
contextMock.SetupGet(t => t.Log).Returns(log);
contextMock.SetupGet(t => t.Arguments).Returns(args);
contextMock.SetupGet(t => t.ProcessRunner).Returns(fixture.ProcessRunner);
contextMock.SetupGet(t => t.Registry).Returns(registry);
contextMock.SetupGet(t => t.Tools).Returns(fixture.Tools);
return(contextMock.Object);
}
/// <summary>
/// Initializes a new instance of the <see cref="CakeContext"/> class.
/// </summary>
/// <param name="fileSystem">The file system.</param>
/// <param name="environment">The environment.</param>
/// <param name="globber">The globber.</param>
/// <param name="log">The log.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="processRunner">The process runner.</param>
/// <param name="registry">The registry.</param>
/// <param name="tools">The tool locator.</param>
/// <param name="data">The data service.</param>
public CakeContext(
IFileSystem fileSystem,
ICakeEnvironment environment,
IGlobber globber,
ICakeLog log,
ICakeArguments arguments,
IProcessRunner processRunner,
IRegistry registry,
IToolLocator tools,
ICakeDataService data)
{
FileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
Environment = environment ?? throw new ArgumentNullException(nameof(environment));
Globber = globber ?? throw new ArgumentNullException(nameof(globber));
Log = log ?? throw new ArgumentNullException(nameof(log));
Arguments = arguments ?? throw new ArgumentNullException(nameof(arguments));
ProcessRunner = processRunner ?? throw new ArgumentNullException(nameof(processRunner));
Registry = registry ?? throw new ArgumentNullException(nameof(registry));
Tools = tools ?? throw new ArgumentNullException(nameof(tools));
Data = data ?? throw new ArgumentNullException(nameof(data));
}
/// <summary>
/// Initializes a new instance of the <see cref="PaketToolResolver" /> class.
/// </summary>
/// <param name="fileSystem">The file system.</param>
/// <param name="environment">The environment.</param>
/// <param name="tools">The tool locator.</param>
/// <param name="processRunner">The process runner.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="log">The log.</param>
internal PaketToolResolver(IFileSystem fileSystem, ICakeEnvironment environment, IToolLocator tools, IProcessRunner processRunner, ICakeArguments arguments, ICakeLog log)
{
if (fileSystem == null)
{
throw new ArgumentNullException(nameof(fileSystem));
}
if (environment == null)
{
throw new ArgumentNullException(nameof(environment));
}
if (tools == null)
{
throw new ArgumentNullException(nameof(tools));
}
if (processRunner == null)
{
throw new ArgumentNullException(nameof(processRunner));
}
if (arguments == null)
{
throw new ArgumentNullException(nameof(arguments));
}
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
FileSystem = fileSystem;
Environment = environment;
Tools = tools;
ProcessRunner = processRunner;
Arguments = arguments;
Log = log;
}
/// <summary>
/// Initializes new instance of <see cref="StorytellerRunner"/> class.
/// </summary>
/// <param name="fileSystem">Filesystem</param>
/// <param name="environment">Environment</param>
/// <param name="processRunner">Process Runner</param>
/// <param name="toolLocator">Tool Locator</param>
/// <param name="arguments">Arguments</param>
public StorytellerRunner(IFileSystem fileSystem, ICakeEnvironment environment, IProcessRunner processRunner, IToolLocator toolLocator, ICakeArguments arguments) : base(fileSystem, environment, processRunner, toolLocator)
{
_arguments = arguments;
}
public VersionHelper(ICakeEnvironment environment, ICakeLog log, ICakeArguments arguments,
IAppVeyorProvider appVeyorProvider, ITFBuildProvider azureProvider, IGlobber globber, IFileSystem fileSystem, IProcessRunner processRunner, IToolLocator tools)
{
_environment = environment;
_log = log;
_arguments = arguments;
_appVeyorProvider = appVeyorProvider;
_azureProvider = azureProvider;
_globber = globber;
_fileSystem = fileSystem;
_processRunner = processRunner;
_tools = tools;
if (environment == null)
{
throw new ArgumentNullException(nameof(environment));
}
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
Configuration = environment.GetEnvironmentVariable("CONFIGURATION");
if (string.IsNullOrWhiteSpace(Configuration))
{
Configuration = _arguments.HasArgument("configuration") ? _arguments.GetArgument("configuration") : "Release";
}
string envLogging = environment.GetEnvironmentVariable("LOGGINGLEVEL");
if (!string.IsNullOrWhiteSpace(envLogging))
{
Verbosity loggingEnum;
if (Enum.TryParse(envLogging, true, out loggingEnum))
{
log.Verbosity = loggingEnum;
log.Information($"Logging Level: {loggingEnum}", Verbosity.Quiet);
if (IsAppVeyor)
{
_appVeyorProvider.AddInformationalMessage($"Logging set by LoggingLevel enviornment variable to {loggingEnum}");
}
_isDefaultLoggingLevel = false;
}
else
{
string msg = $"Invalid logging level [{envLogging}]. Use {Verbosity.Quiet}, {Verbosity.Minimal}, {Verbosity.Normal}, {Verbosity.Verbose} or {Verbosity.Diagnostic}";
if (IsAppVeyor)
{
log.Warning(msg);
}
_appVeyorProvider.AddWarningMessage(msg);
}
}
else
{
_isDefaultLoggingLevel = !arguments.HasArgument("verbosity");
}
if (_log.Verbosity > Verbosity.Normal)
{
var environmentVariables = environment.GetEnvironmentVariables();
foreach (string key in environmentVariables.Keys)
{
log.Verbose($"{key}:{environmentVariables[key]}");
}
}
CommitMessageMatches = new MatchResult {
Success = false
};
if (IsAppVeyor)
{
Branch = _appVeyorProvider.Environment.Repository.Branch;
CommitMessageShort = _appVeyorProvider.Environment.Repository.Commit.Message;
var match = CommitMessageRegex.Match(_appVeyorProvider.Environment.Repository.Commit.ExtendedMessage);
CommitMessageMatches = new MatchResult {
Success = match.Success, Groups = match.Groups
};
_log.Debug($"Branch:{Branch}");
_log.Debug($"Commit Msg Short:{CommitMessageShort}");
_log.Debug($"Commit Msg Extended:{_appVeyorProvider.Environment.Repository.Commit.ExtendedMessage}");
_log.Debug($"Commit Message Cmd Match:{CommitMessageMatches.Success}");
if (_log.Verbosity >= Verbosity.Verbose && CommitMessageMatches.Success)
{
_log.Debug("RegEx Group Matches");
foreach (string groupName in CommitMessageRegex.GetGroupNames())
{
_log.Debug($"{groupName} : {CommitMessageMatches.Groups[groupName].Value}");
}
}
}
if (IsAzureDevops)
{
Branch = _azureProvider.Environment.Repository.Branch;
//CommitMessageShort = _azureProvider.Environment.Repository.Commit.Message;
//var match = CommitMessageRegex.Match(_azureProvider.Environment.Repository.Commit.ExtendedMessage);
//CommitMessageMatches = new MatchResult { Success = match.Success, Groups = match.Groups };
//_log.Debug($"Branch:{Branch}");
//_log.Debug($"Commit Msg Short:{CommitMessageShort}");
//_log.Debug($"Commit Msg Extended:{_appVeyorProvider.Environment.Repository.Commit.ExtendedMessage}");
//_log.Debug($"Commit Message Cmd Match:{CommitMessageMatches.Success}");
//if (_log.Verbosity >= Verbosity.Verbose && CommitMessageMatches.Success)
//{
// _log.Debug("RegEx Group Matches");
// foreach (string groupName in CommitMessageRegex.GetGroupNames())
// {
// _log.Debug($"{groupName} : {CommitMessageMatches.Groups[groupName].Value}");
// }
//}
}
}
/// <summary>
/// Gets the value for an argument.
/// </summary>
/// <remarks>
/// If multiple arguments with the same name are
/// specified, the last argument value is returned.
/// </remarks>
/// <param name="arguments">The arguments.</param>
/// <param name="name">The argument name.</param>
/// <returns>The argument value.</returns>
public static string GetArgument(this ICakeArguments arguments, string name)
{
return(arguments.GetArguments(name).LastOrDefault());
}
private static string GetValue(ICakeArguments arguments, ICakeEnvironment environment, string prefix, string paramName)
{
return(arguments.HasArgument(paramName)
? arguments.GetArgument(paramName)
: environment.GetEnvironmentVariable(GetEnvVarName(prefix, paramName)));
}
