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"));
}
