public void GenerateValidationMessage_WithNullExpression_Throws() { // Arrange var metadataProvider = new TestModelMetadataProvider(); var htmlGenerator = GetGenerator(metadataProvider); var viewContext = GetViewContext <Model>(model: null, metadataProvider: metadataProvider); var modelExplorer = metadataProvider.GetModelExplorerForType(typeof(string), model: null); var expected = "The name of an HTML field cannot be null or empty. Instead use methods " + "Microsoft.AspNetCore.Mvc.Rendering.IHtmlHelper.Editor or Microsoft.AspNetCore.Mvc.Rendering." + "IHtmlHelper`1.EditorFor with a non-empty htmlFieldName argument value."; // Act and Assert ExceptionAssert.ThrowsArgument( () => htmlGenerator.GenerateValidationMessage( viewContext, modelExplorer: null, expression: null, message: "Message", tag: "tag", htmlAttributes: null), "expression", expected); }
public void Rejection_DefendPromisesOnceMade() { var container = ContainerFactory.CreateWithAttributedCatalog(typeof(Needy)); var addBatch = new CompositionBatch(); var removeBatch = new CompositionBatch(); var addedPart = addBatch.AddPart(new NoImportPart()); removeBatch.RemovePart(addedPart); // Add then remove should be fine as long as exports aren't used yet. container.Compose(addBatch); container.Compose(removeBatch); // Add the dependencies container.Compose(addBatch); // Retrieve needy which uses an export from addedPart var export = container.GetExportedValue <Needy>(); // Should not be able to remove the addedPart because someone depends on it. ExceptionAssert.Throws <ChangeRejectedException>(() => container.Compose(removeBatch)); }
public async Task AsyncClientStreamingCall_DeadlineBeforeWrite_ResponseThrowsDeadlineExceededStatus() { // Arrange var tcs = new TaskCompletionSource<object?>(TaskCreationOptions.RunContinuationsAsynchronously); var httpClient = ClientTestHelpers.CreateTestClient(async request => { await tcs.Task.DefaultTimeout(); return ResponseUtils.CreateResponse(HttpStatusCode.OK); }); var systemClock = new TestSystemClock(DateTime.UtcNow); var invoker = HttpClientCallInvokerFactory.Create(httpClient, systemClock: systemClock); // Act var call = invoker.AsyncClientStreamingCall<HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(deadline: systemClock.UtcNow.AddMilliseconds(10))); // Ensure the deadline has passed systemClock.UtcNow = systemClock.UtcNow.AddMilliseconds(200); await Task.Delay(200); // Assert var ex = await ExceptionAssert.ThrowsAsync<RpcException>(() => call.RequestStream.WriteAsync(new HelloRequest())).DefaultTimeout(); Assert.AreEqual(StatusCode.DeadlineExceeded, ex.StatusCode); Assert.AreEqual(StatusCode.DeadlineExceeded, call.GetStatus().StatusCode); }
public void EscapedPathInExceptionMessage() { string json = @"{ ""frameworks"": { ""dnxcore50"": { ""dependencies"": { ""System.Xml.ReaderWriter"": { ""source"": !!! !!! } } } } }"; ExceptionAssert.Throws <JsonReaderException>( () => { JsonTextReader reader = new JsonTextReader(new StringReader(json)); while (reader.Read()) { } }, "Unexpected character encountered while parsing value: !. Path 'frameworks.dnxcore50.dependencies['System.Xml.ReaderWriter'].source', line 6, position 20."); }
public async Task PickAsync_WaitForReadyWithDrop_ThrowsError() { // Arrange var services = new ServiceCollection(); services.AddNUnitLogger(); var serviceProvider = services.BuildServiceProvider(); var loggerFactory = serviceProvider.GetRequiredService <ILoggerFactory>(); var resolver = new TestResolver(loggerFactory); resolver.UpdateAddresses(new List <BalancerAddress> { new BalancerAddress("localhost", 80) }); var transportFactory = new TestSubchannelTransportFactory(); var clientChannel = CreateConnectionManager(loggerFactory, resolver, transportFactory); clientChannel.ConfigureBalancer(c => new DropLoadBalancer(c)); // Act _ = clientChannel.ConnectAsync(waitForReady: true, CancellationToken.None).ConfigureAwait(false); var pickTask = clientChannel.PickAsync( new PickContext { Request = new HttpRequestMessage() }, waitForReady: true, CancellationToken.None).AsTask(); // Assert var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => pickTask).DefaultTimeout(); Assert.AreEqual(StatusCode.DataLoss, ex.StatusCode); }
public void RedirectToRoute_Execute_ThrowsOnNullUrl() { // Arrange var httpContext = new Mock <HttpContext>(); httpContext.Setup(o => o.Response).Returns(new Mock <HttpResponse>().Object); var actionContext = new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor()); var urlHelper = GetMockUrlHelper(returnValue: null); var result = new RedirectToRouteResult(null, new Dictionary <string, object>()) { UrlHelper = urlHelper, }; // Act & Assert ExceptionAssert.ThrowsAsync <InvalidOperationException>( async() => { await result.ExecuteResultAsync(actionContext); }, "No route matches the supplied values."); }
public void DeserializeArraysWithPreserveObjectReferences() { string json = @"{ ""$id"": ""1"", ""$values"": [ null, { ""$id"": ""2"", ""$values"": [ null ] }, { ""$id"": ""3"", ""$values"": [ { ""$id"": ""4"", ""$values"": [ { ""$ref"": ""1"" } ] } ] } ] }"; ExceptionAssert.Throws <JsonSerializationException>(() => { JsonConvert.DeserializeObject <string[][]>(json, new JsonSerializerSettings { PreserveReferencesHandling = PreserveReferencesHandling.All }); }, @"Cannot preserve reference to array or readonly list, or list created from a non-default constructor: System.String[][]. Path '$values', line 3, position 14."); }
public async Task NullPrimitiveValueSerializeAsODataThrows(Type valueType, object value, string mediaType, string unused) { // Arrange Assert.NotNull(valueType); Assert.NotNull(unused); ODataConventionModelBuilder modelBuilder = ODataConventionModelBuilderFactory.Create(); modelBuilder.EntitySet <WorkItem>("WorkItems"); IEdmModel model = modelBuilder.GetEdmModel(); IEdmProperty property = model.EntityContainer.EntitySets().Single().EntityType().Properties().First(); ODataPath path = new ODataPath(new PropertySegment(property as IEdmStructuralProperty)); var configuration = RoutingConfigurationFactory.CreateWithRootContainer("OData"); var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/WorkItems(10)/ID", configuration, "OData", path); var formatter = FormatterTestHelper.GetFormatter(new ODataPayloadKind[] { ODataPayloadKind.Property }, request, mediaType); // Act & Assert Type type = (value != null) ? value.GetType() : typeof(Nullable <int>); var content = FormatterTestHelper.GetContent(value, type, formatter, mediaType.ToString()); await ExceptionAssert.ThrowsAsync <ODataException>( () => FormatterTestHelper.GetContentResult(content, request), "Cannot write the value 'null' in top level property; return 204 instead."); }
public void SerializeWrappingErrorsAndErrorHandling() { var serialiser = JsonSerializer.Create(new JsonSerializerSettings() { }); Something s = new Something { RootSomethingElse = new RootSomethingElse { SomethingElse = new SomethingElse() } }; RootThing r = new RootThing { Something = s }; var writer = new System.IO.StringWriter(); ExceptionAssert.Throws <Exception>( "An error occurred.", () => { serialiser.Serialize(writer, r); }); }
public void CreateSetWithBadObjectTarget() { ExceptionAssert.Throws <InvalidCastException>( () => { Person p = new Person(); Movie m = new Movie(); Action <object, object> setter = ExpressionReflectionDelegateFactory.Instance.CreateSet <object>(TestReflectionUtils.GetProperty(typeof(Movie), "Name")); setter(m, "Hi"); Assert.AreEqual(m.Name, "Hi"); setter(p, "Hi"); Assert.AreEqual(p.Name, "Hi"); }, new[] { "Unable to cast object of type 'Newtonsoft.Json.Tests.TestObjects.Person' to type 'Newtonsoft.Json.Tests.TestObjects.Movie'.", "Cannot cast from source type to destination type." // mono }); }
public void DeserializeISerializable() { InMemoryTraceWriter traceWriter = new InMemoryTraceWriter { LevelFilter = TraceLevel.Verbose }; ExceptionAssert.Throws <SerializationException>( "Member 'ClassName' was not found.", () => { JsonConvert.DeserializeObject <Exception>( "{}", new JsonSerializerSettings { TraceWriter = traceWriter }); }); Assert.AreEqual("Deserializing System.Exception using ISerializable constructor. Path '', line 1, position 2.", traceWriter.TraceRecords[0].Message); Assert.AreEqual(TraceLevel.Info, traceWriter.TraceRecords[0].Level); Assert.AreEqual("Error deserializing System.Exception. Member 'ClassName' was not found. Path '', line 1, position 2.", traceWriter.TraceRecords[1].Message); Assert.AreEqual(TraceLevel.Error, traceWriter.TraceRecords[1].Level); }
public async Task AsyncClientStreamingCall_WriteAfterResult_Error() { // Arrange var requestContent = new MemoryStream(); var callCount = 0; var httpClient = ClientTestHelpers.CreateTestClient(async request => { Interlocked.Increment(ref callCount); _ = request.Content !.ReadAsStreamAsync(); var reply = new HelloReply { Message = "Hello world" }; var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout(); return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent)); }); var serviceConfig = ServiceConfigHelpers.CreateRetryServiceConfig(); var invoker = HttpClientCallInvokerFactory.Create(httpClient, serviceConfig: serviceConfig); // Act var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.GetServiceMethod(MethodType.ClientStreaming), string.Empty, new CallOptions()); // Assert var responseMessage = await call.ResponseAsync.DefaultTimeout(); Assert.AreEqual("Hello world", responseMessage.Message); var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.RequestStream.WriteAsync(new HelloRequest { Name = "1" })).DefaultTimeout(); Assert.AreEqual(StatusCode.OK, ex.StatusCode); }
public async Task AsyncUnaryCall_PushbackExplicitDelayExceedAttempts_Failure() { // Arrange var callCount = 0; var httpClient = ClientTestHelpers.CreateTestClient(async request => { callCount++; await request.Content !.CopyToAsync(new MemoryStream()); return(ResponseUtils.CreateHeadersOnlyResponse(HttpStatusCode.OK, StatusCode.Unavailable, retryPushbackHeader: "0")); }); var serviceConfig = ServiceConfigHelpers.CreateRetryServiceConfig(maxAttempts: 5); var invoker = HttpClientCallInvokerFactory.Create(httpClient, serviceConfig: serviceConfig); // Act var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(), new HelloRequest { Name = "World" }); // Assert Assert.AreEqual(5, callCount); var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout(); Assert.AreEqual(StatusCode.Unavailable, ex.StatusCode); }
public void InstallCommandWorksIfExcludedVersionsAndPackageIsNotFoundInRemoteRepository() { // Arrange var fileSystem = new MockFileSystem(); var packages = new List <IPackage> { PackageUtility.CreatePackage("A", "0.5") }; var repository = new Mock <IPackageRepository>(); repository.Setup(c => c.GetPackages()).Returns(packages.AsQueryable()); repository.Setup(c => c.AddPackage(It.IsAny <IPackage>())).Throws(new Exception("Method should not be called")); repository.Setup(c => c.RemovePackage(It.IsAny <IPackage>())).Throws(new Exception("Method should not be called")); var packageManager = new PackageManager(GetFactory().CreateRepository("Some source"), new DefaultPackagePathResolver(fileSystem), fileSystem, repository.Object); var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, packageManager); installCommand.ExcludeVersion = true; installCommand.Arguments.Add("A"); // Act and Assert ExceptionAssert.Throws <InvalidOperationException>(() => installCommand.ExecuteCommand(), "Unable to find package 'A'."); // Ensure packages were not removed. Assert.Equal(1, packages.Count); }
public void ReadBytesFailure() { ExceptionAssert.Throws <JsonReaderException>( "Error reading bytes. Unexpected token: Integer. Path 'Test1'.", () => { JObject o = new JObject( new JProperty("Test1", 1) ); using (JTokenReader jsonReader = new JTokenReader(o)) { jsonReader.Read(); Assert.AreEqual(JsonToken.StartObject, jsonReader.TokenType); jsonReader.Read(); Assert.AreEqual(JsonToken.PropertyName, jsonReader.TokenType); Assert.AreEqual("Test1", jsonReader.Value); jsonReader.ReadAsBytes(); } }); }
public async Task SubscribedWebHooksShouldFailOnErrors() { string testName = "SubscribedWebHooksShouldFailOnErrors"; string hook = "hookCalled/1"; using (new LatencyLogger(testName)) { await ApplicationManager.RunAsync("HookSite" + testName, async hookAppManager => { string customHookEventType = "CustomEvent"; string hookAddress = hookAppManager.SiteUrl + hook; await hookAppManager.WebHooksManager.SubscribeAsync(new WebHook(customHookEventType, hookAddress)); var thrownException = await ExceptionAssert.ThrowsAsync <HttpUnsuccessfulRequestException>(async() => { await hookAppManager.WebHooksManager.SubscribeAsync(new WebHook(customHookEventType + "_DifferentEvent", hookAddress)); }); Assert.Contains("Conflict", thrownException.Message); }); } }
public void CheckIllegalTagInput() { var container = MakeContainer(); ExceptionAssert.Throws <ArgumentNullException>(() => { container.Tag("TestTag"); }); ExceptionAssert.Throws <ArgumentNullException>(() => { container.Tag("TestTag", null); }); ExceptionAssert.Throws <ArgumentNullException>(() => { container.Tag(null, "service1", "service2"); }); ExceptionAssert.Throws <ArgumentNullException>(() => { container.Tag(string.Empty, "service1", "service2"); }); }
public void DataContractSerializerDuplicateNameEnumTest() { MemoryStream ms = new MemoryStream(); var s = new DataContractSerializer(typeof(DuplicateEnumNameTestClass)); ExceptionAssert.Throws <InvalidDataContractException>(() => { s.WriteObject(ms, new DuplicateEnumNameTestClass { Value = DuplicateNameEnum.foo_bar, Value2 = DuplicateNameEnum2.foo_bar_NOT_USED }); string xml = @"<DuplicateEnumNameTestClass xmlns=""http://schemas.datacontract.org/2004/07/Newtonsoft.Json.Tests.Converters"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance""> <Value>foo_bar</Value> <Value2>foo_bar</Value2> </DuplicateEnumNameTestClass>"; var o = (DuplicateEnumNameTestClass)s.ReadObject(new MemoryStream(Encoding.UTF8.GetBytes(xml))); Assert.AreEqual(DuplicateNameEnum.foo_bar, o.Value); Assert.AreEqual(DuplicateNameEnum2.FooBar, o.Value2); }, "Type 'Newtonsoft.Json.Tests.Converters.DuplicateNameEnum' contains two members 'foo_bar' 'and 'FooBar' with the same name 'foo_bar'. Multiple members with the same name in one type are not supported. Consider changing one of the member names using EnumMemberAttribute attribute."); }
public void Validate_NoException_ForParameterAlias() { // Arrange IEdmModel model = GetEdmModel(); IEdmEntityType edmType = model.SchemaElements.OfType <IEdmEntityType>().Single(t => t.Name == "LimitedEntity"); IEdmEntitySet entitySet = model.FindDeclaredEntitySet("Microsoft.AspNet.OData.Query.Validators.LimitedEntities"); ODataQueryContext context = new ODataQueryContext(model, edmType); OrderByQueryOption option = new OrderByQueryOption( "@p,@q desc", context, new ODataQueryOptionParser( model, edmType, entitySet, new Dictionary <string, string> { { "$orderby", "@p,@q desc" }, { "@p", "Id" }, { "@q", "RelatedEntity/Id" } })); ODataValidationSettings settings = new ODataValidationSettings(); // Act & Assert ExceptionAssert.DoesNotThrow(() => _validator.Validate(option, settings)); }
public async Task ReadSingleMessageAsync_ExceedReceiveSize_ReturnData() { // Arrange var context = HttpContextServerCallContextHelper.CreateServerCallContext(maxReceiveMessageSize: 1); var ms = new MemoryStream(new byte[] { 0x00, // compression = 0 0x00, 0x00, 0x00, 0x02, // length = 1 0x10, 0x10 }); var pipeReader = PipeReader.Create(ms); // Act var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => pipeReader.ReadSingleMessageAsync(context, TestDataMarshaller.ContextualDeserializer).AsTask()).DefaultTimeout(); // Assert Assert.AreEqual("Received message exceeds the maximum configured message size.", ex.Status.Detail); Assert.AreEqual(StatusCode.ResourceExhausted, ex.StatusCode); }
public void ReadStringValue_Numbers_NotString() { JsonTextReader reader = new JsonTextReader(new StringReader("[56,56]")); reader.Read(); ExceptionAssert.Throws <JsonReaderException>(() => { reader.ReadAsDateTime(); }, "Unexpected character encountered while parsing value: 5. Path '', line 1, position 2."); ExceptionAssert.Throws <JsonReaderException>(() => { reader.ReadAsDateTime(); }, "Unexpected character encountered while parsing value: 6. Path '', line 1, position 3."); ExceptionAssert.Throws <JsonReaderException>(() => { reader.ReadAsDateTime(); }, "Unexpected character encountered while parsing value: ,. Path '[0]', line 1, position 4."); Assert.AreEqual(56, reader.ReadAsInt32()); Assert.IsTrue(reader.Read()); }
public async Task ReadSingleMessageAsync_AdditionalData_ThrowError() { // Arrange var ms = new MemoryStream(new byte[] { 0x00, // compression = 0 0x00, 0x00, 0x00, 0x01, // length = 1 0x10, 0x10 // additional data }); var pipeReader = PipeReader.Create(ms); // Act var ex = await ExceptionAssert.ThrowsAsync <RpcException>( () => pipeReader.ReadSingleMessageAsync(HttpContextServerCallContextHelper.CreateServerCallContext(), TestDataMarshaller.ContextualDeserializer).AsTask()).DefaultTimeout(); // Assert Assert.AreEqual("Additional data after the message received.", ex.Status.Detail); Assert.AreEqual(StatusCode.Internal, ex.StatusCode); }
public async Task AsyncClientStreamingCall_DeadlineDuringWrite_ResponseThrowsDeadlineExceededStatus() { // Arrange var httpClient = ClientTestHelpers.CreateTestClient(request => { var stream = new SyncPointMemoryStream(); var content = new StreamContent(stream); return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, content, grpcStatusCode: null))); }); var systemClock = new TestSystemClock(DateTime.UtcNow); var invoker = HttpClientCallInvokerFactory.Create(httpClient, systemClock: systemClock); var deadline = systemClock.UtcNow.AddMilliseconds(0.1); // Act var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions(deadline: deadline)); systemClock.UtcNow = deadline; // Assert var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.RequestStream.WriteAsync(new HelloRequest())).DefaultTimeout(); Assert.AreEqual(StatusCode.DeadlineExceeded, ex.StatusCode); Assert.AreEqual(StatusCode.DeadlineExceeded, call.GetStatus().StatusCode); }
public async Task Unary_DeadlineExceedBeforeServerCall_Failure() { var callCount = 0; var tcs = new TaskCompletionSource <DataMessage>(TaskCreationOptions.RunContinuationsAsynchronously); Task <DataMessage> UnaryFailure(DataMessage request, ServerCallContext context) { callCount++; return(tcs.Task); } // Arrange var method = Fixture.DynamicGrpc.AddUnaryMethod <DataMessage, DataMessage>(UnaryFailure); var serviceConfig = ServiceConfigHelpers.CreateRetryServiceConfig(retryableStatusCodes: new List <StatusCode> { StatusCode.DeadlineExceeded }); var channel = CreateChannel(serviceConfig: serviceConfig); var client = TestClientFactory.Create(channel, method); // Act var call = client.UnaryCall(new DataMessage(), new CallOptions(deadline: DateTime.UtcNow)); // Assert var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseAsync).DefaultTimeout(); Assert.AreEqual(StatusCode.DeadlineExceeded, ex.StatusCode); Assert.AreEqual(StatusCode.DeadlineExceeded, call.GetStatus().StatusCode); Assert.AreEqual(0, callCount); AssertHasLog(LogLevel.Debug, "RetryEvaluated", "Evaluated retry for failed gRPC call. Status code: 'DeadlineExceeded', Attempt: 1, Retry: False"); AssertHasLog(LogLevel.Debug, "CallCommited", "Call commited. Reason: DeadlineExceeded"); tcs.SetResult(new DataMessage()); }
public void Constructor3ThrowsWithNullFormatters() { TestDataAssert.Execute( TestData.RepresentativeValueAndRefTypeTestDataCollection, (type, obj) => { foreach (HttpMethod httpMethod in HttpTestData.AllHttpMethods) { foreach (Uri uri in TestData.UriTestData) { ExceptionAssert.ThrowsArgumentNull <TargetInvocationException>( "formatters", () => { HttpRequestMessage request = GenericTypeAssert.InvokeConstructor <HttpRequestMessage>( httpRequestMessageOfTType, type, new Type[] { type, typeof(HttpMethod), typeof(Uri), typeof(IEnumerable <MediaTypeFormatter>) }, new object[] { obj, httpMethod, uri, null }); }); } } }); }
public async Task ParseAdditionalContent_TextAsync() { string json = @"[ ""Small"", ""Medium"", ""Large"" ]content"; JsonTextReader reader = new JsonTextReader(new StringReader(json)); #if DEBUG reader.SetCharBuffer(new char[2]); #endif await reader.ReadAsync(); Assert.AreEqual(1, reader.LineNumber); await reader.ReadAsync(); Assert.AreEqual(2, reader.LineNumber); await reader.ReadAsync(); Assert.AreEqual(3, reader.LineNumber); await reader.ReadAsync(); Assert.AreEqual(4, reader.LineNumber); await reader.ReadAsync(); Assert.AreEqual(5, reader.LineNumber); await ExceptionAssert.ThrowsAsync <JsonReaderException>(async() => { await reader.ReadAsync(); }, "Additional text encountered after finished reading JSON content: c. Path '', line 5, position 1."); }
public void CreateTableWithoutIndexesTest() { var db = new OrmTestSession(); // the table db.CreateTable <IndexedTable>(false); // the indexes var map = db.GetMapping <IndexedTable>(); foreach (var index in map.Indexes) { db.Execute(index.GetCreateSql(map.TableName)); } // the test db.Insert(new IndexedTable { Indexed = 1 }); ExceptionAssert.Throws <SqliteException>( () => db.Insert(new IndexedTable { Indexed = 1 })); }
public void MissingDotAfterIndexer() { ExceptionAssert.Throws <JsonException>(() => { new JPath("[1]Blah"); }, "Unexpected character following indexer: B"); }
public void Constructor_Throws_WhenResponsesAreNull() { // Arrange & Act & Assert ExceptionAssert.ThrowsArgumentNull(() => CreateBatchContent(null), "responses"); }
public void IndexerCloseInProperty() { ExceptionAssert.Throws <JsonException>(() => { new JPath("]"); }, "Unexpected character while parsing path: ]"); }