public TemporarySolutionFile( ICakeContext ctx, FilePath originalPath )
{
_cake = ctx;
_originalPath = ctx.MakeAbsolute( originalPath );
_modifiedPath = _originalPath + Guid.NewGuid().ToString( "N" ) + ".sln";
ctx.CopyFile( _originalPath, _modifiedPath );
}
public void BuildArguments(ICakeContext context, ProcessArgumentBuilder builder)
{
if (NoGraphics)
{
builder.Append("-nographics");
}
builder.Append(PlatformTarget == UnityPlatformTarget.x64 ? "-buildWindows64Player" : "-buildWindowsPlayer");
builder.AppendQuoted(_outputPath.MakeAbsolute(context.Environment).FullPath);
}
public void Should_Throw_If_No_Process_Was_Returned_From_Process_Runner(
ICakeContext context, IAdvProcessRunner runner)
{
// Arrange
runner.Start(Arg.Any<FilePath>(), Arg.Any<AdvProcessSettings>())
.Returns((IAdvProcess) null);
Action sut = () => context.StartAdvProcess("hello.exe", runner);
// Act / Assert
sut.ShouldThrow<CakeException>().WithMessage("Could not start process.");
}
private static GitterChatMessageResult PostToIncomingWebHook(ICakeContext context, string message, GitterChatMessageSettings messageSettings)
{
context.Verbose("Posting to incoming webhook {0}...", string.Concat(messageSettings.IncomingWebHookUrl.TrimEnd('/').Reverse().SkipWhile(c => c != '/').Reverse()));
var gitterWebHookService = new WebhookService();
var result = gitterWebHookService.PostAsync(messageSettings.IncomingWebHookUrl, message, messageSettings.MessageLevel == GitterMessageLevel.Error ? MessageLevel.Error : MessageLevel.Info);
var parsedResult = new GitterChatMessageResult(result.Result, DateTime.UtcNow.ToString("u"), string.Empty);
context.Debug("Result parsed: {0}", parsedResult);
return parsedResult;
}
public void Should_Return_Process_Created_By_Runner(ICakeContext context,
FilePath filePath, AdvProcessSettings settings, IAdvProcessRunner runner,
IAdvProcess expectedResult)
{
runner.Start(filePath, settings).Returns(expectedResult);
Func<IAdvProcess> sut =
() => context.StartAdvProcess(filePath, settings, runner);
var result = sut();
result.Should().BeSameAs(expectedResult);
}
/// <summary>
/// Filters binaries that are in common with orchard web project binaries.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="moduleBinaries">Collection of binaries.</param>
/// <param name="orchardWebBinaries">Collection of Orchard.Web project binaries.</param>
/// <returns>Collection of binaries that are shared.</returns>
public static FilePathCollection Filter(ICakeContext context, FilePathCollection moduleBinaries, FilePathCollection orchardWebBinaries) {
if (context == null) {
throw new ArgumentNullException(nameof(context));
}
if (moduleBinaries == null || orchardWebBinaries == null) {
throw new ArgumentNullException("A FilePathCollection is empty.");
}
var orchardWebAssemblies = new HashSet<string>(
orchardWebBinaries.Select(item => item.ToString()),
StringComparer.InvariantCultureIgnoreCase);
return new FilePathCollection(moduleBinaries
.Where(item => orchardWebAssemblies.Contains(item.ToString())), PathComparer.Default);
}
public void Should_Use_Environments_Working_Directory(ICakeContext context,
IAdvProcessRunner runner)
{
// Arrange
context.Environment.WorkingDirectory.Returns(new DirectoryPath("/Working"));
Action sut = () => context.StartAdvProcess("hello.exe", runner);
// Act
sut();
// Assert
runner.Received(1).Start(Arg.Any<FilePath>(), Arg.Is<AdvProcessSettings>(info =>
info.WorkingDirectory.FullPath == "/Working"));
}
private static void ValidateFile(ICakeContext context, FilePath file) {
context.Log.Information("Validating \"{0}\"", file.ToString());
var errors = new Validator(file).Validate();
if (errors.Any()) {
foreach (var error in errors) {
context.Log.Error("{0}, LineNumber {1}, FileName {2}", error.Message, error.LineNumber,
error.FileName);
}
}
else {
context.Log.Information("Project file \"{0}\" is valid", file.ToString());
}
}
public FakeCakeContext ()
{
testsDir = new DirectoryPath (
System.IO.Path.GetFullPath (AppDomain.CurrentDomain.BaseDirectory));
var fileSystem = new FileSystem ();
var environment = new CakeEnvironment ();
var globber = new Globber (fileSystem, environment);
log = new FakeLog ();
var args = new FakeCakeArguments ();
var processRunner = new ProcessRunner (environment, log);
var registry = new WindowsRegistry ();
context = new CakeContext (fileSystem, environment, globber, log, args, processRunner, registry);
context.Environment.WorkingDirectory = testsDir;
}
public FakeCakeContext ()
{
testsDir = new DirectoryPath (
System.IO.Path.GetFullPath (AppDomain.CurrentDomain.BaseDirectory));
var fileSystem = new FileSystem ();
var environment = new CakeEnvironment (new CakePlatform (), new CakeRuntime ());
var globber = new Globber (fileSystem, environment);
log = new FakeLog ();
var args = new FakeCakeArguments ();
var processRunner = new ProcessRunner (environment, log);
var registry = new WindowsRegistry ();
var toolRepo = new ToolRepository (environment);
var config = new Core.Configuration.CakeConfigurationProvider (fileSystem, environment).CreateConfiguration (testsDir, new Dictionary<string, string> ());
var toolResolutionStrategy = new ToolResolutionStrategy (fileSystem, environment, globber, config);
var toolLocator = new ToolLocator (environment, toolRepo, toolResolutionStrategy);
context = new CakeContext (fileSystem, environment, globber, log, args, processRunner, registry, toolLocator);
context.Environment.WorkingDirectory = testsDir;
}
public FakeCakeContext ()
{
testsDir = new DirectoryPath (
System.IO.Path.GetDirectoryName (System.Reflection.Assembly.GetExecutingAssembly ().Location));
var fileSystem = new FileSystem ();
var environment = new CakeEnvironment ();
var globber = new Globber (fileSystem, environment);
log = new FakeLog ();
var args = new FakeCakeArguments ();
var processRunner = new ProcessRunner (environment, log);
var registry = new WindowsRegistry ();
var toolRepo = new ToolRepository (environment);
var config = new Core.Configuration.CakeConfigurationProvider (fileSystem, environment).CreateConfiguration (new Dictionary<string, string> ());
var toolResStrat = new ToolResolutionStrategy (fileSystem, environment, globber, config);
var toolLocator = new ToolLocator (environment, toolRepo, toolResStrat);
context = new CakeContext (fileSystem, environment, globber, log, args, processRunner, registry, toolLocator);
context.Environment.WorkingDirectory = testsDir;
}
/// <summary>
/// Validates module and theme project files.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="files">Project files to be validated.</param>
public static void ValidateFiles(ICakeContext context, FilePathCollection files) {
if (context == null) {
throw new ArgumentNullException(nameof(context));
}
if (files == null) {
throw new ArgumentNullException(nameof(files));
}
if (files.Count == 0) {
context.Log.Verbose("There are not any files in the collection.");
return;
}
foreach (var file in files) {
try {
ValidateFile(context, file);
}
catch (Exception) {
context.Log.Verbose("Error validating project file \"{0}\"", file.ToString());
}
}
}
public static void DotNetCoreRestore(this ICakeContext context, DotNetCoreRestoreSettings settings)
{
context.DotNetCoreRestore(null, settings);
}
public static void DotNetCoreRestore(this ICakeContext context, string root)
{
context.DotNetCoreRestore(root, null);
}
private static async Task <bool> WaitForPipelineToFinishAsync(int projectId, Pipeline pipeline, ICakeContext context)
{
var pipelineIsRunning = true;
while (pipelineIsRunning)
{
await Task.Delay(15000);
Console.WriteLine("Checking pipeline status...");
pipeline = await GetPipelineAsync(projectId, pipeline.Id);
switch (pipeline.Status)
{
case "success":
pipelineIsRunning = false;
context?.Log.Write(Verbosity.Normal, LogLevel.Information, "Pipeline succeeded");
break;
case "failed":
context?.Log.Write(Verbosity.Normal, LogLevel.Information, "Pipeline failed");
return(false);
case "canceled":
context?.Log.Write(Verbosity.Normal, LogLevel.Information, "Pipeline was cancelled");
return(false);
case "skipped":
context?.Log.Write(Verbosity.Normal, LogLevel.Information, "Pipeline was skipped");
return(false);
default:
continue;
}
}
return(true);
}
/// <summary>
/// Always create a <see cref="DNXRuntimeInformation"/> object that may be not valid.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
static DNXRuntimeInformation LoadDNXRuntimeInformation( ICakeContext context )
{
var output = new List<string>();
if( RunCmdAliases.RunCmd( context, "where dnx", output.Add ) != 0 ) return new DNXRuntimeInformation( null );
return new DNXRuntimeInformation( output[0] );
}
public static void DotNetCoreTest(this ICakeContext context, string project)
{
context.DotNetCoreTest(project, null);
}
public static string PropertyAliasReturningCachedString(this ICakeContext context)
{
return("Hello World");
}
public static void DownloadFile(this ICakeContext context, string address, FilePath outputPath, DownloadFileSettings settings)
{
DownloadFile(context, new Uri(address), outputPath, settings);
}
public static string Prompt(this ICakeContext context, string message, string defaultResult)
{
return(Prompt(context, message, defaultResult, TimeSpan.FromSeconds(30)));
}
// ---------------- Constructor ----------------
public FilePathArgumentBinder(ICakeContext cakeContext) :
base(cakeContext)
{
}
public static string Prompt(this ICakeContext context, string message)
{
return(Prompt(context, message, defaultResult: null));
}
public static string Prompt(this ICakeContext context, string message, TimeSpan timeout)
{
return(Prompt(context, message, null, timeout));
}
public OpenCoverContext(ICakeContext context)
{
_context = context;
Log = new NullLog();
_runner = new OpenCoverProcessRunner();
}
public static void SoftNUnit3(this ICakeContext context, IEnumerable <FilePath> assemblies)
{
context.SoftNUnit3(assemblies, new NUnit3Settings());
}
public static void DotNetCoreExecute(this ICakeContext context, FilePath assemblyPath, ProcessArgumentBuilder arguments)
{
context.DotNetCoreExecute(assemblyPath, arguments, null);
}
/// <summary>
/// Initializes a new instance of the <see cref="BuildScriptHost"/> class.
/// </summary>
/// <param name="engine">The engine.</param>
/// <param name="context">The context.</param>
public BuildScriptHost(
ICakeEngine engine,
ICakeContext context )
: base(engine, context)
{
}
internal static string[] ToRelativePathStrings(this IEnumerable<FilePath> filePaths, ICakeContext context, DirectoryPath repositoryDirectoryPath)
{
return filePaths
.Select(filePath => filePath.MakeRelativePath(context.Environment, repositoryDirectoryPath).FullPath)
.ToArray();
}
public static int PropertyAliasReturningInteger(this ICakeContext context)
{
return(42);
}
/// <summary>
/// Initializes a new instance of the <see cref="SlackProvider"/> class.
/// </summary>
/// <param name="context">The context.</param>
public SlackProvider(ICakeContext context)
{
_chat = new SlackChatProvider(context);
}
public static bool PropertyAliasReturningCachedBoolean(this ICakeContext context)
{
return(true);
}
public static void DotNetCoreExecute(this ICakeContext context, FilePath assemblyPath)
{
context.DotNetCoreExecute(assemblyPath, null);
}
/// <summary>
/// Sends an email via the SendGrid API, based on the provided settings
/// </summary>
/// <param name="context">The Cake Context</param>
/// <param name="senderName">The name of the person sending the email</param>
/// <param name="senderAddress">The email address of the person sending the email</param>
/// <param name="recipients">An enumeration of recipients who will receive the email</param>
/// <param name="subject">The subject line of the email</param>
/// <param name="htmlContent">The HTML content</param>
/// <param name="textContent">The text content</param>
/// <param name="attachments">Attachments to send with the email</param>
/// <param name="settings">The settings to be used when sending the email</param>
/// <returns>An instance of <see cref="SendGridResult"/> indicating success/failure</returns>
internal static SendGridResult SendEmail(this ICakeContext context, string senderName, string senderAddress, IEnumerable <System.Net.Mail.MailAddress> recipients, string subject, string htmlContent, string textContent, IEnumerable <System.Net.Mail.AttachmentBase> attachments, SendGridSettings settings)
{
if (recipients == null)
{
throw new CakeException("You must specify at least one recipient");
}
var safeRecipients = recipients.Where(r => r != null && !string.IsNullOrEmpty(r.Address));
if (!safeRecipients.Any())
{
throw new CakeException("None of the recipients you specified have an email address");
}
if (attachments == null)
{
attachments = Enumerable.Empty <System.Net.Mail.AttachmentBase>();
}
try
{
using (var client = new Client(settings.ApiKey))
{
context.Verbose("Sending email to {0} via the SendGrid API...", string.Join(", ", safeRecipients.Select(r => r.Address).ToArray()));
var from = new MailAddress(senderAddress, senderName);
var personalizations = safeRecipients.Select(r => new MailPersonalization {
To = new[] { new MailAddress(r.Address, r.DisplayName) }
}).ToArray();
var contents = new[]
{
new MailContent("text/plain", textContent),
new MailContent("text/html", htmlContent)
};
var trackingSettings = new TrackingSettings
{
ClickTracking = new ClickTrackingSettings
{
EnabledInHtmlContent = false,
EnabledInTextContent = false
},
OpenTracking = new OpenTrackingSettings {
Enabled = false
},
GoogleAnalytics = new GoogleAnalyticsSettings {
Enabled = false
},
SubscriptionTracking = null
};
var sendGridAttachments = attachments
.Select(a =>
{
var buffer = (byte[])null;
using (var ms = new MemoryStream())
{
a.ContentStream.CopyTo(ms);
buffer = ms.ToArray();
}
return(new StrongGrid.Model.Attachment()
{
Content = Convert.ToBase64String(buffer),
ContentId = a.ContentId,
Disposition = a is System.Net.Mail.LinkedResource ? "inline" : "attachment",
FileName = a.ContentType.Name,
Type = a.ContentType.MediaType
});
}).ToArray();
client.Mail.SendAsync(personalizations, subject, contents, from, null, sendGridAttachments, null, null, null, null, null, null, null, null, null, null, trackingSettings).Wait();
}
return(new SendGridResult(true, DateTime.UtcNow.ToString("u"), string.Empty));
}
catch (Exception e)
{
while (e.InnerException != null)
{
e = e.InnerException;
}
if (settings.ThrowOnFail.HasValue && settings.ThrowOnFail.Value)
{
throw new CakeException(e.Message);
}
else
{
return(new SendGridResult(false, DateTime.UtcNow.ToString("u"), e.Message));
}
}
}
public static void DotNetCoreRun(this ICakeContext context, string project, ProcessArgumentBuilder arguments)
{
context.DotNetCoreRun(project, arguments, null);
}
public void PerformSetup(Action <ICakeContext> action, ICakeContext context)
{
}
public static void DotNetCoreTest(this ICakeContext context)
{
context.DotNetCoreTest(null, null);
}
/// <summary>
/// Initializes a new instance of the <see cref="GitterProvider"/> class.
/// </summary>
/// <param name="context">The context.</param>
public GitterProvider(ICakeContext context)
{
_chat = new GitterChatProvider(context);
}
public ShowUnitRunner(ICakeContext context) : base(context)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="GitterChatProvider"/> class.
/// </summary>
/// <param name="context">The context.</param>
public GitterChatProvider(ICakeContext context)
{
_context = context;
}
/// <summary>
/// Initializes a new instance of the <see cref="TreeScriptHost"/> class.
/// </summary>
/// <param name="engine">The engine.</param>
/// <param name="context">The context.</param>
/// <param name="console">The console.</param>
public TreeScriptHost(ICakeEngine engine, ICakeContext context, IConsole console)
: base(engine, context)
{
_console = console ?? throw new ArgumentNullException(nameof(console));
}
public void Should_Make_Working_Directory_Absolute_If_Set_To_Relative(
ICakeContext context,
[NoAutoProperties] AdvProcessSettings settings, IAdvProcessRunner runner)
{
// Arrange
context.Environment.WorkingDirectory.Returns("/Working");
settings.WorkingDirectory = "OtherWorking";
Action sut =
() => context.StartAdvProcess("hello.exe", settings, runner);
// Act
sut();
// Assert
runner.Received(1).Start(
Arg.Any<FilePath>(),
Arg.Is<AdvProcessSettings>(info =>
info.WorkingDirectory.FullPath == "/Working/OtherWorking"));
}
public static ICollection <GitDiffFile> GitDiff(
this ICakeContext context,
DirectoryPath repositoryDirectoryPath,
string sinceCommitId,
string toCommitId
)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (repositoryDirectoryPath == null)
{
throw new ArgumentNullException(nameof(repositoryDirectoryPath));
}
if (string.IsNullOrWhiteSpace(sinceCommitId))
{
throw new ArgumentNullException(nameof(sinceCommitId));
}
return(context.UseRepository(
repositoryDirectoryPath,
repository =>
{
var initalCommit = new List <KeyValuePair <Tree, Tree> >();
if (sinceCommitId == Git.GitCommit.RootCommit)
{
var firstCommit = repository.Commits.Select(commit => commit).FirstOrDefault();
if (firstCommit == null)
{
return new GitDiffFile[0];
}
initalCommit.Add(
new KeyValuePair <Tree, Tree>(
repository.ObjectDatabase.CreateTree(new TreeDefinition()),
firstCommit.Tree
)
);
sinceCommitId = firstCommit.Sha;
}
if (!string.IsNullOrWhiteSpace(toCommitId))
{
var fromCommitTree = sinceCommitId == Git.GitCommit.RootCommit
? repository.ObjectDatabase.CreateTree(new TreeDefinition())
: repository.Lookup <Commit>(sinceCommitId)?.Tree;
var toCommitTree = repository.Lookup <Commit>(toCommitId)?.Tree;
return (
from change in repository.Diff.Compare <TreeChanges>(fromCommitTree, toCommitTree)
select new GitDiffFile(change)
).ToArray();
}
return (
from trees in initalCommit.Concat(
from commit in repository.Commits.QueryBy(new CommitFilter
{
SortBy = CommitSortStrategies.Reverse | CommitSortStrategies.Time,
IncludeReachableFrom = sinceCommitId,
ExcludeReachableFrom = repository.Lookup <Commit>(sinceCommitId)?.Parents
}) as IEnumerable <Commit> ?? new Commit[0]
from parent in commit.Parents
select new KeyValuePair <Tree, Tree>(parent.Tree, commit.Tree)
)
from change in repository.Diff.Compare <TreeChanges>(trees.Key, trees.Value)
select new GitDiffFile(change)
).ToArray();
}
));
//}
//return context.UseRepository(
// repositoryDirectoryPath,
// repository => (
// from commit in repository.Commits.QueryBy(new CommitFilter
// {
// SortBy = CommitSortStrategies.Reverse | CommitSortStrategies.Time,
// IncludeReachableFrom = sinceCommitId,
// ExcludeReachableFrom = repository.Lookup<Commit>(sinceCommitId)?.Parents
// }) as IEnumerable<Commit> ?? new Commit[0]
// from parent in commit.Parents
// from change in repository.Diff.Compare<TreeChanges>(parent.Tree, commit.Tree)
// select new GitDiffFile(change)
// ).ToList());
}
public void Should_Use_Provided_Working_Directory_If_Set(ICakeContext context,
[NoAutoProperties] AdvProcessSettings settings, IAdvProcessRunner runner)
{
// Arrange
settings.WorkingDirectory = "/OtherWorking";
Action sut =
() => context.StartAdvProcess("hello.exe", settings, runner);
// Act
sut();
// Assert
runner.Received(1).Start(
Arg.Any<FilePath>(),
Arg.Is<AdvProcessSettings>(info =>
info.WorkingDirectory.FullPath == "/OtherWorking"));
}
public static void Configure(ICakeContext context,
IReadOnlyList <ICakeTaskInfo> tasks)
{
Tasks = tasks;
Context = context;
}
/// <summary>
/// Initializes a new instance of the <see cref="KuduProvider"/> class.
/// </summary>
/// <param name="context">The context.</param>
internal KuduProvider(ICakeContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var environmenVariables = context.EnvironmentVariables();
Deployment = new Deployment(environmenVariables);
WebSite = new WebSite(environmenVariables);
SCM = new SCM(environmenVariables);
Tools = new Tools(environmenVariables);
AppSettings = environmenVariables
.Where(key => key.Key.StartsWith("APPSETTING_"))
.ToDictionary(
key => string.Concat(key.Key.Skip(11)),
value => value.Value
);
ConnectionStrings = environmenVariables
.Where(key => key.Key.StartsWith("SQLAZURECONNSTR_"))
.ToDictionary(
key => string.Concat(key.Key.Skip(16)),
value => value.Value
);
IsRunningOnKudu = !string.IsNullOrWhiteSpace(WebSite.Name);
_kuduSyncRunner = new KuduSyncRunner(context.FileSystem, context.Environment, context.Globber, context.ProcessRunner);
}
public Logger( ICakeContext ctx )
{
_ctx = ctx;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SvnAdd"/> class.
/// </summary>
public SvnAdd(ICakeContext context) : base(context)
{
base.Command = "add";
base.NonInteractive = true;
base.NoAuthCache = true;
}
private static async Task <bool> WaitForJobToFinishAsync(int projectId, long jobId, ICakeContext context)
{
var jobIsRunning = true;
while (jobIsRunning)
{
await Task.Delay(15000);
Console.WriteLine("Checking job status...");
var job = await GetJobAsync(projectId, jobId);
switch (job.Status)
{
case "success":
jobIsRunning = false;
context?.Log.Write(Verbosity.Normal, LogLevel.Information, "Job succeeded");
break;
case "failed":
context?.Log.Write(Verbosity.Normal, LogLevel.Information, "Job failed");
return(false);
case "canceled":
context?.Log.Write(Verbosity.Normal, LogLevel.Information, "Job was cancelled");
return(false);
case "skipped":
context?.Log.Write(Verbosity.Normal, LogLevel.Information, "Job was skipped");
return(false);
default:
continue;
}
}
return(true);
}
public static void NotAScriptMethod(this ICakeContext context)
{
}
// ReSharper disable once UnusedTypeParameter
public static void GenericScriptMethod <T>(this ICakeContext context)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SlackChatProvider"/> class.
/// </summary>
/// <param name="context">The context.</param>
public SlackChatProvider(ICakeContext context)
{
_context = context;
}
public static void PropertyAliasWithMoreThanOneMethod(this ICakeContext context, int number)
{
}
private static SlackChatMessageResult PostToIncomingWebHook(
ICakeContext context,
string channel,
string text,
SlackChatMessageSettings messageSettings
)
{
if (messageSettings == null)
{
throw new ArgumentNullException("messageSettings", "Invalid slack message specified");
}
if (string.IsNullOrWhiteSpace(messageSettings.IncomingWebHookUrl))
{
throw new NullReferenceException("Invalid IncomingWebHookUrl supplied.");
}
context.Verbose(
"Posting to incoming webhook {0}...",
string.Concat(
messageSettings
.IncomingWebHookUrl
.TrimEnd('/')
.Reverse()
.SkipWhile(c => c != '/')
.Reverse()
)
);
var postJson = JsonMapper.ToJson(
new
{
channel,
text,
username = messageSettings.UserName ?? "CakeBuild",
icon_url =
messageSettings.IconUrl != null
? messageSettings.IconUrl.AbsoluteUri
: "https://raw.githubusercontent.com/cake-build/graphics/master/png/cake-small.png"
}
);
context.Debug("Parameter: {0}", postJson);
using (var client = new WebClient())
{
var postBytes = Encoding.UTF8.GetBytes(postJson);
var resultBytes = client.UploadData(
messageSettings.IncomingWebHookUrl,
"POST",
postBytes
);
var result = Encoding.UTF8.GetString(
resultBytes
);
var parsedResult = new SlackChatMessageResult(
StringComparer.OrdinalIgnoreCase.Equals(result, "ok"),
channel,
string.Empty,
StringComparer.OrdinalIgnoreCase.Equals(result, "ok") ? string.Empty : result
);
context.Debug("Result parsed: {0}", parsedResult);
return parsedResult;
}
}
public static void PropertyAliasReturningVoid(this ICakeContext context)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CakeMSBuildEngine"/> class.
/// </summary>
/// <param name="context">The context.</param>
public CakeMSBuildEngine(ICakeContext context)
{
this.context = context;
}
public Ef6AliasesFacts()
{
_context = Substitute.For<ICakeContext>();
}
