public string ActionExecuteExceptionLog(ChangesHeader _ChangesHeader, List <ChangeItem> _ChangeItemCollection, ThrowingException _ThrowingException) { string _Result = string.Empty; MappingException _MappingException = null; string _XML = string.Empty; List <DbParameter> _ParameterList = new List <DbParameter>(); string _ConnectionString = ConfigurationManager.ConnectionStrings["BrErpSindicatoV04_HistoricoModificacoes"].ConnectionString; string _ProviderName = ConfigurationManager.ConnectionStrings["BrErpSindicatoV04_HistoricoModificacoes"].ProviderName; string _TSQL = "[dbo].[Log_ModificaLogExcecoes]"; _MappingException = ServiceHelper.CreateInstance.GetMappingExceptions(_ChangesHeader, _ChangeItemCollection, _ThrowingException); _XML = SerializationData.CreateInstance.GetSerializableData(_MappingException, "MappingExecuteExceptionLog"); _ParameterList.Add(DatabasePersistence.CreateInstance(_ConnectionString, _ProviderName).CreateParameter("@XMLExceptionLog", System.Data.DbType.Xml, _XML)); try { _Result = Convert.ToString(DatabasePersistence.CreateInstance(_ConnectionString, _ProviderName).ExecuteCommand(_TSQL, CommandType.StoredProcedure, _ParameterList, ExecuteType.ExecuteScalar)); } catch (Exception ex) { ExceptionHandling.CreateInstance.AddExceptionAndSaveTextFile(ex); } return(_Result); }
private static byte[] SerializeToBytes(MappingException e) { using (var stream = new MemoryStream()) { new BinaryFormatter().Serialize(stream, e); return(stream.GetBuffer()); } }
public void MappingExceptionSerialization() { var message = "Test message"; var exception = new MappingException(message); var actual = SerializeToBytes(exception); actual.Length.Should().BeGreaterThan(0); }
public void MappingExceptionWithMessage() { var message = "Test message"; FluentActions.Invoking(() => systemUnderTest = new MappingException(message)) .Should() .NotThrow(); Assert.AreEqual(message, systemUnderTest.Message); }
public MappingException GetMappingExceptions(ChangesHeader _ChangeHeader, List <ChangeItem> _ChangeItems, ThrowingException _ThrowingException) { MappingException _MappingException = null; List <ChangesHeader> _ChangeHeadersHelper = new List <ChangesHeader>(); List <ChangeItem> _ChangeItemsHelper = new List <ChangeItem>(); List <ThrowingException> ThrowingExceptionsHelper = new List <ThrowingException>(); _ChangeHeadersHelper.Add(new ChangesHeader() { Id = _ChangeHeader.Id, CodigoRegistro = _ChangeHeader.CodigoRegistro, NomeProcesso = _ChangeHeader.NomeProcesso, TipoModificacao = _ChangeHeader.TipoModificacao, Usuario = _ChangeHeader.Usuario, DataHora = _ChangeHeader.DataHora, StatusExecucao = _ChangeHeader.StatusExecucao }); foreach (ChangeItem _ChangeItem in _ChangeItems) { _ChangeItemsHelper.Add(new ChangeItem() { IdChangeHeader = _ChangeItem.IdChangeHeader, IdItem = _ChangeItem.IdItem, NomeTabela = _ChangeItem.NomeTabela, NomeCampo = _ChangeItem.NomeCampo, ValorAntigo = _ChangeItem.ValorAntigo, ValorNovo = _ChangeItem.ValorNovo }); } ThrowingExceptionsHelper.Add(new ThrowingException() { Id = _ThrowingException.Id, IdChangeHeader = _ThrowingException.IdChangeHeader, Formulario = _ThrowingException.Formulario, Tarefa = _ThrowingException.Tarefa, FuncaoDisparador = _ThrowingException.FuncaoDisparador, TipoExcecao = _ThrowingException.TipoExcecao, MensagemExcecao = _ThrowingException.MensagemExcecao }); if (_MappingException == null) { _MappingException = new MappingException(); } _MappingException.ChangeHeaders = _ChangeHeadersHelper; _MappingException.ChangeItems = _ChangeItemsHelper; _MappingException.ThrowingExceptions = ThrowingExceptionsHelper; return(_MappingException); }
public void serialization_works_with_datacontract() { var serializer = new DataContractSerializer(typeof(MappingException)); var ms = new MemoryStream(); var sut = new MappingException(typeof(string), "Hello"); serializer.WriteObject(ms, sut); ms.Position = 0; var actual = (MappingException)serializer.ReadObject(ms); actual.Message.Should().Be("Hello"); actual.EntityTypeName.Should().Be(typeof(string).FullName); }
public void MappingExceptionDeserialization() { var message = "Test message"; var exception = new MappingException(message); var bytes = SerializeToBytes(exception); bytes.Length.Should().BeGreaterThan(0); var actual = DeserializeFromBytes(bytes); actual.Message.Should().Be(message); actual.InnerException.Should().BeNull(); }
public void CannotOverloadHandleMethods() { var serviceProvider = new Mock <IServiceProvider>(); var attribute = new HandleByAttributeAttribute { PublicOnly = false }; var expectedException = new MappingException(Exceptions.HandleMethodOverloaded.FormatWith(typeof(FakeAggregate), "Void Handle(FakeCommand, FakeService, FakeService)")); serviceProvider.Setup(mock => mock.GetService(typeof(FakeService))).Returns(null); var actualException = Assert.Throws <MappingException>(() => attribute.GetHandleMethods(typeof(FakeAggregate), serviceProvider.Object)); Assert.Equal(expectedException.Message, actualException.Message); }
public void serialization_works_with_BinaryFormatter() { var serializer = new BinaryFormatter(); var ms = new MemoryStream(); var sut = new MappingException(typeof(string), "Hello"); serializer.Serialize(ms, sut); ms.Position = 0; var actual = (MappingException)serializer.Deserialize(ms); actual.Message.Should().Be("Hello"); actual.EntityTypeName.Should().Be(typeof(string).FullName); }
private static Expression WrapInTryCatch(Expression mappingBlock, IMemberMapperData mapperData) { var configuredCallback = mapperData.MapperContext.UserConfigurations.GetExceptionCallbackOrNull(mapperData); var exceptionVariable = Parameters.Create <Exception>("ex"); Expression catchBody; if (configuredCallback != null) { var callbackActionType = configuredCallback.Type.GetGenericTypeArguments()[0]; Type[] contextTypes; Expression contextAccess; if (callbackActionType.IsGenericType()) { contextTypes = callbackActionType.GetGenericTypeArguments(); contextAccess = mapperData.GetAppropriateTypedMappingContextAccess(contextTypes); } else { contextTypes = new[] { mapperData.SourceType, mapperData.TargetType }; contextAccess = mapperData.MappingDataObject; } var exceptionContextCreateMethod = ObjectMappingExceptionData .CreateMethod .MakeGenericMethod(contextTypes); var exceptionContextCreateCall = Expression.Call( exceptionContextCreateMethod, contextAccess, exceptionVariable); var callbackInvocation = Expression.Invoke(configuredCallback, exceptionContextCreateCall); var returnDefault = mappingBlock.Type.ToDefaultExpression(); catchBody = Expression.Block(callbackInvocation, returnDefault); } else { catchBody = Expression.Throw( MappingException.GetFactoryMethodCall(mapperData, exceptionVariable), mappingBlock.Type); } var catchBlock = Expression.Catch(exceptionVariable, catchBody); return(Expression.TryCatch(mappingBlock, catchBlock)); }
public void AddClassNotFound() { Configuration cfg = new Configuration(); try { cfg.AddResource("NHibernate.Test.MappingExceptions.A.ClassNotFound.hbm.xml", this.GetType().Assembly); } catch (MappingException me) { Assert.IsTrue(me.InnerException is MappingException); MappingException innerMe = (MappingException)me.InnerException; Assert.AreEqual("persistent class " + typeof(A).FullName + " not found", innerMe.Message); } }
public void Bug() { try { new Configuration() .AddResource(GetType().Namespace + ".EmptyTableName.hbm.xml", GetType().Assembly) .BuildSessionFactory(); Assert.Fail("should throw exception"); } catch (MappingException e) { MappingException ee = e.InnerException as MappingException; if (ee == null) { throw; } Assert.IsTrue(ee.Message.StartsWith("Could not determine the name of the table for entity")); } }
public static TryExpression WrapInTryCatch(this Expression mapping, IMemberMapperData mapperData) { var configuredCallback = mapperData.MapperContext.UserConfigurations.GetExceptionCallbackOrNull(mapperData); var exceptionVariable = Parameters.Create <Exception>("ex"); if (configuredCallback == null) { var catchBody = Expression.Throw( MappingException.GetFactoryMethodCall(mapperData, exceptionVariable), mapping.Type); return(CreateTryCatch(mapping, exceptionVariable, catchBody)); } var configuredCatchBody = configuredCallback .ToCatchBody(exceptionVariable, mapping.Type, mapperData); return(CreateTryCatch(mapping, exceptionVariable, configuredCatchBody)); }
private void LogFailedToMapProperty(PropertyInfo property, MappingException exception) { Log.LogError(exception, "Failed to map {0} property.", property.Name); }
public void Setup() { systemUnderTest = new MappingException(); }
public void type_is_assigned_to_the_property() { var sut = new MappingException(typeof(string), "Hello"); sut.EntityTypeName.Should().Be(typeof(string).FullName); }
public void MappingExceptionDefaultConstructor() { FluentActions.Invoking(() => systemUnderTest = new MappingException()) .Should() .NotThrow(); }
public void CannotOverloadHandleMethods() { var serviceProvider = new Mock<IServiceProvider>(); var attribute = new HandleByConventionAttribute { PublicOnly = false }; var expectedException = new MappingException(Exceptions.HandleMethodOverloaded.FormatWith(typeof(FakeHandler), "Void Handle(FakeEvent, FakeService, FakeService)")); serviceProvider.Setup(mock => mock.GetService(typeof(FakeService))).Returns(null); var actualException = Assert.Throws<MappingException>(() => attribute.GetHandleMethods(typeof(FakeHandler), serviceProvider.Object)); Assert.Equal(expectedException.Message, actualException.Message); }
public void description_is_assigned_to_base() { var sut = new MappingException(typeof(string), "Hello"); sut.Message.Should().Be("Hello"); }
private static void LogAndThrow(MappingException me) { log.Error(me.Message, me); throw me; }