public void Index_Returns_View_with_Values()
{
var expected_values = new[] { "1", "2", "3" };
var values_service_mock = new Mock <IValuesService>();
values_service_mock
.Setup(service => service.Get())
.Returns(expected_values);
// Стаб
var controller = new WebApiController(values_service_mock.Object);
var result = controller.Index();
var view_result = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <IEnumerable <string> >(view_result.Model);
Assert.Equal(expected_values.Length, model.Count());
//"Мок"
values_service_mock.Verify(service => service.Get());
values_service_mock.VerifyNoOtherCalls();
}
public JsonResult GetTankerDetails(string rSTNo)
{
WebApiController api = new WebApiController();
var details = api.GetTankerDetails(rSTNo);
return(this.Json(details, JsonRequestBehavior.AllowGet));
}
public JsonResult GetAllVendorDetails()
{
WebApiController api = new WebApiController();
var details = api.GetAllVendorDetails();
return(this.Json(details, JsonRequestBehavior.AllowGet));
}
public static Task <bool> JsonResponseAsync(this WebApiController This, object obj,
HttpStatusCode statusCode = HttpStatusCode.OK)
{
This.Response.StatusCode = (int)statusCode;
return(This.StringResponseAsync(obj?.ToJson() ?? "{}"));
}
/// <summary>
/// Clicando no botão editar do formulário para atualizar o nome da atividade
/// </summary>
/// <param name="sender">object</param>
/// <param name="e">EventArgs</param>
protected void btnEditar_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{
//preenche os dados
var atividades = new AtividadesToDo()
{
NomeTodo = HtmlToText.StripHtml(txtTituloToDo.Text),
CompletoTodo = 0,
IdTodo = int.Parse(hdIdToDo.Value)
};
//atualiza os dados na web api
HttpResponseMessage response = WebApiController.AtualizarDadosWebApi(hdIdToDo.Value, atividades);
if (response.IsSuccessStatusCode)
{
Response.Redirect("Default?guid=" + Guid.NewGuid() + "&id=AtualizadoSucesso");
}
else
{
Response.Write(response.StatusCode + " - " + response.ReasonPhrase);
}
}
}
/// <summary>
/// Segunda grid com as atividades já realizadas
/// </summary>
/// <param name="sender">object</param>
/// <param name="e">GridViewCommandEventArgs</param>
protected void grdToDoCompleto_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName == "DesFeito")
{
int index = int.Parse((string)e.CommandArgument);
string chave = grdToDoCompleto.DataKeys[index]?["IdToDo"].ToString();
//preenche os dados
var atividades = new AtividadesToDo()
{
NomeTodo = HtmlToText.StripHtml(grdToDoCompleto.Rows[index].Cells[1].Text),
CompletoTodo = 0,
IdTodo = int.Parse(chave ?? throw new InvalidOperationException())
};
//atualiza os dados no web api
HttpResponseMessage response = WebApiController.AtualizarDadosWebApi(chave, atividades);
if (response.IsSuccessStatusCode)
{
Response.Redirect("Default?guid=" + Guid.NewGuid() + "&id=AtualizadoSucesso");
}
else
{
Response.Write(response.StatusCode + " - " + response.ReasonPhrase);
}
}
}
public void Index_Returns_View_with_Values()
{
var expected_values = new[] { "1", "2", "3" };
var values_service_mock = new Mock <IValuesService>(); //
values_service_mock //
.Setup(x => x.Get()) // Стаб - некоторый результат, который будет использован внутри тестового объекта.
.Returns(expected_values); //(прикидываемся интерфейсом)
var controller = new WebApiController(values_service_mock.Object); // Stab
var result = controller.Index();
var view_result = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <IEnumerable <string> >(view_result.Model);
Assert.Equal(expected_values.Length, model.Count());
//Mock
values_service_mock.Verify(service => service.Get());
values_service_mock.VerifyNoOtherCalls();
}
public void WriteEndpointClassToBlock(TypeScriptBlock endpointsBlock, WebApiController webApiController)
{
var controllerBlock = endpointsBlock
.AddAndUseBlock($"export {Config.NamespaceOrModuleName} {webApiController.Name}");
var actions = webApiController.Actions.Where(a => a.IsMobileAction);
foreach (var action in actions)
{
if (action.BodyParameters.Count > 1)
{
LogMessage($"Multiple conflicting call parameters detected in action [{action.Name}] of controller [{webApiController.Name}]!");
LogMessage("Please use [FromBody] or [FromUri] on all non-primitives!");
var parameters = action.BodyParameters.Select(bp => $"[{bp.Name}]");
LogMessage($"Parameters: {string.Join(" ", parameters)}");
LogMessage("");
continue;
}
foreach (var verb in action.Verbs)
{
var actionName = action.GetActionNameForVerb(verb);
var interfaceBlock = controllerBlock
.AddAndUseBlock($"export interface I{actionName}");
WriteInterfaceToBlock(interfaceBlock, action);
var endpointBlock = controllerBlock
.AddAndUseBlock($"export interface I{actionName}Endpoint extends I{actionName}, IEndpoint");
var ctorBlock = controllerBlock
.AddAndUseBlock($"export interface I{actionName}Ctor")
.AddStatement($"new(args?: I{actionName}): I{actionName}Endpoint");
var ctorImplBlock = controllerBlock
.AddAndUseBlock($"export var {actionName} : I{actionName}Ctor = <any>(function(args?: I{actionName})", false, ");")
.AddStatement($"this._verb = '{verb.VerbMethod}';");
var constructorParameterMappings = action.GetConstructorParameterMappings(ignoreEnumDefinitions: true);
foreach (var mapping in constructorParameterMappings)
{
ctorImplBlock.AddStatement($"this.{mapping.Name} = args != null ? args.{mapping.Name} : null;");
if (mapping.TypeMapping?.AutoInitialize ?? false)
{
ctorImplBlock
.AddAndUseBlock($"if (this.{mapping.Name} == null)")
.AddStatement($"this.{mapping.Name} = new {mapping.TypeMapping.TypeScriptTypeName}();");
}
}
WriteGetQueryStringToBlock(controllerBlock, actionName, action);
WriteToStringToBlock(controllerBlock, actionName, action);
}
}
}
public void IsConnectedTest()
{
WebApiController api = new WebApiController();
bool result = api.IsConnected(true);
Assert.IsTrue(result);
}
public void ControllerWithProvidedInstanceShouldPopulateCorrectInstanceOfControllerType()
{
var instance = new WebApiController();
var controller = MyWebApi.Controller(instance).Controller;
Assert.IsNotNull(controller);
Assert.IsAssignableFrom <WebApiController>(controller);
}
public void ControllerWithProvidedInstanceShouldPopulateCorrectInstanceOfControllerType()
{
var instance = new WebApiController();
var controller = MyWebApi.Controller(instance).AndProvideTheController();
Assert.IsNotNull(controller);
Assert.IsAssignableFrom<WebApiController>(controller);
}
public ActionResult InsertVendorTanker(VendorTankerModel res)
{
if (res != null)
{
WebApiController webapi = new WebApiController();
webapi.InsertVendorTanker(res);
}
return(RedirectToAction("Index"));
}
public void WriteEndpointClassToBlock(TypeScriptBlock endpointBlock, WebApiController webApiController)
{
var controllerBlock = endpointBlock
.AddAndUseBlock($"export {Config.NamespaceOrModuleName} {webApiController.Name}");
TypeScriptBlock serviceBlock = null;
if (Config.GenerateService)
{
serviceBlock = controllerBlock
.AddAndUseBlock($"export interface I{webApiController.Name}Service");
}
var actions = webApiController.Actions;
foreach (var action in actions)
{
foreach (var verb in action.Verbs)
{
var actionName = action.GetActionNameForVerb(verb);
var interfaceBlock = controllerBlock
.AddAndUseBlock($"export interface I{actionName}");
WriteInterfaceToBlock(interfaceBlock, action);
if (Config.GenerateService)
{
var interfaceWithCallBlock = controllerBlock
.AddAndUseBlock($"export interface I{actionName}WithCall extends I{actionName}, {IEndpoint}");
WriteInterfaceWithCallToBlock(interfaceWithCallBlock, action, verb);
serviceBlock
.AddStatement($"{actionName}: (args?: I{actionName}) => I{actionName}WithCall");
}
var classBlock = controllerBlock
.AddAndUseBlock($"export class {actionName} implements I{actionName}, {IEndpoint}")
.AddStatement($"_verb = '{verb.VerbMethod}';");
var constructorParameterMappings = action.GetConstructorParameterMappings();
foreach (var constructorParameterMapping in constructorParameterMappings)
{
classBlock
.AddStatement($"{constructorParameterMapping.String};");
}
WriteConstructorToBlock(classBlock, action, verb);
WriteGetQueryStringToBlock(classBlock, action);
WriteToStringToBlock(classBlock, action);
}
}
}
public void WithResponseModelShouldNotThrowExceptionWithCorrectResponseModel()
{
var controller = new WebApiController();
MyWebApi
.Controller(controller)
.Calling(c => c.HttpResponseMessageAction())
.ShouldReturn()
.HttpResponseMessage()
.WithResponseModel(controller.ResponseModel);
}
public void WithResponceModelShouldNotThrowExceptionWithDeeplyEqualPassedExpectedObject()
{
var controller = new WebApiController();
MyWebApi
.Controller<WebApiController>()
.Calling(c => c.OkResultWithResponse())
.ShouldReturn()
.Ok()
.WithResponseModel(controller.ResponseModel);
}
public void WithResponseModelShouldNotThrowExceptionWithCorrectResponseModel()
{
var controller = new WebApiController();
MyWebApi
.Controller(controller)
.Calling(c => c.HttpResponseMessageAction())
.ShouldReturn()
.HttpResponseMessage()
.WithResponseModel(controller.ResponseModel);
}
public void Cannot_Get_Data_When_Not_Contain_KeyString()
{
MyMock myMock = new MyMock();
string key = "GPU";
myMock.ProductRepository.Setup(m => m.Products).Returns(GetProductsData());
var controller = new WebApiController(myMock.ProductRepository.Object);
ProductsListJsonViewModel result = controller.GetSpecifyProductIntro("ALL", key);
Assert.AreEqual(0, result.Products.Count());
}
public void Setup()
{
_listener = new HttpListener();
_localEndPoint = new IPEndPoint(IPAddress.Loopback, 8080);
_apiUrl = string.Format("http://{0}/sharpremote/api/test/", _localEndPoint);
_listener.Prefixes.Add(_apiUrl);
_listener.Start();
_client = new HttpClient();
_server = new WebApiController();
_container = new SystemNetHttpListener(_listener, _server);
}
/// <summary>
/// Preenche o grid com as atividades não completas
/// </summary>
private void PreencherGridNaoCompleto()
{
HttpResponseMessage response = WebApiController.ConsultaWebApiByStatus(0);
if (response.IsSuccessStatusCode)
{
var contas = response.Content.ReadAsAsync <IEnumerable <AtividadesToDo> >().Result;
grdToDo.DataSource = contas;
grdToDo.DataBind();
}
}
public override bool Execute()
{
InitializeServices();
var apiControllers = TypeService.GetControllers(Config.WebApiModuleFileName);
var endpointBlock = EndpointsService.CreateEndpointBlock();
var serviceBlock = AngularEndpointsService.CreateServiceBlock();
StartAnalysis("controllers and actions");
foreach (var apiController in apiControllers)
{
var webApiController = new WebApiController(apiController);
EndpointsService.WriteEndpointClassToBlock(endpointBlock, webApiController);
AngularEndpointsService.WriteServiceObjectToBlock(serviceBlock.Children.First() as TypeScriptBlock, webApiController);
}
StopAnalysis();
CreateFileForBlock(endpointBlock, Config.EndpointsOutputDirectory, Config.EndpointsFileName);
CreateFileForBlock(serviceBlock, Config.ServiceOutputDirectory, Config.ServiceFileName);
var enumsBlock = EnumsService.CreateEnumsBlock();
var interfacesBlock = InterfaceService.CreateInterfacesBlock();
if (Config.GenerateInterfaces)
{
StartAnalysis("interfaces");
InterfaceService.AddMatchingInterfaces();
InterfaceService.WriteInterfacesToBlock(interfacesBlock);
StopAnalysis();
CreateFileForBlock(interfacesBlock, Config.InterfacesOutputDirectory, Config.InterfacesFileName);
}
if (Config.GenerateEnums)
{
StartAnalysis("enumerations");
EnumsService.WriteEnumsToBlock(enumsBlock);
StopAnalysis();
CreateFileForBlock(enumsBlock, Config.EnumsOutputDirectory, Config.EnumsFileName);
}
return(true);
}
/// <summary>
/// Deletando dados na Web Api
/// </summary>
/// <param name="sender">object</param>
/// <param name="e">GridViewDeleteEventArgs</param>
protected void grdToDo_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
//pegando o valor selecionado no grid
string idToDo = grdToDo.DataKeys[e.RowIndex]?["IdToDo"].ToString();
//deleta os dados pela Web API
HttpResponseMessage response = WebApiController.DeletarDadosWebApi(idToDo);
if (response.IsSuccessStatusCode)
{
Response.Redirect("Default?guid=" + Guid.NewGuid() + "&id=deleteSucesso");
}
}
public void Can_Get_Data()
{
MyMock myMock = new MyMock();
myMock.ProductRepository.Setup(m => m.Products).Returns(GetProductsData());
var controller = new WebApiController(myMock.ProductRepository.Object);
ProductsListJsonViewModel result = controller.GetSpecifyProductIntro("ALL");
Assert.AreEqual(5, result.CategoryList.Count());
Assert.AreEqual("ALL", result.CategoryList.First());
Assert.AreEqual(10, result.Products.Count());
Assert.AreEqual(2, result.TotalPage);
}
public void Can_Get_Data_With_KeyString()
{
MyMock myMock = new MyMock();
string key = "2";
myMock.ProductRepository.Setup(m => m.Products).Returns(GetProductsData());
var controller = new WebApiController(myMock.ProductRepository.Object);
ProductsListJsonViewModel result = controller.GetSpecifyProductIntro("ALL", key);
Assert.AreEqual(3, result.Products.Count());
Assert.AreEqual(1, result.TotalPage);
Assert.AreEqual("smartphone2", result.Products.First().Name);
}
public void WithResponceModelShouldThrowExceptionWithDifferentPassedExpectedObject()
{
var controller = new WebApiController();
var another = controller.ResponseModel.ToList();
another.Add(new ResponseModel());
MyWebApi
.Controller<WebApiController>()
.Calling(c => c.OkResultWithResponse())
.ShouldReturn()
.Ok()
.WithResponseModel(another);
}
public void WriteServiceObjectToBlock(TypeScriptBlock serviceBlock, WebApiController webApiController)
{
var controllerBlock = serviceBlock
.AddAndUseBlock($"public {webApiController.Name} =");
var actions = webApiController.Actions;
for (var a = 0; a < actions.Count; a++)
{
var action = actions[a];
var constructorParameterMappings = action.GetConstructorParameterMappings();
for (var v = 0; v < action.Verbs.Count; v++)
{
var verb = action.Verbs[v];
var actionName = action.GetActionNameForVerb(verb);
var isLastActionAndVerb = a == actions.Count - 1 &&
v == action.Verbs.Count - 1;
var areAllParametersOptional = constructorParameterMappings
.All(m => m.IsOptional);
var optionalString = areAllParametersOptional
? "?"
: string.Empty;
var callArgumentDefinition = action.GetCallArgumentDefinition(verb);
var callArgumentValue = action.GetCallArgumentValue(verb);
var interfaceFullName = $"{Config.EndpointsNamespace}.{webApiController.Name}.I{actionName}";
var interfaceWithCallFullName = $"{Config.EndpointsNamespace}.{webApiController.Name}.I{actionName}WithCall";
var endpointFullName = $"{Config.EndpointsNamespace}.{webApiController.Name}.{actionName}";
controllerBlock
.AddAndUseBlock
(
outer: $"{actionName}: (args{optionalString}: {interfaceFullName}): {interfaceWithCallFullName} =>",
isFunctionBlock: false,
terminationString: !isLastActionAndVerb ? "," : string.Empty
)
.AddStatement($"var endpoint = new {endpointFullName}(args);")
.AddAndUseBlock("return _.extendOwn(endpoint,", isFunctionBlock: true, terminationString: ";")
.AddAndUseBlock($"call<TView>({callArgumentDefinition})")
.AddStatement($"return {Config.ServiceName}.call<TView>(this, {callArgumentValue});");
}
}
}
/// <summary>
/// Convertir el cuerpo JSON de la solicitud en un modelo de datos
/// </summary>
/// <typeparam name="T">Tipo de modelo</typeparam>
/// <param name="controller">Controlador</param>
/// <param name="body">Referencia donde almacenar el contenido del cuerpo</param>
/// <returns>null en caso de que la solicitud no sea JSON o no tenga la estructura correcta</returns>
public static T RequestBodyToModel <T>(this WebApiController controller, out string body)
where T : class
{
body = controller.RequestBody();
try {
if (controller.Request.ContentType != "application/json")
{
return(null);
}
return(JsonConvert.DeserializeObject <T>(body));
} catch (Exception) {
return(null);
}
}
//获取工单详情
public ActionResult GetOrderData(string OrderNo, string TenantID, string LineId)
{
StringBuilder sb = new StringBuilder();
try
{
WebApiController controller = new WebApiController();
dynamic result = controller.GetOrderNoDetail(LineId, OrderNo, DateTime.Now.Date.ToString("yyyy-MM-dd"), TenantID);
string status = result.status + "";
string message = result.message + "";
if (status == "error")
{
sb.Append("{\"ok\":false,");
sb.Append("\"message\":\"" + message + "\"}");
return(Json(sb.ToString(), "application/json", JsonRequestBehavior.AllowGet));
}
else
{
dynamic rows = result.rows;
int TTQty = rows.Qty;
int TodayQty = GetQty(TenantID, LineId, OrderNo);
if (TTQty < TodayQty)
{
TTQty = TodayQty;
}
string Rate = Math.Round((decimal)TTQty * 100 / Convert.ToInt32(rows.PlanQty), 2) + "%";
sb.Append("{\"ok\":true,");
sb.Append("\"OrderNo\":\"" + rows.OrderNo + "\",");
sb.Append("\"ProductCode\":\"" + rows.ProductCode + "\",");
sb.Append("\"ProductName\":\"" + rows.ProductName + "\",");
sb.Append("\"Qty\":\"" + TodayQty + "\",");
sb.Append("\"QtyNG\":\"" + rows.QtyNG + "\",");
sb.Append("\"PlanQty\":\"" + rows.PlanQty + "\",");
sb.Append("\"Ratio\":\"" + rows.Ratio + "\",");
sb.Append("\"StandUsers\":\"" + rows.StandUsers + "\",");
sb.Append("\"TTQty\":\"" + TTQty + "\",");
sb.Append("\"Rate\":\"" + Rate + "\"}");
return(Json(sb.ToString(), "application/json", JsonRequestBehavior.AllowGet));
}
}
catch (Exception ex)
{
sb.Append("{\"ok\":false,");
sb.Append("\"message\":\"" + ex.Message + "\"}");
return(Json(sb.ToString(), "application/json", JsonRequestBehavior.AllowGet));
}
}
public void Setup()
{
_dummyPolls = new InMemoryDbSet <Poll>(true);
var mockContextFactory = new Mock <IContextFactory>();
var mockContext = new Mock <IVotingContext>();
_mockContext = mockContext.Object;
mockContextFactory.Setup(a => a.CreateContext()).Returns(_mockContext);
mockContext.Setup(a => a.Polls).Returns(_dummyPolls);
var mockMetricHandler = new Mock <IMetricHandler>();
_controller = new WebApiController(mockContextFactory.Object, mockMetricHandler.Object);
_controller.Request = new HttpRequestMessage();
_controller.Configuration = new HttpConfiguration();
}
/// <summary>
/// Atualiza os dados pel Web Api
/// Ou Joga os dados para a tela
/// Apenas o status que altera
/// </summary>
/// <param name="sender">object</param>
/// <param name="e">GridViewCommandEventArgs</param>
protected void grdToDo_RowCommand(object sender, GridViewCommandEventArgs e)
{
//clicar no botão feito (já foi realizado essa atividade)
if (e.CommandName == "Feito")
{
int index = int.Parse((string)e.CommandArgument);
string chave = grdToDo.DataKeys[index]?["IdToDo"].ToString();
//preenche os dados
var atividades = new AtividadesToDo()
{
NomeTodo = HtmlToText.StripHtml(grdToDo.Rows[index].Cells[1].Text),
CompletoTodo = 1,
IdTodo = int.Parse(chave)
};
//atualiza os dados preenchidos da classe Atividades no Web Api
HttpResponseMessage response = WebApiController.AtualizarDadosWebApi(chave, atividades);
if (!response.IsSuccessStatusCode)
{
Response.Write(response.StatusCode + " - " + response.ReasonPhrase);
}
else
{
Response.Redirect("Default?guid=" + Guid.NewGuid() + "&id=AtualizadoSucesso");
}
}
//click no botão editar dentro do grid
else if (e.CommandName == "Editar")
{
int index = int.Parse((string)e.CommandArgument);
string chave = grdToDo.DataKeys[index]?["IdToDo"].ToString();
if (chave != null)
{
hdIdToDo.Value = chave;
}
txtTituloToDo.Text = HtmlToText.StripHtml(grdToDo.Rows[index].Cells[1].Text);
btnEditar.Visible = true;
btnEnviar.Visible = false;
}
}
public void WithResponseModelShouldNotThrowExceptionWithCorrectPassedExpectedObject()
{
var controller = new WebApiController();
MyWebApi
.Controller(() => controller)
.Calling(c => c.OkResultWithInterfaceResponse())
.ShouldReturn()
.Ok()
.WithResponseModel(controller.ResponseModel);
}
