public async Task ExecuteJsonPostAsync() { // Arrange const string expectedResponseMessage = "Item created"; const int expectedResponseCode = 200; var jsonObject = new { Id = 42, Name = "Test Object", Delta = 56.78f }; var request = new PostJsonRequest("RestArt", jsonObject, null, null); IRestArtClient client = new RestArtClient(this._restUrl); client.AddOrUpdatePersistentHeader("PersistentHeader", "ph-value"); // Act IRestResponse<TestResponse> response = await client.ExecuteAsync<TestResponse>(request); // Assert Assert.NotNull(response); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.NotNull(response.Raw); Assert.NotNull(response.Value); Assert.Equal(expectedResponseCode, response.Value.Code); Assert.Equal(expectedResponseMessage, response.Value.Msg); }
public void When_dns_servers_unreachable_should_throw_SocketException() { var xmppHostsLookup = new XmppHostsLookup(); var ipAddresses = new []{ IPAddress.Parse("1.1.1.1")}; //assuming there is no dns server at 1.1.1.1 var logger = new ConsoleOutLogger("XmppHostsLookupTests", LogLevel.All, true, true, true, "yyyy-MM-dd HH:MM:SS"); Assert.Throws<SocketException>( ()=> xmppHostsLookup.GetXmppHosts(ipAddresses, "host", logger)); }
public void TryMergeWithList_AddsToHead_AndMovesExisting() { serverList.GetAllEndPoints(); var seedList = new[] { new IPEndPoint( IPAddress.Loopback, 27025 ), new IPEndPoint( IPAddress.Loopback, 27035 ), new IPEndPoint( IPAddress.Loopback, 27045 ), new IPEndPoint( IPAddress.Loopback, 27105 ), }; serverList.ReplaceList( seedList ); Assert.Equal( 4, seedList.Length ); var listToReplace = new[] { new IPEndPoint( IPAddress.Loopback, 27015 ), new IPEndPoint( IPAddress.Loopback, 27035 ), new IPEndPoint( IPAddress.Loopback, 27105 ), }; serverList.ReplaceList( listToReplace ); var addresses = serverList.GetAllEndPoints(); Assert.Equal( 3, addresses.Length ); Assert.Equal( listToReplace[ 0 ], addresses[ 0 ] ); Assert.Equal( listToReplace[ 1 ], addresses[ 1 ] ); Assert.Equal( listToReplace[ 2 ], addresses[ 2 ] ); }
private static async Task CreateExchange(string queueName) { var requestUri = string.Format("{0}/exchanges/{1}/{2}", ApiRoot, VirtualHostName, queueName); var exchange = new {type = "direct"}; var body = new JavaScriptSerializer().Serialize(exchange); var content = new StringContent(body, Encoding.UTF8, JsonContentType); await _httpClient.PutAsync(requestUri, content); }
private static async Task GiveUserPermissions(string userName) { var requestUri = string.Format("{0}permissions/{1}/{2}", ApiRoot, VirtualHostName, userName); var permission = new {configure = ".*", write = ".*", read = ".*"}; var body = new JavaScriptSerializer().Serialize(permission); var content = new StringContent(body, Encoding.UTF8, JsonContentType); await _httpClient.PutAsync(requestUri, content); }
public void Then_documents_should_be_indexed() { var documents = new[] { new Document("1").AddField("key", "value"), new Document("2").AddField("key", "value") }; Index.AddDocuments(documents); TankTopClient.StatusCode.Should().Be(HttpStatusCode.OK); }
public void TestToEndPointWithExternalAddress() { IPEndPoint endpointFromDomain = "deltaengine.net".ToEndPoint(777); IPEndPoint endpointFromIp = "217.91.31.182".ToEndPoint(777); // Allow local IP for buildserver var validEndpoints = new [] { "217.91.31.182:777", "192.168.0.9:777" }; Assert.Contains(endpointFromDomain.ToString(), validEndpoints); Assert.Contains(endpointFromIp.ToString(), validEndpoints); }
public static void UpdateConfiguration(HttpConfiguration configuration) { var controllers = new[] { typeof(TradesController) }; TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers)); configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; configuration.Services.Replace(typeof(IAssembliesResolver), resolver); configuration.MapODataServiceRoute("OData", "", GetModel()); configuration.EnsureInitialized(); }
public override void OnException(HttpActionExecutedContext actionExecutedContext) { // TODO: Add logging var response = new { ErrorMessage = actionExecutedContext.Exception.Message, }; actionExecutedContext.Response = actionExecutedContext.Request.CreateResponse(HttpStatusCode.InternalServerError, response); }
public HttpResponseMessage Get() { var gems = new[] { new Gem{Name = "Dodecahedron",Price = 2.95, Description = "Some description", CanPurchase = true, IsSoldOut = false, Reviews = new[]{new Review{Author = "[email protected]", Body = "I love it", Stars = 5}}}, new Gem{Name = "Pentagon",Price = 3.95, Description = "Some description", CanPurchase = true, IsSoldOut = false, Reviews = new[]{new Review{Author = "[email protected]", Body = "I like it", Stars = 3}}}, new Gem{Name = "Cube",Price = 0.95, Description = "Some description", CanPurchase = true, IsSoldOut = false, Reviews = new[]{new Review{Author = "[email protected]", Body = "I hate it", Stars = 1}}} }; return Request.CreateResponse(HttpStatusCode.OK, gems); }
protected async Task<bool> CheckNeedUpdateAsync(string date) { string urlApi = "http://test.api.unitgroup.ru/data/ServiceMobile/CheckDeviceInfoListIsChanged?lastModifyDate={0}"; urlApi = string.Format(urlApi, date); string responseStr = await _getApiResponseAsync(_getApiRequest(urlApi)); var changed = new { isChanged = true }; var needChange = JsonConvert.DeserializeAnonymousType(responseStr, changed); return needChange.isChanged; }
public void Route_Parameters_Casing(string httpMethod, string requestUrl, string expectedActionName) { string routeUrl = "{controller}/{ID}"; object routeDefault = new { id = RouteParameter.Optional }; HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault); context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "test", typeof(TestController)); HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context); Assert.Equal(expectedActionName, descriptor.ActionName); }
public void TestToEndPointWithExternalAddress() { const string DeltaEngineExternalIp = "217.91.31.182"; IPEndPoint endpointFromDomain = NetworkExtensions.ToEndPoint("deltaengine.net", ServicesPort); IPEndPoint endpointFromIp = NetworkExtensions.ToEndPoint(DeltaEngineExternalIp, ServicesPort); const string DeltaEngineInternalIp = "192.168.0.5"; var validEndpoints = new[] { DeltaEngineExternalIp + ":" + ServicesPort, DeltaEngineInternalIp + ":" + ServicesPort }; Assert.Contains(endpointFromDomain.ToString(), validEndpoints); Assert.Contains(endpointFromIp.ToString(), validEndpoints); }
public static void UpdateConfiguration(HttpConfiguration configuration) { var controllers = new[] { typeof(DLManagersController), typeof(DLEmployeesController) }; TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers)); configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; configuration.Services.Replace(typeof(IAssembliesResolver), resolver); configuration.Routes.Clear(); configuration.MapODataServiceRoute("OData", "odata", DollarLevelsEdmModel.GetConventionModel()); configuration.EnsureInitialized(); }
public void TestIndex() { var currencyRatesService = new Mock<ICurrencyRatesService>(); var rates = new[] { new Rate { CurrencyCode = "EUR" }, new Rate { CurrencyCode = "USD" } }; currencyRatesService.Setup(crs => crs.FindLatest()).Returns(rates); var controller = new RatesController(currencyRatesService.Object); var result = controller.Index(); Assert.That(result, Is.Not.Null); Assert.That(result.Model, Is.EqualTo(rates)); }
public override void OnException(HttpActionExecutedContext context) { if (context.Exception.GetType() == typeof(BusinessException)) { BusinessException businessException=context.Exception as BusinessException; var errorModel = new { ExceptionMessage = businessException.Message, ExceptionCode = businessException.Code, ExceptionOveridable = false }; context.Response = context.Request.CreateResponse(HttpStatusCode.ExpectationFailed, errorModel); } else { context.Response = context.Request.CreateResponse(HttpStatusCode.InternalServerError, context.Exception); } }
public HttpResponseMessage Get(bool archivedTrips = false) { // query the database // if result returns error, return CreateErrorResponse and pass along message // map results to a view model object // temporary stub data var model = new[] { new { title = "My first trip", date = "January 2016" } }; return Request.CreateResponse(HttpStatusCode.OK, model); }
public static string GetIp(HttpContextWrapper context) { if (Equals(context, null)) return string.Empty; var ips = new[] { "127.0.0.1", context.Request.ServerVariables["REMOTE_ADDR"], context.Request.ServerVariables["HTTP_X_FORWARDED_FOR"] }; var length = ips.Length; var ret = ips[0]; while (length-- > 0) { if (string.IsNullOrWhiteSpace(ips[length]) || "::1".Equals(ips[length])) continue; ret = ips[length]; break; } return ret; }
public void Should_pass_on_the_filtered_servers_to_subsequent_selectors() { var selector1Selected = new[] { _description.Servers[1], _description.Servers[2] }; var selector1 = Substitute.For<IServerSelector>(); selector1.SelectServers(null, null).ReturnsForAnyArgs(selector1Selected); var selector2 = Substitute.For<IServerSelector>(); var subject = new CompositeServerSelector(new[] { selector1, selector2 }); subject.SelectServers(_description, _description.Servers); selector1.Received().SelectServers(_description, _description.Servers); selector2.Received().SelectServers(_description, selector1Selected); }
public override void Run() { var cloudConnectionString = CloudConfigurationManager.GetSetting("Microsoft.Storage.ConnectionString"); IContentRepository content = new BlobStorageContentRepository(cloudConnectionString, "content"); IDataRepository data = new BlobStorageDataRespository(cloudConnectionString, "data"); IUploader uploader = new BlobStorageUploader(cloudConnectionString, "output"); var productIds = new[] { "1", "2", "3", "4", "5" }; var renderer = new RenderHtmlPage(content, data); foreach (var productId in productIds) { var result = renderer.BuildContentResult("product", productId); uploader.SaveContentToLocation(result, productId); } }
public HttpResponseMessage Get(int id) { var provider = new RealEstate.ZillowListingsFeed(); var property = provider.Property(new Property{Zpid = id}); var propertyModel = ModelFactory.Create(property); if (propertyModel != null) { var returnModel = new { Property = propertyModel }; return Request.CreateResponse(HttpStatusCode.OK, returnModel); } else { return Request.CreateResponse(HttpStatusCode.NoContent); } }
public void Given_the_Application_is_Intialized() { it["Should create a cart and the intialize the Id for the same"] = () => { var client = HttpClientFactory.CreateClient(); CreateCartCommand command = new CreateCartCommand(); command.Id = 1; var Response = client.PostAsJsonAsync("api/Cart", command).Result; Response.StatusCode.should_be(HttpStatusCode.Created); Response.Headers.Location.ToString().should_be("http://localhost:8082/api/Cart/1"); }; it["Should be possible to add a product to the cart"] = () => { var client = HttpClientFactory.CreateClient(); CreateCartCommand Createcommand = new CreateCartCommand(); Createcommand.Id = 1; client.PostAsJsonAsync("api/Cart", Createcommand); var command = new { cartId = 1, productId = 1, quantity = 1 }; var Response = client.PutAsJsonAsync("api/Cart", command).Result; Response.StatusCode.should_be(HttpStatusCode.OK); }; it["Should be possible to increase the quantity of the product in the cart"] = () => { var client = HttpClientFactory.CreateClient(); CreateCartCommand Createcommand = new CreateCartCommand(); Createcommand.Id = 1; client.PostAsJsonAsync("api/Cart", Createcommand); AddProductToCartCommand command = new AddProductToCartCommand { CartId = 1, ProductId = 1, Quantity = 2 }; var Response = client.PutAsJsonAsync("api/Cart", command).Result; Response.StatusCode.should_be(HttpStatusCode.OK); }; xit["Should be able to delete the Product from the Cart"] = () => { var client = HttpClientFactory.CreateClient(); CreateCartCommand Createcommand = new CreateCartCommand(); Createcommand.Id = 1; client.PostAsJsonAsync("api/Cart", Createcommand); AddProductToCartCommand command = new AddProductToCartCommand { CartId = 1, ProductId = 1, Quantity = 2 }; client.PutAsJsonAsync("api/Cart", command); var DeleteCommand = new { cartId = 1, productId = 1, quantity = 0 }; var Response = client.PutAsJsonAsync("api/Cart", DeleteCommand).Result; Response.StatusCode.should_be(HttpStatusCode.NoContent); }; }
public void SelectAction_ThrowsNotFound_OnRouteWithActionParameter(string httpMethod, string requestUrl) { string routeUrl = "{controller}/{action}/{id}"; object routeDefault = new { id = RouteParameter.Optional }; HttpControllerContext controllerContext = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault); Type controllerType = typeof(ActionAttributeTestController); controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, controllerType.Name, controllerType); var exception = Assert.Throws<HttpResponseException>(() => { HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(controllerContext); }); Assert.Equal(HttpStatusCode.NotFound, exception.Response.StatusCode); var content = Assert.IsType<ObjectContent<string>>(exception.Response.Content); Assert.Equal("No action was found on the controller 'ActionAttributeTestController' that matches the request.", content.Value); }
public static void UpdateConfiguration(HttpConfiguration configuration) { var controllers = new[] { typeof(CustomersController), typeof(OrdersController), typeof(MetadataController) }; TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers)); configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; configuration.Services.Replace(typeof(IAssembliesResolver), resolver); configuration.EnableUnqualifiedNameCall(true); configuration.Routes.Clear(); configuration.MapODataServiceRoute(routeName: "odata", routePrefix: "odata", model: UriParserExtenstionEdmModel.GetEdmModel()); configuration.EnsureInitialized(); }
public static void UpdateConfiguration(HttpConfiguration configuration) { var controllers = new[] { typeof(ProductsController), typeof(MetadataController) }; TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers)); configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; configuration.Services.Replace(typeof(IAssembliesResolver), resolver); configuration.Routes.Clear(); IEdmModel edmModel = CastEdmModel.GetEdmModel(); foreach (string dataSourceType in dataSourceTypes) { configuration.MapODataServiceRoute(dataSourceType, dataSourceType, edmModel); } configuration.EnsureInitialized(); }
public void SelectAction_ThrowsMethodNotSupported_OnRouteWithActionParameter(string httpMethod, string requestUrl) { string routeUrl = "{controller}/{action}/{id}"; object routeDefault = new { id = RouteParameter.Optional }; HttpControllerContext controllerContext = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault); Type controllerType = typeof(ActionAttributeTestController); controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, controllerType.Name, controllerType); var exception = Assert.Throws<HttpResponseException>(() => { HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(controllerContext); }); Assert.Equal(HttpStatusCode.MethodNotAllowed, exception.Response.StatusCode); var content = Assert.IsType<ObjectContent<HttpError>>(exception.Response.Content); Assert.Equal("The requested resource does not support http method '" + httpMethod + "'.", ((HttpError)content.Value).Message); }
public HttpResponseMessage GetUserProfile(int userId) { var upc = new UserProfileController(); var up = upc.Profiles_Get(PortalSettings.PortalId, ActiveModule.ModuleID, userId); if(up == null) return Request.CreateResponse(HttpStatusCode.NotFound); var result = new { up.UserID, up.TrustLevel, up.UserCaption, up.Signature, up.RewardPoints }; return Request.CreateResponse(HttpStatusCode.OK, result); }
public static void UpdateConfiguration(HttpConfiguration configuration) { var controllers = new[] { typeof(DynamicCustomersController), typeof(DynamicSingleCustomerController), typeof(MetadataController), }; TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers)); configuration.Services.Replace(typeof(IAssembliesResolver), resolver); configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; configuration.Routes.Clear(); configuration.GetHttpServer(); configuration.MapODataServiceRoute(routeName: "odata", routePrefix: "odata", model: GetEdmModel()); configuration.EnsureInitialized(); }
public void CanGetAccessTokenUsingStandardPrimitives() { Request request = Session.Bind(OAuth2TestConstants.TokenEndpointPath) .BasicAuthentication(OAuth2TestConstants.ClientID, OAuth2TestConstants.ClientPassword) .AsFormUrlEncoded() .AcceptJson(); var tokenRequest = new { grant_type = "password", username = OAuth2TestConstants.Username, password = OAuth2TestConstants.UserPassword }; using (var response = request.Post<dynamic>(tokenRequest)) { Assert.IsNotNull(response.Body); Assert.That(response.Body.access_token, Is.Not.Null.And.Not.Empty); } }
[InlineData("GET", "ActionAttributeTest/NonAction")] // NonAction, 404 public void SelectAction_ThrowsNotFound_OnRouteWithActionParameter(string httpMethod, string requestUrl) { string routeUrl = "{controller}/{action}/{id}"; object routeDefault = new { id = RouteParameter.Optional }; HttpControllerContext controllerContext = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault); controllerContext.Configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; Type controllerType = typeof(ActionAttributeTestController); controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, controllerType.Name, controllerType); var exception = Assert.Throws<HttpResponseException>(() => { HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(controllerContext); }); Assert.Equal(HttpStatusCode.NotFound, exception.Response.StatusCode); var content = Assert.IsType<ObjectContent<HttpError>>(exception.Response.Content); // Error message might be ApiControllerActionSelector_ActionNameNotFound or ApiControllerActionSelector_ActionNotFound string actualMessage = (string)((HttpError)content.Value)["MessageDetail"]; Assert.True(actualMessage.StartsWith("No action was found on the controller 'ActionAttributeTestController' that matches")); }