public async Task HandleExtraSpacesBetweenKeywordAndNumber() { var mockRequest = new Mock <HttpRequest>(); var mockLogger = new Mock <ILogger>(); var mockFileWrapper = new Mock <IHelpers>(); var assembly = Assembly.LoadFrom("CalculatorFunction"); mockFileWrapper.Setup(m => m.LoadInstructionsfromFile(assembly, "CalculatorFunction.Instructions.txt")).Returns("add 10\r\nmultiply 2\r\nsubtract 5\r\napply 2"); var function = new CalculatorFunction.CalculatorFunction(mockFileWrapper.Object); var result = await function.Calculator(mockRequest.Object, mockLogger.Object); var request = new CalculatorResponse { Result = 19 }; var objectResult = result as ObjectResult; var value = objectResult.Value as CalculatorResponse; Xunit.Assert.Equal(value.Result, request.Result); Xunit.Assert.Equal(200, objectResult?.StatusCode.Value); }
/// <summary> /// Calculates the batch of expressions. /// </summary> /// <param name="expressions"></param> /// <returns>Calculated expressions</returns> public (string, IEnumerable <CalculatorResponse>) CalculateBatchExpressions(IEnumerable <string> expressions) { string errorMessage = null; if (expressions.Count() == 0) { errorMessage = "Expressions list is empty"; return(errorMessage, null); } List <CalculatorResponse> result = new List <CalculatorResponse>(); foreach (string expression in expressions) { (string error, double value) = CalculateExpression(expression); if (error != null) { errorMessage = "Wrong expression was found"; } var response = new CalculatorResponse { Value = value, Error = error }; result.Add(response); } return(errorMessage, result); }
public async Task <IActionResult> Calculator([HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req, ILogger log) { try { var calculatorInstructions = _functionHelpers.LoadInstructionsfromFile(Assembly.GetExecutingAssembly(), "CalculatorFunction.Instructions.txt"); if (string.IsNullOrEmpty(calculatorInstructions)) { log.LogError("Instruction file is either not found or is empty."); return(new BadRequestObjectResult("Instruction File is empty or not found.")); } var instructionList = Instructions.GetInstructionList(calculatorInstructions); var result = float.Parse(instructionList.Where(x => x.Keyword == "apply").FirstOrDefault()?.Number); foreach (var instruct in instructionList) { switch (instruct.Keyword.ToLower()) { case "add": result += float.Parse(instruct.Number); break; case "subtract": result -= float.Parse(instruct.Number); break; case "multiply": result *= float.Parse(instruct.Number); break; case "divide": result /= float.Parse(instruct.Number); break; case "apply": break; default: log.LogError($"keyword is not valid {instruct.Keyword}"); return(new BadRequestObjectResult("Keyword in instruction file is not valid.")); } } CalculatorResponse response = new CalculatorResponse() { Result = result }; log.LogInformation($"Result Calculated {result}"); return(new OkObjectResult(response)); } catch (Exception ex) { log.LogError($"An error has occured {ex.Message}"); return(new BadRequestObjectResult("An error has occurred.")); } }
public CalculatorResponse Handle() { var values = _input.Split(','); var numbers = new List <double>(); var result = double.NaN; CalculatorResponse response; try { if (values.Length <= 1) { return(response = new CalculatorResponse { Status = "Error", Message = "Input 2 or more numbers for division", }); } foreach (var value in values) { numbers.Add(double.Parse(value.Trim())); } if (numbers != null) { var calc = new CalculatorCore(); if (numbers.Any(n => n == 0)) { return response = new CalculatorResponse { Status = "Error", Message = "Division by Zero not allowed.", } } ; result = calc.Divide(numbers.ToArray()); } return(response = new CalculatorResponse { _Result = result, Status = "Success" }); } catch (Exception ex) { _logger.LogError($"Invalid input : {ex.StackTrace}"); return(new CalculatorResponse { Status = "Error", Message = ($"Invalid input : {ex.Message}") }); } }
public CalculatorResponse MakePostRequest(DivisionRequest divisionRequest) { string url = "http://api.mathjs.org/v4/"; string json = JsonConvert.SerializeObject(divisionRequest); var data = new StringContent(json, Encoding.UTF8, "application/json"); var client = new HttpClient(); var response = client.PostAsync(url, data).Result; string result = response.Content.ReadAsStringAsync().Result; CalculatorResponse calculatorResponse = JsonConvert.DeserializeObject <CalculatorResponse>(result); return(calculatorResponse); }
public void DigitsDivision_DigitsFromFile_ResultsMatchToValidationFile() { foreach (var testData in _testData) { var divisionRequest = new DivisionRequest { Expr = new List <string> { $"{testData.FirstExpression}/{testData.SecondExpression}" } }; CalculatorResponse divisionResult = _mathjsProxy.MakePostRequest(divisionRequest); Assert.AreEqual(testData.IsToFail, divisionResult.HasFailed); Assert.AreEqual(testData.ExpectedResult, divisionResult.Result?.First()); } }
public async Task DivideStrategy_Success_Handled() { List <double> inputs = new List <double> { 1, 2, 3 }; CalculatorResponse expectedResponse = new CalculatorResponse(); expectedResponse.SetResult(0.16666, true, 200, new List <string>()); var computeResolver = new Mock <IComputeResolver>(); computeResolver.Setup(cr => cr.Compute(inputs)).ReturnsAsync(0.16666); ICalculatorService calculator = new CalculatorService(computeResolver.Object); var result = await calculator.Add(inputs); expectedResponse.Should().BeEquivalentTo(result); }
public ActionResult <Adder> Post([FromBody] CalculatorRequest calculatorRequest) { CalculatorOperatorBase calculator; switch (calculatorRequest.CalculatorOperatorType) { case CalculatorOperatorTypeEnum.Adder: { calculator = new Adder(calculatorRequest.LeftVal, calculatorRequest.RightVal); break; } case CalculatorOperatorTypeEnum.Substracter: { calculator = new Substracter(calculatorRequest.LeftVal, calculatorRequest.RightVal); break; } case CalculatorOperatorTypeEnum.Multiplier: { calculator = new Multiplier(calculatorRequest.LeftVal, calculatorRequest.RightVal); break; } case CalculatorOperatorTypeEnum.Divider: { calculator = new Divider(calculatorRequest.LeftVal, calculatorRequest.RightVal); break; } default: { return(BadRequest("Invalid CalculatorOperatorType")); } } calculator.Calculate(); var calculatorResponse = new CalculatorResponse { Result = calculator.Result }; return(Ok(calculatorResponse)); }
public async Task MultiplyStrategy_Failure_Handled() { List <double> inputs = new List <double> { 1, 2, 3 }; CalculatorResponse expectedResponse = new CalculatorResponse(); expectedResponse.SetResult(double.NaN, false, 500, new List <string>() { Resources.GenericException }); var computeResolver = new Mock <IComputeResolver>(); computeResolver.Setup(cr => cr.Compute(inputs)).ThrowsAsync(new Exception(Resources.GenericException)); ICalculatorService calculator = new CalculatorService(computeResolver.Object); var result = await calculator.Add(inputs); expectedResponse.Should().BeEquivalentTo(result); }
public async Task <CalculatorResponse> Divide(List <double> inputs) { CalculatorResponse response = new CalculatorResponse(); try { _computeResolver.SetComputeStrategy(new DivideStrategy()); double result = await _computeResolver.Compute(inputs); response.SetResult(result, true, 200, new List <string>()); } catch (CalculatorException ex) { // the response code is 200 as this is a handled operation even if there was an exception response.SetResult(double.NaN, false, 200, new List <string>(new string[] { ex.Message })); } catch { // the response code is 500 as this is an unhandled exception which is generic response.SetResult(double.NaN, false, 500, new List <string>(new string[] { Resources.GenericException })); } return(response); }
public async Task ResultAsExpected() { var mockRequest = new Mock <HttpRequest>(); var mockLogger = new Mock <ILogger>(); var mockFileWrapper = new Mock <IHelpers>(); var assembly = Assembly.LoadFrom("CalculatorFunction"); mockFileWrapper.Setup(m => m.LoadInstructionsfromFile(assembly, "CalculatorFunction.Instructions.txt")).Returns("add 2\r\nmultiply 3\r\napply 3"); var function = new CalculatorFunction.CalculatorFunction(mockFileWrapper.Object); var result = await function.Calculator(mockRequest.Object, mockLogger.Object); var request = new CalculatorResponse { Result = 15 }; var objectResult = result as ObjectResult; var value = objectResult.Value as CalculatorResponse; Xunit.Assert.Equal(value.Result, request.Result); }
async Task <CalculatorResponse> CalculateAsync(CalculatorRequest request) { // Do async requests for the data var validationResult = this.Validate(request); if (!validationResult.IsValid) { await _logServiceClient.PostAsync(new LogRequest { Message = $"Failed to Calculate for {request.SupplyPoint}-{request.Date}" }); return(new CalculatorResponse { Success = false, Errors = validationResult.FormattedErrors }); } var taskResult = GetTheDataToMakeCalculationsAsync(request); var result = new CalculatorResponse { Success = true, Reply = HttpStatusCode.OK }; await _logServiceClient.PostAsync(new LogRequest { Message = $"Calculation complete for: {request.SupplyPoint}-{request.MarketParticipantId}-{request.LLF}-{request.Date}" }); return(result); }
public CalculatorResponse Calculate(string input, string operatorChar) { var response = new CalculatorResponse { Success = true }; try { if (input == null) { throw new Exception("Null Input"); } var tokens = Tokenize(input); if (tokens.Any(t => t.Errored)) { response.Success = false; var invalidTokens = tokens.Where(t => t.Errored).Select(t => t.Token); var invalidTokenString = string.Join(", ", invalidTokens); throw new Exception(string.Format("The following inputs were rejected: {0}", invalidTokenString)); } decimal result = 0; if (tokens.Any()) { switch (operatorChar) { case "+": { result = tokens.Sum(t => t.Value); break; } case "-": { result = tokens.First().Value; var otherTokens = tokens.Skip(1); foreach (var t in otherTokens) { result -= t.Value; } break; } case "*": { result = tokens.First().Value; var otherTokens = tokens.Skip(1); foreach (var t in otherTokens) { result *= t.Value; } break; } case "/": { result = tokens.First().Value; var otherTokens = tokens.Skip(1); foreach (var t in otherTokens) { result /= t.Value; } break; } } } response.Value = result; response.Formula = Formula(tokens, operatorChar, result); } catch (Exception ex) { response.Success = false; response.Message = ex.Message; } return(response); }