public void TestExtractAllInnerExceptions() { // the implementation only concatenates exception type and message (no stacktrace) // format is: excp.GetType().Name + " : " + excp.Message + "\n" and this same is repeated as long there are innerexceptions ArgumentNullException nex = new ArgumentNullException("nex", "Parameter cannot be null."); ArgumentException argEx = new ArgumentException("Invalid argument supplied.", nex); Exception ex = new Exception("An error occured when calling typography service.", argEx); string extractedMessage = CoreExtensions.ExtractAllInnerExceptions(ex); extractedMessage.Should().NotBeNullOrWhiteSpace(); // create the expected message parts separated with the \n // remove \r\n so that we can split with \n easily string partOne = $"{ex.GetType().Name} : {ex.Message}".Replace("\r\n", string.Empty); string partTwo = $"{argEx.GetType().Name} : {argEx.Message}".Replace("\r\n", string.Empty); string partThree = $"{nex.GetType().Name} : {nex.Message}".Replace("\r\n", string.Empty); // remove \r\n also from the result (when parameter name is given it will be part of the ex.Message) extractedMessage = extractedMessage.Replace("\r\n", string.Empty); // don't remove empty entries var splittedMsgs = extractedMessage.Split(new string[] { "\n" }, StringSplitOptions.None); splittedMsgs.Length.Should().Be(4, "Count should be 4 because there are 3 exceptions and after last exception there will be '\n' which will produce the extra string in the array."); splittedMsgs[0].Should().Be(partOne); splittedMsgs[1].Should().Be(partTwo); splittedMsgs[2].Should().Be(partThree); }
[Fact] // OpenExeConfiguration (String) public void OpenExeConfiguration2_ExePath_DoesNotExist() { using (var temp = new TempDirectory()) { string exePath = Path.Combine(temp.Path, "DoesNotExist.exe"); ConfigurationErrorsException ex = Assert.Throws <ConfigurationErrorsException>( () => ConfigurationManager.OpenExeConfiguration(exePath)); // An error occurred loading a configuration file: // The parameter 'exePath' is invalid Assert.Equal(typeof(ConfigurationErrorsException), ex.GetType()); Assert.Null(ex.Filename); Assert.NotNull(ex.InnerException); Assert.Equal(0, ex.Line); Assert.NotNull(ex.Message); // The parameter 'exePath' is invalid ArgumentException inner = ex.InnerException as ArgumentException; Assert.NotNull(inner); Assert.Equal(typeof(ArgumentException), inner.GetType()); Assert.Null(inner.InnerException); Assert.NotNull(inner.Message); Assert.Equal("exePath", inner.ParamName); } }
public void ReadExceptionFile() { var expectedException = new ArgumentException("test"); var mockFile = Mock.Of <File>(); var mockStream = new System.IO.MemoryStream(); new BinaryFormatter().Serialize(mockStream, expectedException); mockStream.Position = 0; string actualFullFileName = null; System.IO.FileMode?actualFileMode = null; Mock.Get(mockFile).Setup(f => f.FullName).Returns("test.exception"); ErrorLogHelper.Instance.NewFileStream = (name, mode) => { actualFullFileName = name; actualFileMode = mode; return(mockStream); }; var actualException = ErrorLogHelper.ReadExceptionFile(mockFile); Assert.IsInstanceOfType(actualException, expectedException.GetType()); Assert.AreEqual(expectedException.Message, actualException.Message); Assert.AreEqual(mockFile.FullName, actualFullFileName); Assert.AreEqual(System.IO.FileMode.Open, actualFileMode); }
[Test] // OpenExeConfiguration (String) public void OpenExeConfiguration2_ExePath_DoesNotExist() { String exePath = Path.Combine(tempFolder, "DoesNotExist.exe"); try { ConfigurationManager.OpenExeConfiguration(exePath); Assert.Fail("#1"); } catch (ConfigurationErrorsException ex) { // An error occurred loading a configuration file: // The parameter 'exePath' is invalid Assert.AreEqual(typeof(ConfigurationErrorsException), ex.GetType(), "#2"); Assert.IsNull(ex.Filename, "#3"); Assert.IsNotNull(ex.InnerException, "#4"); Assert.AreEqual(0, ex.Line, "#5"); Assert.IsNotNull(ex.Message, "#6"); // The parameter 'exePath' is invalid ArgumentException inner = ex.InnerException as ArgumentException; Assert.IsNotNull(inner, "#7"); Assert.AreEqual(typeof(ArgumentException), inner.GetType(), "#8"); Assert.IsNull(inner.InnerException, "#9"); Assert.IsNotNull(inner.Message, "#10"); Assert.AreEqual("exePath", inner.ParamName, "#11"); } }
public void CorrectAgeTest1(int age) { var actException = Assert.Catch(() => new Person("Name", "Surname", age)); var expectedException = new ArgumentException(); Assert.AreEqual(expectedException.GetType(), actException.GetType()); }
private static bool MapsToDateBrokenRule(ArgumentException sourceException) { return(sourceException.GetType() == typeof(ArgumentNullException) || IsInvalidDateException(sourceException) || IsInFututeException(sourceException) || IsNotInPastException(sourceException)); }
public void MessageTest() { const string Message = "some message"; var exception = new ArgumentException(Message); var exceptionViewModel = new ExceptionViewModel(exception); Assert.AreEqual(exception.GetType().Name + ": " + Message, exceptionViewModel.Message); }
private static bool MapsToOutOfRangeBrokenRule(ArgumentException sourceException) { return(sourceException.GetType() == typeof(ArgumentOutOfRangeException) || IsGreaterThanException(sourceException) || IsLessThanException(sourceException) || IsGreaterThanOrEqualToException(sourceException) || IsLessThanOrEqualToException(sourceException) || IsInRangeException(sourceException)); }
public void TestReportClassifier_ShouldSetErrorClassifier_SetCorrectExceptionReportClassifier() { var exception = new ArgumentException(string.Empty); var report = new BacktraceReport( exception: exception, attributes: reportAttributes, attachmentPaths: attachemnts); Assert.AreEqual(report.Classifier, exception.GetType().Name); }
public void Constructor0_Arguments_Mismatch() { ArgumentException ex = Assert.Throws <ArgumentException>(() => new InstanceDescriptor(ci, null)); // Length mismatch Assert.Equal(typeof(ArgumentException), ex.GetType()); Assert.Null(ex.InnerException); Assert.NotNull(ex.Message); Assert.Null(ex.ParamName); }
public async Task GenericThrowsAsync_Should_ThrowAssertionException_WhenNoAnyExceptionWasThrown() { var exceptionToThrow = new ArgumentException("some_message", "some_name"); var result = await SafelyCatchAnNUnitExceptionAsync(() => Assert.ThrowsAsync <ArgumentException>(async() => { })); Assert.That(result, new ExceptionTypeConstraint(typeof(AssertionException))); Assert.That(exceptionToThrow, Is.Not.EqualTo(result)); Assert.That(result.Message, Is.EqualTo($" Expected: <{exceptionToThrow.GetType().FullName}>" + Environment.NewLine + " But was: null" + Environment.NewLine)); }
private async Task ThrowsAsyncShouldReturnCorrectExceptionBaseTest(Func <Exception, Task <Exception> > code) { var exceptionToThrow = new ArgumentException("some_message", "some_param"); var result = await code(exceptionToThrow) as ArgumentException; Assert.That(result, new ExceptionTypeConstraint(exceptionToThrow.GetType()), string.Empty, null); Assert.IsNotNull(result, "No ArgumentException thrown"); Assert.That(exceptionToThrow.Message, Is.EqualTo(result.Message)); Assert.That(exceptionToThrow.ParamName, Is.EqualTo(result.ParamName)); Assert.That(exceptionToThrow, Is.EqualTo(result)); }
public void Property_MemberInfo_WriteOnly() { PropertyInfo pi = typeof(WriteOnlyProperty).GetProperty("Name"); ArgumentException ex = Assert.Throws <ArgumentException>(() => new InstanceDescriptor(pi, null)); // Parameter must be readable Assert.Equal(typeof(ArgumentException), ex.GetType()); Assert.Null(ex.InnerException); Assert.NotNull(ex.Message); Assert.Null(ex.ParamName); }
public void Field_MemberInfo_NonStatic() { FieldInfo fi = typeof(InstanceField).GetField("Name"); ArgumentException ex = Assert.Throws <ArgumentException>(() => new InstanceDescriptor(fi, null)); // Parameter must be static Assert.Equal(typeof(ArgumentException), ex.GetType()); Assert.Null(ex.InnerException); Assert.NotNull(ex.Message); Assert.Null(ex.ParamName); }
public void Field_Arguments_Mismatch() { FieldInfo fi = typeof(Uri).GetField("SchemeDelimiter"); ArgumentException ex = Assert.Throws <ArgumentException>(() => new InstanceDescriptor(fi, new object[] { url })); // Parameter must be static Assert.Equal(typeof(ArgumentException), ex.GetType()); Assert.Null(ex.InnerException); Assert.NotNull(ex.Message); Assert.Null(ex.ParamName); }
/// <summary> /// ArgumentException An argument to a method was invalid. /// </summary> /// <param name="ex"></param> /// <returns></returns> private static SqlMessage SqlException(ArgumentException ex) { SqlMessage meResul = new SqlMessage { Status = sqlMessagerType.SystemError, Title = ex.GetType().FullName, Message = ex.Message, ExceptionMesseger = ex.ToString() }; return(meResul); }
public void Constructor0_Arguments_Mismatch() { ArgumentException ex = Assert.Throws <ArgumentException>(() => new InstanceDescriptor(ci, null)); // Length mismatch Assert.Equal(typeof(ArgumentException), ex.GetType()); Assert.Null(ex.InnerException); if (!PlatformDetection.IsNetNative) // .Net Native toolchain optimizes away exception messages and paramnames. { Assert.NotNull(ex.Message); Assert.Null(ex.ParamName); } }
public async Task ThrowsAsync_Should_ThrowAssertionException_WhenUnrelatedExceptionWasThrown() { var expectedExceptionType = typeof(NullReferenceException); var unrelatedException = new ArgumentException("some_message", "some_name"); var result = await SafelyCatchAnNUnitExceptionAsync(() => Assert.ThrowsAsync(expectedExceptionType, async() => throw unrelatedException)); Assert.That(result, new ExceptionTypeConstraint(typeof(AssertionException))); Assert.That(expectedExceptionType, Is.Not.TypeOf(result.GetType())); Assert.That(result.Message, Does.StartWith($" Expected: <{expectedExceptionType.FullName}>" + Environment.NewLine + $" But was: <{unrelatedException.GetType().FullName}: {unrelatedException.Message}" + Environment.NewLine)); }
/// <summary> /// simple error handler for now, could refactor to use ExceptionAttribute filter etc /// </summary> private static void HandleArgumentErrors(string extraInfo, ArgumentException argEx) { //return status 400 - BadRequest var msg = argEx?.Message?.Split("\r\n".ToCharArray()).FirstOrDefault(); var resp = new HttpResponseMessage(HttpStatusCode.BadRequest) { Content = new StringContent(argEx.Message), ReasonPhrase = $"{argEx.GetType().Name} ({extraInfo} - {msg})", }; throw new HttpResponseException(resp); }
public void Property_MemberInfo_WriteOnly() { PropertyInfo pi = typeof(WriteOnlyProperty).GetProperty(nameof(WriteOnlyProperty.Name)); ArgumentException ex = Assert.Throws <ArgumentException>(() => new InstanceDescriptor(pi, null)); // Parameter must be readable Assert.Equal(typeof(ArgumentException), ex.GetType()); Assert.Null(ex.InnerException); if (!PlatformDetection.IsNetNative) // .Net Native toolchain optimizes away exception messages and paramnames. { Assert.NotNull(ex.Message); Assert.Null(ex.ParamName); } }
public void Field_MemberInfo_NonStatic() { FieldInfo fi = typeof(InstanceField).GetField(nameof(InstanceField.Name)); ArgumentException ex = Assert.Throws <ArgumentException>(() => new InstanceDescriptor(fi, null)); // Parameter must be static Assert.Equal(typeof(ArgumentException), ex.GetType()); Assert.Null(ex.InnerException); if (!PlatformDetection.IsNetNative) // .Net Native toolchain optimizes away exception messages and paramnames. { Assert.NotNull(ex.Message); Assert.Null(ex.ParamName); } }
public void SummaryOrdersErrorsFromMostOccuringDescending() { var error1 = new DllNotFoundException(); var error2 = new ArgumentException(); var error3 = new ArgumentException(); var error4 = new ArgumentException(); var exceptionsAggregated = new List <Exception> { error1, error2, error3, error4 }; var received = exceptionsAggregated.Summary(); var multilineRegex = new Regex($"{OpeningSequenceMultipleRegex}.?.?.?({error2.GetType().FullName}|{error2.GetType().Name}){RegexForThreeTimes}", RegexOptions.IgnoreCase | RegexOptions.Singleline); Assert.True(multilineRegex.IsMatch(received)); }
public void CreatingFromException_MapsProperties_FromMostInnerException() { // Arrange const string InnerMessage = "InnerMessage"; var innerException = new ArgumentException(InnerMessage); var middleException = new ArgumentNullException("MiddleMessage", innerException); var outerException = new Exception("OuterMessage", middleException); // Act var actualServerException = ServerException.CreateFromException(outerException); // Assert Assert.AreEqual(InnerMessage, actualServerException.Message); Assert.AreEqual(innerException.GetType().Name, actualServerException.TypeName); }
public void Field_Arguments_Mismatch() { FieldInfo fi = typeof(StaticField).GetField(nameof(StaticField.Field)); ArgumentException ex = AssertExtensions.Throws <ArgumentException>(null, () => new InstanceDescriptor(fi, new object[] { url })); // Parameter must be static Assert.Equal(typeof(ArgumentException), ex.GetType()); Assert.Null(ex.InnerException); if (!PlatformDetection.IsNetNative) // .Net Native toolchain optimizes away exception messages and paramnames. { Assert.NotNull(ex.Message); Assert.Null(ex.ParamName); } }
public void Increment_WithException_AddReadingDataForTheSpecificException() { var sensor = new ExceptionSensor(); ArgumentException exception = new ArgumentException(); sensor.AddError(exception); Reading reading = null; ReadingPublisher.Readings.TryDequeue(out reading); // TotalExceptions ReadingPublisher.Readings.TryDequeue(out reading); Assert.That(reading.Data.Name, Is.EqualTo(exception.GetType().Name)); }
public void SerializesTwoExceptions() { var exception1 = new InvalidOperationException("Some message 1"); var exception2 = new ArgumentException("Some message 2"); var errors = new ErrorSerializer().Serialize( new List <ApiError>() { new ApiError(exception1), new ApiError(exception2) })["errors"]; Assert.Equal(exception1.Message, errors[0].Value <string>("title")); Assert.Equal(exception1.GetType().FullName, errors[0].Value <string>("code")); Assert.Equal(exception1.ToString(), errors[0].Value <string>("detail")); Assert.Equal(exception2.Message, errors[1].Value <string>("title")); Assert.Equal(exception2.GetType().FullName, errors[1].Value <string>("code")); Assert.Equal(exception2.ToString(), errors[1].Value <string>("detail")); }
public void Should_serialize_inner_exceptions() { var exception0 = new InvalidOperationException(); var exception1 = new NullReferenceException(); var exception2 = new ArgumentException(); var aggregateException = new AggregateException(exception0, exception1, exception2); builder.AddExceptionData(aggregateException); var tags = builder.BuildTags(); tags.ContainsKey(ExceptionTagNames.InnerExceptions).Should().BeTrue(); var exceptions = tags[ExceptionTagNames.InnerExceptions].AsVector.AsContainerList; exceptions[0][ExceptionTagNames.Type].AsString.Should().Be(exception0.GetType().FullName); exceptions[1][ExceptionTagNames.Type].AsString.Should().Be(exception1.GetType().FullName); exceptions[2][ExceptionTagNames.Type].AsString.Should().Be(exception2.GetType().FullName); }
public void Test_TraceError_with_message() { var traceMock = new Mock <TraceListener>(MockBehavior.Loose); var ts = new TraceSource(AppConstants.SignalRMagicHub, SourceLevels.All); ts.Listeners.Add(traceMock.Object); Exception ex = new ArgumentException("foo"); ts.TraceError(ex, "bar"); traceMock.Verify(t => t.TraceEvent( It.IsAny <TraceEventCache>(), It.IsAny <string>(), TraceEventType.Error, It.IsAny <int>(), "{3} ExceptionType=\"{0}\" ExceptionMessage=\"{1}\" StackTrace={2}", new object[] { ex.GetType().FullName, ex.Message, ex.StackTrace, "ErrorOccurred=\"bar\" " }), Times.Exactly(1)); }
public static void ArgumentExceptionIsThrown(Action action, string expectedArgumentName, string expectedMessage = null) { if (action == null) { throw new ArgumentNullException("method"); } if (expectedArgumentName == null) { throw new ArgumentNullException("expectedArgumentName"); } if (expectedArgumentName == string.Empty) { throw new ArgumentException(ValidationPredicateMessages.NullOrEmptyStringMessage, "expectedArgumentName"); } ArgumentException ex = null; try { action(); } catch (ArgumentException e) { ex = e; } Assert.AreEqual(typeof(ArgumentException), ex.GetType()); Assert.IsNotNull(ex); Assert.AreEqual(expectedArgumentName, ex.ParamName); if (expectedMessage != null) { Assert.AreEqual(ex.Message, expectedMessage); } }
public void PruebaConstructorConString() { #region Caso 1: Indice en rango válido. { // Preparación. LímiteDeVelocidad límiteDeVelocidad = new LímiteDeVelocidad(2); ClaseDeRuta claseDeRuta = new ClaseDeRuta(3); string parámetrosDeRuta = "2,3,0,1,0,0,0,0,0,0,0,1"; bool[] otrosParámetrosEsperados = new bool[] { false, true, false, false, false, false, false, false, false, true }; // Llama al constructor en prueba. CampoParámetrosDeRuta objectoEnPrueba = new CampoParámetrosDeRuta(parámetrosDeRuta); // Prueba Propiedades. Assert.That(objectoEnPrueba.Identificador, Is.EqualTo(CampoParámetrosDeRuta.IdentificadorDeParámetrosDeRuta), "Identificador"); Assert.That(objectoEnPrueba.ClaseDeRuta, Is.EqualTo(claseDeRuta), "ClaseDeRuta"); Assert.That(objectoEnPrueba.LímiteDeVelocidad, Is.EqualTo(límiteDeVelocidad), "LímiteDeVelocidad"); Assert.That(objectoEnPrueba.OtrosParámetros, Is.EqualTo(otrosParámetrosEsperados), "OtrosParámetros"); } #endregion #region Caso 2: Parametros de Tuta con muy pocos elementos. { // Preparación. string parametrosDeRutaInválidos = "2"; bool lanzóExcepción = false; ArgumentException excepciónEsperada = new ArgumentException( "Los parámetros de rutas deben tener 12 elementos separados por coma, pero es: 2"); // Llama al constructor en prueba. try { CampoParámetrosDeRuta objectoEnPrueba = new CampoParámetrosDeRuta(parametrosDeRutaInválidos); } catch (Exception e) { // Prueba las propiedades de la excepción. Assert.That(e.GetType(), Is.EqualTo(excepciónEsperada.GetType()), "Tipo de Excepción"); Assert.That(e.Message, Is.EqualTo(excepciónEsperada.Message), "Excepción.Message"); lanzóExcepción = true; } Assert.That(lanzóExcepción, Is.True, "No se lanzó la excepción."); } #endregion #region Caso 3: Otros Parámetros con valores diferente de 0 ó 1. { // Preparación. string parametrosDeRutaInválidos = "2,3,0,5,0,0,0,0,0,0,0,1"; bool lanzóExcepción = false; ArgumentException excepciónEsperada = new ArgumentException( "El números de los parámetros de ruta para el tercer elemento en adelante tiene que ser 0 ó 1:" + " 2,3,0,5,0,0,0,0,0,0,0,1\r\nParameter name: elTextoDeParámetrosDeRuta"); // Llama al constructor en prueba. try { CampoParámetrosDeRuta objectoEnPrueba = new CampoParámetrosDeRuta(parametrosDeRutaInválidos); } catch (Exception e) { // Prueba las propiedades de la excepción. Assert.That(e.GetType(), Is.EqualTo(excepciónEsperada.GetType()), "Tipo de Excepción"); Assert.That(e.Message, Is.EqualTo(excepciónEsperada.Message), "Excepción.Message"); lanzóExcepción = true; } Assert.That(lanzóExcepción, Is.True, "No se lanzó la excepción."); } #endregion }