/// <summary>
/// Find a node from the supplied key. The action is used to determine what
/// to do if the node does not exist.
/// </summary>
private Node FindNode(TKey key, NotFoundAction action)
{
Node currentNode = _root;
foreach (TSubKey subKey in key)
{
Node found = currentNode.GetChildForKey(subKey, _subKeyComparer);
if (found == null)
{
if (action == NotFoundAction.CreateNew)
{
found = Node.Create(subKey);
currentNode.AddNode(found);
}
else if (action == NotFoundAction.ReturnNull)
{
return(null);
}
else
{
throw new InvalidOperationException("Inexhuastive branches");
}
}
currentNode = found;
}
return(currentNode);
}
public void Constructor_SetsStatusCode()
{
// Act
NotFoundAction action = new NotFoundAction();
// Assert
Assert.AreEqual(HttpStatusCode.NotFound, action.StatusCode);
}
public void Execute_WithNullContext_Throws()
{
// Arrange
NotFoundAction action = new NotFoundAction();
IRewriteContext context = null;
// Act/Assert
ExceptionAssert.Throws <ArgumentNullException>(() => action.Execute(context));
}
/// <summary>
/// Returns the part of the source string before the first occurrence of the specified character.
/// </summary>
/// <param name="source"></param>
/// <param name="ch"></param>
/// <returns></returns>
static public String LeftOfFirst(this String source, Char ch, NotFoundAction notFoundAction = NotFoundAction.returnNull)
{
int index = source.IndexOf(ch);
if (index == -1)
{
return(source.HandleNotFoundAction(notFoundAction));
}
string subString = source.Substring(0, index);
return(subString);
}
/// <summary>
/// Returns the part of the source string after the last occurrence of the specified character.
/// </summary>
/// <param name="source"></param>
/// <param name="ch"></param>
/// <returns></returns>
static public String RightOfLast(this String source, Char ch, NotFoundAction notFoundAction = NotFoundAction.returnNull)
{
int index = source.LastIndexOf(ch);
if (index == -1)
{
return(source.HandleNotFoundAction(notFoundAction));
}
string subString = source.Substring(index + 1);
return(subString);
}
/// <summary>
/// Returns the part of the source string before any occurrence of the specified characters.
/// </summary>
/// <param name="source"></param>
/// <param name="match"></param>
/// <param name="notFoundAction"></param>
/// <param name="stringComparison"></param>
/// <returns></returns>
public static string LeftOfFirst(this string source,
string match,
NotFoundAction notFoundAction = NotFoundAction.returnNull,
StringComparison stringComparison = StringComparison.CurrentCulture)
{
int index = source.IndexOf(match, stringComparison);
if (index == -1)
{
return(source.HandleNotFoundAction(notFoundAction));
}
return(source.Substring(0, index));
}
public void Execute_SetsStatusCode_ReturnsStopProcessing()
{
// Arrange
NotFoundAction action = new NotFoundAction();
IRewriteContext context = new MockRewriteContext();
// Act
RewriteProcessing result = action.Execute(context);
// Assert
Assert.AreEqual(HttpStatusCode.NotFound, context.StatusCode);
Assert.AreEqual(RewriteProcessing.StopProcessing, result);
}
/// <summary>
/// Returns the part of the source string before the first occurrence of the specified character.
/// </summary>
/// <param name="source"></param>
/// <param name="ch"></param>
/// <returns></returns>
static public String LeftOfLast(this String source,
string match,
NotFoundAction notFoundAction = NotFoundAction.returnNull,
StringComparison stringComparison = StringComparison.CurrentCulture)
{
int index = source.LastIndexOf(match, stringComparison);
if (index == -1)
{
return(source.HandleNotFoundAction(notFoundAction));
}
string subString = source.Substring(0, index);
return(subString);
}
private static string HandleNotFoundAction(this string source, NotFoundAction notFoundAction)
{
switch (notFoundAction)
{
case NotFoundAction.returnNull: return(null);
case NotFoundAction.returnEmpty: return(String.Empty);
case NotFoundAction.returnAll: return(source);
case NotFoundAction.throwException: throw new ArgumentException("Match string not present in the source string");
default: throw new NotImplementedException($"{notFoundAction} is not handled");
}
}
private async Task <string> GetAsync(string url, NotFoundAction action = NotFoundAction.ThrowException)
{
if (string.IsNullOrEmpty(serverUrl))
{
return(null);
}
using (var client = await this.CreateHttpClientAsync().ConfigureAwait(false))
{
var downloadUrl = IJenkinsConnectionInfoExtensions.GetApiUrl(this.serverUrl) + '/' + url.TrimStart('/');
this.logger?.LogDebug($"Downloading string from {downloadUrl}...");
using (var response = await client.GetAsync(downloadUrl, this.cancellationToken).ConfigureAwait(false))
{
if (response.StatusCode == HttpStatusCode.NotFound && action == NotFoundAction.ReturnNull)
{
return(null);
}
response.EnsureSuccessStatusCode();
return(await response.Content.ReadAsStringAsync().ConfigureAwait(false));
}
}
}
public void LeftOfLast(string source, string match, NotFoundAction notFound, System.StringComparison stringComparison, string expected)
{
string result = source.LeftOfLast(match, notFound, stringComparison);
Assert.AreEqual(expected, result);
}