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