public void GetValue_ValueFactoryThrows(bool specifyJtf)
{
var exception = new InvalidOperationException();
var completeValueFactory = new AsyncManualResetEvent();
var jtf = specifyJtf ? new JoinableTaskContext().Factory : null; // use our own so we don't get main thread deadlocks, which isn't the point of this test.
var lazy = new AsyncLazy <GenericParameterHelper>(() => throw exception, jtf);
// Verify that we throw the right exception the first time.
Assert.Same(exception, Assert.Throws(exception.GetType(), () => lazy.GetValue()));
// Assert that we rethrow the exception the second time.
Assert.Same(exception, Assert.Throws(exception.GetType(), () => lazy.GetValue()));
}
public static void MetadataApiException_Constructor_For_Serialization_Can_Be_Serialized()
{
// Arrange
InvalidOperationException innerException = new InvalidOperationException();
string message = Guid.NewGuid().ToString();
// Act
MetadataApiException target = new MetadataApiException(message, innerException);
BinaryFormatter formatter = new BinaryFormatter();
MetadataApiException deserialized;
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, target);
stream.Seek(0L, SeekOrigin.Begin);
deserialized = formatter.Deserialize(stream) as MetadataApiException;
}
// Assert
Assert.NotNull(deserialized);
Assert.NotNull(deserialized.InnerException);
Assert.IsType(innerException.GetType(), deserialized.InnerException);
Assert.Equal(deserialized.Message, target.Message);
}
public void TestPropIfItThrewException()
{
InvalidOperationException ex = Assert.Throws <InvalidOperationException>(() => this.database =
new Database(new int[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }));
Assert.AreEqual(ex.GetType(), typeof(InvalidOperationException));
}
public void Execute_ExceptionIsPassedToInterceptors()
{
var executable = A.Fake <IExecutable <string, string> >();
var exception = new InvalidOperationException();
A.CallTo(() => executable.Execute("parameter hello")).Throws(exception);
var generalInterceptor1 = A.Fake <IExecutionInterceptor>();
A.CallTo(() => generalInterceptor1.OrderingIndex).Returns(1);
var generalInterceptor2 = A.Fake <IExecutionInterceptor>();
A.CallTo(() => generalInterceptor2.OrderingIndex).Returns(3);
var specificInterceptor = A.Fake <IExecutionInterceptor <IExecutable <string, string>, string, string> >();
A.CallTo(() => specificInterceptor.OrderingIndex).Returns(2);
ServiceProvider serviceProvider = new ServiceCollection().AddExecutor().AddExecutable(executable).AddSpecificInterceptors(specificInterceptor).AddGeneralInterceptors(generalInterceptor1, generalInterceptor2).BuildServiceProvider();
var executor = serviceProvider.GetRequiredService <IExecutor>();
_ = Assert.Throws(exception.GetType(), () => executor.Execute <IExecutable <string, string>, string, string>("parameter hello"));
// interceptors called in ascending OrderIndex order
_ = A.CallTo(() => generalInterceptor1.Before(executable, "parameter hello")).MustHaveHappenedOnceExactly()
.Then(A.CallTo(() => specificInterceptor.Before(executable, "parameter hello")).MustHaveHappenedOnceExactly())
.Then(A.CallTo(() => generalInterceptor2.Before(executable, "parameter hello")).MustHaveHappenedOnceExactly())
// executable called
.Then(A.CallTo(() => executable.Execute("parameter hello")).MustHaveHappenedOnceExactly())
// interceptors called in descending OrderIndex order
.Then(A.CallTo(() => generalInterceptor2.After(executable, "parameter hello", default(string), exception)).MustHaveHappenedOnceExactly())
.Then(A.CallTo(() => specificInterceptor.After(executable, "parameter hello", default(string), exception)).MustHaveHappenedOnceExactly())
.Then(A.CallTo(() => generalInterceptor1.After(executable, "parameter hello", default(string), exception)).MustHaveHappenedOnceExactly());
}
public void Output_ExceptionProperties()
{
// Arrange
var testEnricher = new TestEnricher();
var testOutputSink = new TestSinkWithFormatter(new NewRelicFormatter());
var testLogger = TestHelpers.GetLogger(testOutputSink, testEnricher);
var testException = new InvalidOperationException(TestErrMsg);
// Act
try
{
TestHelpers.CreateStackTracedError(0, testException, 3);
}
catch (Exception ex)
{
testLogger.Error(ex, LogMessage);
}
// Assert
Asserts.NoSerilogErrorsCountOutputs(_testRunDebugLogs, testOutputSink.InputsAndOutputs, LogMessage);
var resultDic = TestHelpers.SerializeOutputJSON(testOutputSink.InputsAndOutputs[0]);
Asserts.PropertyCountsMatch(testEnricher, countIntrinsicProperties + 3, resultDic);
Asserts.KeyAndValueMatch(resultDic, "error.message", TestErrMsg);
Asserts.KeyAndValueMatch(resultDic, "error.class", testException.GetType().FullName);
Asserts.KeyAndValueMatch(resultDic, "error.stack", testException.StackTrace);
}
public void ValidateToken_ISecurityTokenValidator_WhenFailure_ExpectInnerException()
{
var token = Guid.NewGuid().ToString();
var validationParameters = new TokenValidationParameters();
var expectedException = new InvalidOperationException("test");
var mockHandler = new Mock <TestJwtPayloadTokenHandler> {
CallBase = true
};
mockHandler.Setup(x => x.ValidateToken(token, validationParameters))
.Returns(new TokenValidationResult
{
IsValid = false,
Exception = expectedException
});
SecurityToken parsedToken = null;
var exception = Assert.Throws(
expectedException.GetType(),
() => mockHandler.Object.ValidateToken(token, validationParameters, out parsedToken));
parsedToken.Should().BeNull();
exception.Should().Be(expectedException);
}
public void ProcessError_LoggingWorksWithUnrecognizedExceptionObject()
{
ILog log = Substitute.For <ILog>();
IProcessWrapperFactory procFactory = Substitute.For <IProcessWrapperFactory>();
procFactory.CreateProcess().Returns(new FakeStandardProcess());
var serviceApp = new ServiceApp {
Name = "Test", AppVersion = new Version()
};
ServiceAppProcess appProcToTest = new ServiceAppProcess(serviceApp, log, procFactory);
Exception testException = new InvalidOperationException("test");
string exceptionMessage = string.Format(@"{{ error: {{
details: {{
type: ""{0}"",
message: ""{1}"",
source: ""{2}"",
stackTrace: ""{3}""
}},
exception: ""xxxxx""
}} }}",
testException.GetType().ToString(),
testException.Message,
testException.Source,
testException.StackTrace);
bool shouldExit = appProcToTest.ProcessMessage(exceptionMessage);
log.Received().Warn(Arg.Any <string>());
Assert.IsFalse(shouldExit, "Process message was not meant to return true");
}
private void HandleOperationException(InvalidOperationException e, HttpWebResponse response)
{
Func <Stream> getResponseStream = null;
Descriptor descriptor = base.ChangedEntries[base.entryIndex];
Dictionary <string, string> headers = null;
HttpStatusCode internalServerError = HttpStatusCode.InternalServerError;
Version parsedResponseVersion = null;
if (response != null)
{
headers = WebUtil.WrapResponseHeaders(response);
base.HandleOperationResponseHeaders(response.StatusCode, headers);
if (getResponseStream == null)
{
getResponseStream = () => WebUtil.GetResponseStream(response, (DataServiceContext)this.Source);
}
e = BaseSaveResult.HandleResponse(base.RequestInfo, response.StatusCode, response.Headers["DataServiceVersion"], getResponseStream, false, out parsedResponseVersion);
internalServerError = response.StatusCode;
}
else
{
headers = new Dictionary <string, string>(StringComparer.Ordinal);
headers.Add("Content-Type", "text/plain");
if (e.GetType() != typeof(DataServiceClientException))
{
e = new DataServiceClientException(e.Message, e);
}
}
this.cachedResponses.Add(new CachedResponse(descriptor, headers, internalServerError, parsedResponseVersion, null, e));
base.perRequest = null;
this.CheckContinueOnError();
}
// This snapshot won't contain full normal data for Function.FullName, Function.ShortName and Function.Parameters.
// (All we know is an unavailable function ID; which function location method info to use is a mystery.)
private static FunctionCompletedMessage CreateFailedMessage(CallAndOverrideMessage message)
{
DateTimeOffset startAndEndTime = DateTimeOffset.UtcNow;
Exception exception = new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"No function '{0}' currently exists.", message.FunctionId));
// In theory, we could also set HostId, HostInstanceId and WebJobRunId; we'd just have to expose that data
// directly to this Worker class.
return(new FunctionCompletedMessage
{
FunctionInstanceId = message.Id,
Function = new FunctionDescriptor
{
Id = message.FunctionId
},
Arguments = message.Arguments,
ParentId = message.ParentId,
Reason = message.Reason,
StartTime = startAndEndTime,
EndTime = startAndEndTime,
Failure = new FunctionFailure
{
Exception = exception,
ExceptionType = exception.GetType().FullName,
ExceptionDetails = exception.Message
}
});
}
public void can_create_degraded_with_exception_info()
{
var exception = new InvalidOperationException();
var exceptionString = $"EXCEPTION: {exception.GetType().Name} - {exception.Message}";
var result = HealthCheckResult.Degraded(exception);
result.Message.Should().StartWith(exceptionString);
result.Status.Should().Be(HealthCheckStatus.Degraded);
}
public void ReportException_ExceptionWithMessage_ReportsToGitHub()
{
var exception = new InvalidOperationException("Moon exploded :(");
reporter.ReportException(new UnhandledExceptionEventArgs(exception, true));
Assert.StartsWith("https://github.com/waf/replay-csharp/issues/new", reportedUrl);
Assert.Contains(Uri.EscapeDataString(exception.Message), reportedUrl);
Assert.Contains(Uri.EscapeDataString(exception.GetType().Name), reportedUrl);
}
public void IndexViewResultRedirectCorrect()
{
InvalidOperationException exception = new InvalidOperationException();
ErrorController controller = new ErrorController();
ViewResult result = controller.Index(exception.GetType().Name) as ViewResult;
Assert.AreEqual("NotFound", result.ViewName);
}
public void TestCreateMatroshika()
{
var value = new InvalidOperationException(Guid.NewGuid().ToString(), new Exception());
var result = ExceptionDispatchInfo.CreateMatroshika(value);
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.TypeOf(value.GetType()));
Assert.That(result.Message, Is.EqualTo(value.Message));
Assert.That(result.InnerException, Is.SameAs(value));
}
public void Ctor_CopyFrom_InnerExceptions()
{
var template = new InvalidOperationException("outer", new InvalidCastException("inner"));
var errorData = new CommonErrorData(template);
Assert.Equal(template.GetType().FullName, errorData.TypeName);
Assert.Equal(template.Message, errorData.Message);
Assert.Equal(template.InnerException.GetType().FullName, errorData.Inner?.TypeName);
Assert.Equal(template.InnerException.Message, errorData.Inner?.Message);
}
/// <summary>
/// get packet from packet cache or decode from buffer.
/// </summary>
/// <param name="timeout">
/// a TimeSpan object that specifies the timeout
/// </param>
/// <param name="removeEvent">
/// a bool value that indicates whether need to remove the event from buffer.
/// </param>
/// <param name="remoteEndPoint">
/// an object that specifies the remote endpoint.
/// </param>
/// <returns>
/// a StackPacket object that contains the decoded packet.
/// </returns>
private StackPacket GetPacket(TimeSpan timeout, bool removeEvent, out object remoteEndPoint)
{
// get the packet in packet list.
IPEndPointStackPacket packet = Utility.GetOne <IPEndPointStackPacket>(this.packetCache, null);
if (packet != null)
{
remoteEndPoint = packet.RemoteEndPoint;
return(packet.Packet);
}
UdpReceivedBytes bytes = this.buffer.Dequeue(timeout);
remoteEndPoint = bytes.RemoteEndPoint;
// exception event arrived
if (bytes.Packet == null)
{
if (!removeEvent)
{
this.buffer.Enqueue(bytes);
}
InvalidOperationException exc =
new InvalidOperationException("exception arrived when expect packet from udp.");
// identify this exception.
exc.Data.Add(exc.GetType().Name, true);
throw exc;
}
// decode packets using data in buffer.
int consumedLength = 0;
int expectedLength = 0;
StackPacket[] packets = this.decoder(remoteEndPoint, bytes.Packet, out consumedLength, out expectedLength);
// if no packet, drop the recieved data and continue.
if (packets == null || packets.Length == 0)
{
throw new InvalidOperationException("udp client failed to decode udp packet");
}
// if packet arrived, add to packet list, and return the first.
foreach (StackPacket item in packets)
{
this.packetCache.Enqueue(
new IPEndPointStackPacket(item, bytes.RemoteEndPoint, bytes.LocalEndPoint));
}
// set timeout to zero. when packet is decoded, must not wait.
return(GetPacket(new TimeSpan(), removeEvent, out remoteEndPoint));
}
public void When_log_exception_Then_exception_is_in_output()
{
var message = "Exception message.";
var exceptionMessage = "Test exception thrown!";
var exception = new InvalidOperationException(exceptionMessage);
Assert.Empty(output.Output);
Log.Error(exception, message);
Assert.Contains(message, output.Output);
Assert.Contains(exception.GetType().FullName, output.Output);
Assert.Contains(exceptionMessage, output.Output);
}
public void TestAddNewProp()
{
// TODO: AAA
mod1 = new AllPropsRegisteredModel(PropBagTypeSafetyMode.AllPropsMustBeRegistered,
_amHelpers.StoreAccessCreator, _amHelpers.PropFactory_V1);
InvalidOperationException kk = new InvalidOperationException();
Type tt = kk.GetType();
Assert.Throws(tt, () => mod1["System.String", "NewProperty"] = "This is a a test.");
}
public void Log_Sanitizes()
{
string secretReplacement = "[Hidden Credential]";
string secretString = "{ \"AzureWebJobsStorage\": \"DefaultEndpointsProtocol=https;AccountName=testAccount1;AccountKey=mykey1;EndpointSuffix=core.windows.net\", \"AnotherKey\": \"AnotherValue\" }";
string sanitizedString = $"{{ \"AzureWebJobsStorage\": \"{secretReplacement}\", \"AnotherKey\": \"AnotherValue\" }}";
string secretException = "Invalid string: \"DefaultEndpointsProtocol=https;AccountName=testaccount;AccountKey=testkey;BlobEndpoint=https://testaccount.blob.core.windows.net/;QueueEndpoint=https://testaccount.queue.core.windows.net/;TableEndpoint=https://testaccount.table.core.windows.net/;FileEndpoint=https://testaccount.file.core.windows.net/;\"";
string sanitizedDetails = $"System.InvalidOperationException : Invalid string: \"{secretReplacement}\"";
string sanitizedExceptionMessage = $"Invalid string: \"{secretReplacement}\"";
string functionInvocationId = Guid.NewGuid().ToString();
Exception ex = new InvalidOperationException(secretException);
string properties = null;
_mockEventGenerator.Setup(p => p.LogAzureMonitorDiagnosticLogEvent(LogLevel.Error, _websiteHostName, AzureMonitorDiagnosticLogger.AzureMonitorOperationName, AzureMonitorDiagnosticLogger.AzureMonitorCategoryName, _regionName, It.IsAny <string>()))
.Callback <LogLevel, string, string, string, string, string>((t, r, o, c, l, p) =>
{
// Store off the properties for later validation
properties = p;
});
using (CreateScope(functionName: _functionName, functionInvocationId: functionInvocationId))
{
_logger.LogError(ex, secretString);
}
_mockEventGenerator.VerifyAll();
var level = LogLevel.Error;
JObject actual = JObject.Parse(properties);
JObject expected = JObject.FromObject(new
{
appName = _appServiceOptionsWrapper.CurrentValue.AppName,
roleInstance = _roleInstance,
category = _category,
exceptionDetails = sanitizedDetails,
exceptionMessage = sanitizedExceptionMessage,
exceptionType = ex.GetType().ToString(),
functionInvocationId,
functionName = _functionName,
hostInstanceId = _hostInstanceId,
hostVersion = ScriptHost.Version,
level = level.ToString(),
levelId = (int)level,
message = sanitizedString,
processId = _processId
});
Assert.True(JToken.DeepEquals(actual, expected), $"Actual: {actual.ToString()}{Environment.NewLine}Expected: {expected.ToString()}");
}
public void SerializesProperties()
{
var exception = new InvalidOperationException("Some message")
{
HelpLink = "http://example.com"
};
var errors = new ErrorSerializer().Serialize(new ApiError(exception))["errors"][0];
Assert.Equal(exception.Message, errors.Value <string>("title"));
Assert.Equal(exception.HelpLink, errors["links"].Value <string>("about"));
Assert.Equal(exception.GetType().FullName, errors.Value <string>("code"));
Assert.Equal(exception.ToString(), errors.Value <string>("detail"));
}
public void Can_Log_Exceptions_On_Messages()
{
//In your code you'll want to inject the logger in the constructor,
//generally from the .NET Core Dependency Injection framework.
var logger = GetLogger <Basic_Logging_Tests>();
var ex = new InvalidOperationException("The App Can't Do That");
//We can associate an exception with a log message so it's available as data
//but not necessarily in the message text itself
logger.LogError(ex, "This message is an Error with an exception attached as data.");
//Usually you'll want to include some information from the exception in your message.
logger.LogError(ex, $"Unable to do what you wanted due to {ex.GetType()}\r\n" +
$"{ex.Message}");
//Exceptions can be associated with any severity: Just because it has
//an exception as data doesn't necessarily mean it's an error; it could
//be a retryable error like a network timeout.
logger.LogDebug(ex, $"Retrying operation due to transient error {ex.GetType()}\r\n" +
$"{ex.Message}");
}
// private static string GetMessage(ModelValidationException ex)
// {
// var errors = new StringBuilder();
// errors.AppendLine();
//#if DEBUG
// errors.AppendLine($"[{ex.GetType().Name}]");
//#endif
// errors.AppendLine($"داده های ارسالی به ساختار داده ای نامعتبر می باشد");
// return errors.ToString();
// }
private static string GetMessage(InvalidOperationException ex)
{
var errors = new StringBuilder();
errors.AppendLine();
#if DEBUG
errors.AppendLine($"[{ex.GetType().Name}]");
#endif
if (ex.Message.Contains("The model backing"))
{
errors.AppendLine("نسخه ی پایگاه داده با نسخه ی برنامه مطابقت ندارد.");
}
// Error during serialization or deserialization using the JSON JavaScriptSerializer. The length of the string exceeds the value set on the maxJsonLength property.
else if (ex.Message.Contains("maxJsonLength"))
{
errors.AppendLine("طول داده ی خروجی از حد مجاز تجاوز نموده است.");
}
else
{
errors.AppendLine($"{ex.GetType().Name}: {ex.Message}");
}
return(errors.ToString());
}
public void BuildMailMessageSubject_SubjectFormatStringWithExeptionTypeFormatItem_ReturnsExceptionType()
{
// Arrange
string subjectFormatString = "{3}";
var expectedException = new InvalidOperationException();
var entry = new LogEntry(LoggingEventType.Debug, "Some message", null, expectedException);
// Act
string subject =
MailLoggingProvider.BuildMailMessageSubject(subjectFormatString, entry, DateTime.MaxValue);
// Assert
Assert.AreEqual(expectedException.GetType().Name, subject);
}
public void write_log_exception()
{
var ex = new InvalidOperationException("Fake Exception");
_logger.ErrorException(_uniqueMessage, ex);
VerifyLog(StoredModel, LogLevel.Error);
StoredModel.Message.Should().Be(_uniqueMessage + ": " + ex.Message);
StoredModel.ExceptionType.Should().Be(ex.GetType().ToString());
StoredModel.Exception.Should().Be(ex.ToString());
ExceptionVerification.ExpectedErrors(1);
}
public void TestAddNewProp()
{
// TODO: AAA
mod1 = new OnlyTypedAccessModel(PropBagTypeSafetyMode.Tight, _amHelpers.StoreAccessCreator,
_amHelpers.PropFactory_V1, "PropBagLib.Tests.OnlyTypedAccessModel");
//mod1["System.String", "NewProperty"] = "This is a a test.";
InvalidOperationException aa = new InvalidOperationException();
Type tt = aa.GetType();
Assert.Throws(tt, () => mod1["System.String", "NewProperty"] = "This is a a test.");
}
private IDbSet <TEntity> CreateSet()
{
_tracer.LogInfo("CreateSet Called");
if (_unitOfWork != (IUnitOfWork)null)
{
IDbSet <TEntity> objectSet = _unitOfWork.CreateSet <TEntity>();
return(objectSet);
}
else
{
var err = new InvalidOperationException("");
_tracer.LogError(err.GetType().ToString(), err);
throw err;
}
}
public void TestDequeueFromEmptyQueue()
{
var queue = new CustomQueue <int>();
var actualException = new Exception();
var expectedException = new InvalidOperationException();
try
{
queue.Dequeue();
}
catch (Exception exception)
{
actualException = exception;
}
Assert.AreEqual(expectedException.GetType(), actualException.GetType());
}
/// <summary>operation with exception</summary>
/// <param name="e">exception object</param>
/// <param name="response">response object</param>
private void HandleOperationException(InvalidOperationException e, IODataResponseMessage response)
{
Debug.Assert(this.entryIndex >= 0 && this.entryIndex < this.ChangedEntries.Count, string.Format(System.Globalization.CultureInfo.InvariantCulture, "this.entryIndex = '{0}', this.ChangedEntries.Count = '{1}'", this.entryIndex, this.ChangedEntries.Count));
Descriptor current = this.ChangedEntries[this.entryIndex];
HeaderCollection headers = null;
HttpStatusCode statusCode = HttpStatusCode.InternalServerError;
Version responseVersion = null;
if (response != null)
{
headers = new HeaderCollection(response);
statusCode = (HttpStatusCode)response.StatusCode;
this.HandleOperationResponseHeaders(statusCode, headers);
e = BaseSaveResult.HandleResponse(
this.RequestInfo,
statusCode,
response.GetHeader(XmlConstants.HttpODataVersion),
response.GetStream,
false /*throwOnFailure*/,
out responseVersion);
}
else
{
headers = new HeaderCollection();
headers.SetHeader(XmlConstants.HttpContentType, XmlConstants.MimeTextPlain);
// In V2 we used to merge individual responses from a call to SaveChanges() into a single batch response payload and then process that.
// When we encounter an exception at this point in V2, we used to write the exception to the batch response payload and later on when we
// process through the batch response, we create a DataServiceClientException for each failed operation.
// For backcompat reason, we will always convert the exception type to DataServiceClientException here.
Debug.Assert(e != null, "e != null");
if (e.GetType() != typeof(DataServiceClientException))
{
e = new DataServiceClientException(e.Message, e);
}
}
// For error scenarios, we never invoke the ReadingEntity event.
this.cachedResponses.Add(new CachedResponse(current, headers, statusCode, responseVersion, null, e));
this.perRequest = null;
this.CheckContinueOnError();
}
public void Output_Exception()
{
// Arrange
LogManager.ShutdownRepository(Assembly.GetEntryAssembly());
Mock.Arrange(() => _testAgent.GetLinkingMetadata()).Returns(new Dictionary <string, string>()
{
{ "NewRelicFakeMetaDataKey", "NewRelicFakeMetatDaValue" }
});
//Set the the NewRelicAppender at the root logger
var logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
BasicConfigurator.Configure(logRepository, _testAppender);
TextWriter tw = null;
Mock.Arrange(() => _layout.Format(Arg.IsAny <TextWriter>(), Arg.IsAny <LoggingEvent>())).DoInstead((TextWriter textWriter, LoggingEvent loggingEvent) =>
{
tw = textWriter;
}).CallOriginal();
var testLogger = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
var testExceptionMessage = "This is an exception.";
var testException = new InvalidOperationException(testExceptionMessage);
// Act
try
{
TestHelpers.CreateStackTracedError(0, testException, 3);
}
catch (Exception ex)
{
testLogger.Error("Something has occurred!!!", ex);
}
//// Act
var serializedMessage = tw.ToString();
var deserializedMessage = TestHelpers.DeserializeOutputJSON(serializedMessage);
// Assert
Asserts.KeyAndValueMatch(deserializedMessage, "error.message", testExceptionMessage);
Asserts.KeyAndValueMatch(deserializedMessage, "error.class", testException.GetType().FullName);
Asserts.KeyAndValueMatch(deserializedMessage, "error.stack", testException.StackTrace);
}
/// <summary>
/// Filters set of data of type <typeparamref name="T"/>. Returns filterd data set. Throws <see cref="ArgumentNullException"/> if <paramref name="predicate"/> is null
/// or <see cref="InvalidOperationException"/> if cannot filter data.
/// </summary>
/// <typeparam name="T">The type of entity to set be filtered.</typeparam>
/// <param name="predicate">A function to test each element for a condition.</param>
/// <returns>Filterd <see cref="IEnumerable{T}"/>.</returns>
/// <exception cref="ArgumentNullException">If <paramref name="predicate"/> is null.</exception>
/// <exception cref="InvalidOperationException">If cannot filter data.</exception>
protected virtual IEnumerable <BasicEntity> GetByPredicate <T>(Expression <Func <T, bool> > predicate) where T : BasicEntity
{
_logger.LogDebug($"Starting method '{nameof(GetByPredicate)}'.");
if (predicate is null)
{
throw new ArgumentNullException(nameof(predicate), $"Argument '{nameof(predicate)}' cannot be null.");
}
try
{
IEnumerable <T> result;
if (typeof(T) == typeof(Ticket))
{
result = (IEnumerable <T>)_dbContext.Tickets.IncludeDetails().Where(predicate as Expression <Func <Ticket, bool> >).AsEnumerable();
}
else if (typeof(T) == typeof(VisitInfo))
{
result = (IEnumerable <T>)_dbContext.Info.Include(x => x.OpeningHours).Where(predicate as Expression <Func <VisitInfo, bool> >).AsEnumerable();
}
else if (typeof(T) == typeof(SightseeingGroup))
{
result = (IEnumerable <T>)_dbContext.Groups.Include(x => x.Tickets).Where(predicate as Expression <Func <SightseeingGroup, bool> >).AsEnumerable();
}
else
{
result = _dbContext.Set <T>().Where(predicate).AsEnumerable();
}
_logger.LogDebug($"Finished method '{nameof(GetByPredicate)}'.");
return(result);
}
catch (ArgumentNullException ex)
{
var exception = new InvalidOperationException($"Cannot apply '{nameof(predicate)}' to filter data. See the inner exception for more details.", ex);
_logger.LogError($"{exception.GetType().Name} - {exception.Message}", exception);
throw exception;
}
catch (Exception ex)
{
_logger.LogError($"{ex.GetType().Name} - {ex.Message}", ex);
throw;
}
}
public void write_log_exception()
{
var ex = new InvalidOperationException("Fake Exception");
//Act
Logger.ErrorException(UniqueMessage, ex);
//Assert
var logItem = Db.Fetch <Log>().Single();
VerifyLog(logItem, LogLevel.Error);
logItem.Message.Should().Be(UniqueMessage + ": " + ex.Message);
logItem.ExceptionType.Should().Be(ex.GetType().ToString());
logItem.Exception.Should().Be(ex.ToString());
ExceptionVerification.ExpectedErrors(1);
}