public string GetInvalidArgumentValueFailureMessage(IArrangement arrangement, IInvocation invocation)
{
var compareLogic = new CompareLogic();
var arrangementMethod = (IArrangementMethod)arrangement;
var arrangementArguments = arrangementMethod.ArrangementArguments;
IArrangementArgument arrangementArgument = null;
for (var index = 0; index < arrangementArguments.Length; index++)
{
var arrangementArgumentValue = arrangementArguments[index].ArgumentValue;
var invocationArgumentValue = invocation.Arguments[index];
var comparisonResult = compareLogic.Compare(arrangementArgumentValue, invocationArgumentValue);
if (comparisonResult.AreEqual)
{
continue;
}
arrangementArgument = arrangementArguments[index];
break;
}
var ordinalPosition = arrangementArgument?.OrdinalPosition;
var argumentName = arrangementArgument?.ArgumentName;
var failureMessage = $"{arrangementMethod.MethodName} was not called with arranged argument " +
$"for the {ordinalPosition} argument {{{argumentName}}}.";
return(failureMessage);
}
private void UpdateArrangementCount(IArrangement arrangement, long proxyIdentifier, int metadataToken)
{
if (_arrangementCallsMade.ContainsKey(proxyIdentifier))
{
if (_arrangementCallsMade[proxyIdentifier].ContainsKey(metadataToken))
{
var isPropertyArrangement = arrangement is IArrangementProperty;
if (!isPropertyArrangement)
{
_arrangementCallsMade[proxyIdentifier][metadataToken]++;
}
}
else
{
_arrangementCallsMade[proxyIdentifier].Add(metadataToken, 1);
}
}
else
{
_arrangementCallsMade.Add(proxyIdentifier, new Dictionary <int, int>
{
{ metadataToken, 1 }
});
}
}
public void Clone(IArrangement arrangement)
{
Vendor = arrangement.Vendor;
StartTime = arrangement.StartTime;
EndTime = arrangement.EndTime;
Status = arrangement.Status;
Id = arrangement.Id;
}
public void AddArrangement(IArrangement arrangement)
{
var proxy = arrangement.Proxy;
var proxyIdentifier = GetProxyIdentifier(proxy);
var metadataToken = arrangement.MetadataToken;
AddArrangement(arrangement, proxyIdentifier, metadataToken);
UpdateArrangementCount(arrangement, proxyIdentifier, metadataToken);
}
/// <summary>
/// Arrange <see cref="Fetcher"/>'s members if possible, if it is an <see cref="IRawArrangedLayout"/>.
/// </summary>
/// <param name="arrangement">arangement to use, can be null</param>
/// <param name="converters">converters to consider, can be null</param>
/// <param name="fetcher">fetches an object from a logging event</param>
/// <param name="renderer">serializes the object</param>
/// <param name="decorators">decorates the object before serialization</param>
public virtual void SetUp(IArrangement arrangement, IEnumerable <ConverterInfo> converters, IRawLayout fetcher, IObjectRenderer renderer, IEnumerable <IDecorator> decorators)
{
var decoratorsArray = decorators == null ? null : Enumerable.ToArray(decorators);
Fetcher = fetcher ?? Fetcher ?? CreateFetcher();
Decorators = decoratorsArray ?? Decorators ?? CreateDecorators();
Renderer = renderer ?? Renderer ?? CreateRenderer();
Arrange(arrangement, converters);
}
/// <summary>
/// Arrange members
/// </summary>
/// <param name="arrangement">by arrangement</param>
/// <param name="converters">with converters</param>
protected virtual void Arrange(IArrangement arrangement, IEnumerable <ConverterInfo> converters)
{
var convertersArray = converters == null ? null : Enumerable.ToArray(converters);
var arrangedFetcher = Fetcher as IRawArrangedLayout;
if (arrangedFetcher != null && arrangement != null)
{
arrangement.Arrange(arrangedFetcher.Members, convertersArray);
}
}
public string GetGenericTypeArgumentFailureMessage(IArrangement arrangement, IInvocation invocation)
{
var arrangementMethod = (IArrangementMethod)arrangement;
var memberName = arrangementMethod.MethodName;
var arrangementMethodGenericArguments = arrangementMethod.GenericArguments;
var arrangementFriendlyArguments = arrangementMethodGenericArguments.Select(type => type.GetFriendlyTypeName());
var arrangementFriendlyArgumentsCommaSeparated = $"<{string.Join(", ", arrangementFriendlyArguments)}>";
var invocationGenericArguments = invocation.GenericArguments;
var invocationFriendlyArguments = invocationGenericArguments.Select(type => type.GetFriendlyTypeName());
var invocationFriendlyArgumentsSeparated = $"<{string.Join(", ", invocationFriendlyArguments)}>";
var failureMessage = $"{memberName} was arranged with generic type(s) {arrangementFriendlyArgumentsCommaSeparated}, " +
$"but was called with the generic type(s) {invocationFriendlyArgumentsSeparated}.";
return(failureMessage);
}
public void TestArrangementCRUD()
{
IArrangement a = CreateArrangement();
var ap = new ArrangementProcessor(a);
var save = ap.Create().Result;
Assert.IsTrue(save.Data != null && save.Data.Id != Guid.Empty, "Arrangement save failed.");
var one = ap.FetchById().Result;
Assert.IsTrue(one.Data != null, "Arrangement fetch failed.");
var delete = ap.Delete().Result;
one = ap.FetchById().Result;
Assert.IsTrue(one.Data == null, "Arrangement delete failed.");
}
internal static string GetFriendlyMemberName(this IArrangement arrangement)
{
string memberName;
switch (arrangement)
{
case IArrangementProperty arrangementProperty:
memberName = arrangementProperty.PropertyName;
break;
case IArrangementMethod arrangementMethod:
memberName = arrangementMethod.MethodName;
break;
default:
return(null);
}
return(memberName);
}
private void AddArrangement(IArrangement arrangement, long proxyIdentifier, int metadataToken)
{
if (_arrangementQueue.ContainsKey(proxyIdentifier))
{
if (_arrangementQueue[proxyIdentifier].ContainsKey(metadataToken))
{
_arrangementQueue[proxyIdentifier][metadataToken].Enqueue(arrangement);
}
else
{
_arrangementQueue[proxyIdentifier].Add(metadataToken, new Queue <IArrangement>(new[] { arrangement }));
}
}
else
{
_arrangementQueue.Add(proxyIdentifier, new Dictionary <int, Queue <IArrangement> >
{
{ metadataToken, new Queue <IArrangement>(new[] { arrangement }) }
});
}
}
public void VerifyArgumentValues(IArrangement arrangement, IInvocation invocation)
{
object[] arrangementArguments;
object[] invocationArguments;
switch (arrangement)
{
case IArrangementProperty arrangementProperty:
var arguments = new[] { arrangementProperty.ReturnValue };
arrangementArguments = arguments;
invocationArguments = arguments;
break;
case IArrangementMethod arrangementMethod:
arrangementArguments = arrangementMethod.ArrangementArguments
.Select(arrangementArgument => arrangementArgument.ArgumentValue)
.ToArray();
invocationArguments = invocation.Arguments;
break;
default:
throw new ArgumentOutOfRangeException(arrangement.GetType().Name);
}
var comparisonResult = _compareLogic.Compare(arrangementArguments, invocationArguments);
if (comparisonResult.AreEqual)
{
return;
}
var mockExceptionMessage = _mockFailureMessageFactory.GetInvalidArgumentValueFailureMessage(arrangement, invocation);
throw new MockException(mockExceptionMessage);
}
public void VerifyGenericTypeArguments(IArrangement arrangement, IInvocation invocation)
{
var arrangementMethod = arrangement as IArrangementMethod;
var arrangementHasNoGenericTypeArguments = arrangementMethod == null;
if (arrangementHasNoGenericTypeArguments)
{
return;
}
var arrangementGenericArguments = arrangementMethod.GenericArguments;
var invocationGenericArguments = invocation.GenericArguments ?? new Type[0];
var comparisonResult = _compareLogic.Compare(arrangementGenericArguments, invocationGenericArguments);
if (comparisonResult.AreEqual)
{
return;
}
var mockExceptionMessage = _mockFailureMessageFactory.GetGenericTypeArgumentFailureMessage(arrangement, invocation);
throw new MockException(mockExceptionMessage);
}
/// <summary>
/// Add <see cref="PatternConverter.Properties"/> or make use of <see cref="ISerializingPatternConverter.SetUp"/>,
/// call <see cref="IOptionHandler.ActivateOptions"/>
/// </summary>
/// <param name="conv">serializer to be set up, see also <seealso cref="ISerializingPatternConverter"/></param>
/// <param name="converters">converters to be used collected from parent class</param>
/// <param name="arrangement">arrangement to be used collected from parent class</param>
/// <param name="fetcher">fetcher to use</param>
/// <param name="renderer">renderer to use</param>
/// <param name="decorators">decorators to use</param>
/// <remarks>
/// <para>
/// Please note that properties are only supported with log4net 1.2.11 and above.
/// </para>
/// </remarks>
protected virtual void SetUpSerializingConverter(PatternConverter conv, ConverterInfo[] converters, IArrangement arrangement, IRawLayout fetcher, IObjectRenderer renderer, IDecorator[] decorators)
{
var serializedConv = conv as ISerializingPatternConverter;
if (serializedConv != null)
{
serializedConv.SetUp(arrangement, converters, fetcher, renderer, decorators);
}
#if !LOG4NET_1_2_10_COMPATIBLE
else
{
LogLog.Warn(GetType(), String.Format("Converter is not a ISerializingPatternConverter: {0}. Passing fetcher, renderer, decorators, arrangement and converters as properties.", conv));
conv.Properties["arrangement"] = arrangement;
conv.Properties["converters"] = converters;
conv.Properties["fetcher"] = fetcher;
conv.Properties["renderer"] = renderer;
conv.Properties["decorators"] = decorators;
}
/// <summary>
/// Add an arbitrary <see cref="IArrangement"/>.
/// This method will be most useful for XML configuration.
/// </summary>
/// <param name="value">the arrangement</param>
public virtual void AddArrangement(IArrangement value)
{
m_arrangement.AddArrangement(value);
}
/// <summary>
/// Add <see cref="PatternConverter.Properties"/>,
/// call <see cref="IOptionHandler.ActivateOptions"/>
/// </summary>
/// <param name="conv">serializer to be set up</param>
/// <param name="converters">converters to be used collected from parent class</param>
/// <param name="arrangement">arrangement to be used collected from parent class</param>
/// <param name="fetcher">fetcher to use</param>
/// <param name="renderer">renderer to use</param>
/// <param name="decorators">decorators to use</param>
/// <remarks>
/// <para>
/// Please note that properties are only supported with log4net 1.2.11 and above.
/// </para>
/// </remarks>
protected virtual void SetUpSerializingConverter(PatternConverter conv, ConverterInfo[] converters, IArrangement arrangement, IRawLayout fetcher, IObjectRenderer renderer, IDecorator[] decorators)
{
conv.Properties["arrangement"] = arrangement;
conv.Properties["converters"] = converters;
conv.Properties["fetcher"] = fetcher;
conv.Properties["renderer"] = renderer;
conv.Properties["decorators"] = decorators;
IOptionHandler optionHandler = conv as IOptionHandler;
if (optionHandler != null)
{
optionHandler.ActivateOptions();
}
}
public static void Return(this IArrangement arrangement, object value)
{
arrangement.SetReturnValue(value);
MockInvocationCache.Add(arrangement);
}
public static void Add(IArrangement arrangement)
{
MockInvocationAuditor.AddArrangement(arrangement);
}
/// <summary>
/// Well, add an arrangement
/// </summary>
/// <param name="arrangement">Arrangement to add</param>
public virtual void AddArrangement(IArrangement arrangement)
{
Arrangements.Add(arrangement);
}
/// <inheritdoc cref="IArrangementCollection" />
public void Add(IArrangement arrangement)
{
Ensures.NotNull(arrangement, nameof(arrangement));
Arrangements.Add(arrangement);
}
