public async Task <Transaction> GetTransactionFromNodeAsync(string transactionHash) { var body = new Models.Node.JsonRpcBody("eth_getTransactionByHash", 1); body.AddParam(transactionHash); var client = new RestClient(GetNodeUrl()); var request = new RestRequest(Method.POST); request.AddParameter("application/json; charset=utf-8", Newtonsoft.Json.JsonConvert.SerializeObject(body), ParameterType.RequestBody); request.RequestFormat = DataFormat.Json; var cancellationTokenSource = new CancellationTokenSource(); var restResponse = await client.ExecuteTaskAsync(request, cancellationTokenSource.Token); if (restResponse.StatusCode == HttpStatusCode.OK) { var response = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.Node.GetTransactionResponse>(restResponse.Content); return(response.result != null?ConversionService.Convert(response.result) : null); } else { if (string.IsNullOrEmpty(restResponse.Content)) { throw new Exception($"Error posting to node: {restResponse.ErrorException}"); } else { throw new Exception($"Error posting to node: {restResponse.Content}"); } } }
public async Task <IActionResult> OnPost() { try { var unparsedTableauInput = FormResolver.ResolveForm(HttpContext.Request.Form); var(tableauInput, errorForm) = ConversionService.ParseTableauInput(unparsedTableauInput); if (errorForm.HasErrorResponse()) { ErrorResponseForm = errorForm; return(Page()); } var tableauSolution = TableauSolutionService.ComputeTableauSolution(tableauInput); EventService.LogTableauSolution(tableauSolution); var userRequest = new AppSolutionRequest() { TableauType = TableauSolutionCategorizer.CategorizeTableauSolution(tableauSolution.SolutionNode), ExpectedTableauType = unparsedTableauInput.ExpectedTableauType, SolutionId = tableauSolution.SolutionId }; HttpContext.Session.SetString(SolutionName, JsonConvert.SerializeObject(tableauSolution)); HttpContext.Session.SetString(RequestName, JsonConvert.SerializeObject(userRequest)); await EventService.CreateAppSolutionRequest(userRequest, HttpContext.User); return(RedirectToPage("SolutionView", new { isSession = true, solutionViewType = SolutionViewType.Text })); } catch (FormResolverException) { return(RedirectToPage("../Error")); } }
public async Task <Models.DTOs.Block> GetBlockFromNodeAsync(ulong blockNumber) { var body = new Models.Node.JsonRpcBody("eth_getBlockByNumber", 1); body.AddParam(blockNumber.ToHexString()); body.AddParam(true); var client = new RestClient(GetNodeUrl()); var request = new RestRequest(Method.POST); request.AddParameter("application/json; charset=utf-8", JsonConvert.SerializeObject(body), ParameterType.RequestBody); request.RequestFormat = DataFormat.Json; var cancellationTokenSource = new CancellationTokenSource(); var restResponse = await client.ExecuteTaskAsync(request, cancellationTokenSource.Token); if (restResponse.StatusCode == HttpStatusCode.OK) { var response = JsonConvert.DeserializeObject <Models.Node.GetBlockResponse>(restResponse.Content); return(ConversionService.Convert(response.result)); } else { if (string.IsNullOrEmpty(restResponse.Content)) { throw new Exception($"Error posting to node: {restResponse.ErrorException}"); } else { throw new Exception($"Error posting to node: {restResponse.Content}"); } } }
public void TestConversionServiceErroneousResponseFromDataService() { ConversionService serv = new ConversionService(); using (Microsoft.QualityTools.Testing.Fakes.ShimsContext.Create()) { PdfConversion.Server.DataService.Fakes.ShimFileStatusRepositoryFactory.GetRepository = () => { var shim = new PdfConversion.Server.DataService.Fakes.StubIRepository<FileStatusEntity>(); shim.SaveChanges = () => { }; shim.SearchForExpressionOfFuncOfT0Boolean = a => { var ls = new List<FileStatusEntity>(); var entity = new FileStatusEntity(); entity.FileState = FileState.Erroneous; ls.Add(entity); return ls.AsQueryable<FileStatusEntity>(); }; return shim; }; var status = serv.GetFileState("test"); Assert.IsTrue(status == PdfConversionService.API.FileState.Erroneous); } }
public static ulong EnumToUInt64(object value) { if (value == null) { throw new ArgumentNullException("value"); } TypeCode typeCode = Convert.GetTypeCode(value); switch (typeCode) { case TypeCode.SByte: case TypeCode.Int16: case TypeCode.Int32: case TypeCode.Int64: return((ulong)Convert.ToInt64(value, CultureInfo.InvariantCulture)); case TypeCode.Byte: case TypeCode.UInt16: case TypeCode.UInt32: case TypeCode.UInt64: return(Convert.ToUInt64(value, CultureInfo.InvariantCulture)); //case TypeCode.String: default: return(ConversionService.ChangeType <ulong>(value)); } }
private void btnSelecionarCsv_Click(object sender, EventArgs e) { try { using (OpenFileDialog caminhoDialogo = new OpenFileDialog() { Filter = "CSV|*.csv", ValidateNames = true, Multiselect = true }) { if (caminhoDialogo.ShowDialog() == DialogResult.OK) { foreach (String arquivo in caminhoDialogo.FileNames) { DataTable original = ConversionService.csv2datatable(arquivo); CSV csv = CSVService.gerarcsv(original, arquivo); string caminho = CAMINHO_SALVAR + verificarNome(csv.nomeEmpresa) + ".xlsx"; ConversionService.datatable2xls(csv.csvFinal, caminho); ExcelFunctionalService.criarModelo(caminho, csv); } MessageBox.Show("Processo finalizado com sucesso!", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information); } } } catch (Exception ex) { MessageBox.Show(ex.Message, "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public void ExtractFolder(string extractionPath, IVirtualFolder folder) { var saveService = new VirtualFileSaveService(); var extractor = new VirtualFileExtractionService(); var thisFolderPath = saveService.SaveFolder(extractionPath, folder.Name); foreach (var file in folder.Files) { WriteToConsole(Color.LightBlue, "Extracting " + file.Name); var fileData = extractor.GetDataForVirtualFile(file); var savefileType = file.FileData.Type; if (file.FileData.Type == FileType.Zap) { fileData = ConversionService.ConvertFromZapToJpg(fileData); savefileType = FileType.Jpg; } saveService.SaveFile(thisFolderPath, file.Name, savefileType, fileData); } foreach (var subFolder in folder.SubFolders) { ExtractFolder(thisFolderPath, subFolder); } }
/// <summary> /// Algoritmas leidžiantis surasti binarinius vektorius surikiuotas nuo mažiausio iki didžiausio. /// </summary> /// <param name="length"></param> /// <returns>Sąrašas binarinių vektorių</returns> public static List <int[]> GenerateOrderedBinaryVectors(int length) { var ordered = new List <int[]>(); var combinations = Math.Pow(2, length); if (combinations == 1) { return(new List <int[]>()); } for (var i = 0; i < combinations; i++) { var binaryString = Convert.ToString(i, 2).PadLeft(length, '0'); var binaryStringArr = ConversionService.ConvertBinaryStringToVector(binaryString); ordered.Add(binaryStringArr); // comb = 4 // 000 // 001 // 010 // 011 // 100 } return(ordered); }
public ConversionServiceTests() { _mockLogger = new Mock <ILogger <ConversionService> >(); _service = new ConversionService( _mockLogger.Object ); }
public TableauSolutionModel( ConversionService conversionService, EventService eventService, TableauSolutionService tableauSolutionService) { ConversionService = conversionService; EventService = eventService; TableauSolutionService = tableauSolutionService; }
/// <summary> /// Paveikslėlio apdorojimas /// </summary> /// <param name="r"></param> /// <param name="m"></param> /// <param name="q"></param> /// <param name="matrix"></param> /// <param name="expectedLength"></param> /// <returns></returns> private static async Task HandlePicture(int r, int m, double q, Matrix matrix, int expectedLength) { Console.WriteLine("Select available photos. 0 - bird, 1 - fire, 2 - robot"); var selectedPhoto = Console.ReadLine(); AvailablePhoto photo; while (!Enum.TryParse(selectedPhoto, out photo) || !Enum.IsDefined(typeof(AvailablePhoto), photo)) { Console.WriteLine($"'{selectedPhoto}' is not a valid input. Please enter number between 0 and 2."); selectedPhoto = Console.ReadLine(); } var basePath = Path.Combine(Environment.CurrentDirectory, "Resources"); var filepath = Path.Combine(basePath, $"{photo}.bmp"); if (!File.Exists(filepath)) { Console.WriteLine("File does not exist."); return; } // Paveikslėlio skaitymas ir konvertavimas į baitų masyvą. var(pictureHeader, pictureBody) = await PictureHelper.ReadBmpImageAsync(filepath); var(initialVectors, addedBits) = ConversionService.ConvertByteArrayToVectors(pictureBody, expectedLength); // Vektorių kodavimas var encodedVectors = new List <int[]>(); initialVectors.ForEach(x => encodedVectors.Add(Encoder.EncodeVector(x, matrix))); // Siuntimas kanalu var distortedVectors = new List <int[]>(); var distortedPlainVectors = new List <int[]>(); encodedVectors.SkipLast(1).ToList().ForEach(x => distortedVectors.Add(Channel.Send(x, q))); distortedVectors.Add(Channel.Send(encodedVectors.Last(), q, addedBits)); initialVectors.ForEach(x => distortedPlainVectors.Add(Channel.Send(x, q))); // Vektorių dekodavimas var decodedVectors = new List <int[]>(); distortedVectors.ForEach(x => decodedVectors.Add(Decoder.DecodeVector(x, matrix, m, r))); var decodedByteArr = ConversionService.ConvertVectorsToByteArray(decodedVectors, addedBits); var plainByteArr = ConversionService.ConvertVectorsToByteArray(distortedPlainVectors, addedBits); // Paveikslėlių išsaugojimas. var task1 = PictureHelper.WriteBmpImageAsync(basePath, pictureHeader, decodedByteArr); var task2 = PictureHelper.WriteBmpImageAsync(basePath, pictureHeader, plainByteArr, false); Task.WaitAll(task1, task2); filepath = Path.GetFullPath(basePath); System.Diagnostics.Process.Start("explorer.exe", filepath); }
public void FormulaParserUnknownExceptionThrowsConversionException() { var formulaParser = new Mock <IFormulaFactory>(); formulaParser.Setup(t => t.Parse(It.IsAny <string>())).Throws(new NullReferenceException()); var conversionService = new ConversionService(formulaParser.Object); conversionService.ParseTableauInput(_inputSingleFormula); }
public void ParseTableauInputThrowsOnEmptyUnparsedInput() { var formulaParser = new Mock <IFormulaFactory>(); formulaParser.Setup(t => t.Parse(It.IsAny <string>())).Returns(new VariableFormula('m')); var conversionService = new ConversionService(formulaParser.Object); conversionService.ParseTableauInput(new UnparsedTableauInput()); }
public PollingHostedService(ILogger <PollingHostedService> logger, ILupusecService lupusecService, IConfiguration configuration) { _logger = logger; _lupusecService = lupusecService; _configuration = configuration; _conversionService = new ConversionService(_configuration, logger); _mqttService = new MqttService(_configuration); _cancellationTokenSource = new CancellationTokenSource(); }
public void CreatesErrorResponseOnParserException() { var formulaParser = new Mock <IFormulaFactory>(); formulaParser.Setup(t => t.Parse(It.IsAny <string>())).Throws(new ParseException("...")); var conversionService = new ConversionService(formulaParser.Object); var(tableauInput, errorResponse) = conversionService.ParseTableauInput(_inputSingleFormula); Assert.IsTrue(errorResponse.HasErrorResponse()); Assert.IsTrue(errorResponse.FormulaParseRequests.Count == 1); }
public void DecodesCorrectly(int m, int r, string encodedVector, string expectedDecodedVector) { // Arrange. var generatorMatrix = MatrixHelper.CreateGeneratorMatrix(m, r); var initialVector = ConversionService.ConvertBinaryStringToVector(encodedVector); // Act. var decoded = Decoder.DecodeVector(initialVector, generatorMatrix, m, r); var actualDecodedVector = string.Join("", decoded); // Assert. Assert.AreEqual(expectedDecodedVector, actualDecodedVector); }
public static List <T> SplitToList <T>(this string thisString, params char[] separators) { var list = new List <T>(); if (thisString != null) { foreach (string s in thisString.Split(separators)) { T item = ConversionService.ChangeType <T>(s); list.Add(item); } } return(list); }
public void DuplicitRawFormulasAllowed() { var formulaParser = new Mock <IFormulaFactory>(); formulaParser.SetupSequence(t => t.Parse(It.IsAny <string>())) .Returns(new VariableFormula('n')) .Returns(new VariableFormula('n')); var conversionService = new ConversionService(formulaParser.Object); var(tableauInput, errorResponse) = conversionService.ParseTableauInput(_inputDuplicitFormulas); formulaParser.Verify(f => f.Parse(It.IsAny <string>()), Times.Exactly(2)); }
public void ShouldFindError() { var formulaParser = new Mock <IFormulaFactory>(); formulaParser.SetupSequence(t => t.Parse(It.IsAny <string>())) .Returns(new VariableFormula('n')) .Throws(new ParseException("...")); var conversionService = new ConversionService(formulaParser.Object); var(tableauInput, errorResponse) = conversionService.ParseTableauInput(_inputTwoFormulas); Assert.IsTrue(errorResponse.HasErrorResponse()); Assert.IsTrue(errorResponse.FormulaParseRequests.Count == 2); }
/// <summary> /// Does the glyph painting. /// </summary> /// <param name="pe"></param> /// <returns></returns> protected sealed override bool OnItemPaint(PaintEventArgs pe) { if (pe.ClipRectangle.Width <= 0 || pe.ClipRectangle.Height <= 0) { return(false); } GraphicsState state = pe.Graphics.Save(); try { // clear own bound rectangle pe.Graphics.SetClip(pe.ClipRectangle, CombineMode.Intersect); // add gaps to avoid artifacts on left and bottom borders due to clipping const int SideGap = 1; Rectangle bounds = pe.ClipRectangle; bounds.Width -= SideGap; bounds.Height -= SideGap; bounds = ConversionService.ReverseScale(bounds); if (bounds.Width <= 0 || bounds.Height <= 0) { return(false); } //Case 36389: In some cases, the appointment text was not displaying underlined when it should have been. Work around is to // use the graphics of a bitmap and then draw the bitmap to the original designers graphics. using (Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height)) { using (Graphics graphics = Graphics.FromImage(bitmap)) { //Offset the graphics to compensate for the clip bounds if they are not (0,0). graphics.TranslateTransform( -RenderUtils.ConvertPixelsToTwips(bounds.Left, pe.Graphics.DpiX), -RenderUtils.ConvertPixelsToTwips(bounds.Top, pe.Graphics.DpiY)); DrawGlyph(graphics, bounds); } float scaleFactor = ConversionService.ScalingFactor; pe.Graphics.ScaleTransform(scaleFactor, scaleFactor); pe.Graphics.DrawImageUnscaled(bitmap, bounds); } } finally { pe.Graphics.Restore(state); } return(true); }
/// <summary> /// Gets a typed property value. /// </summary> /// <typeparam name="T">The expected type.</typeparam> /// <param name="name">The property name.</param> /// <param name="defaultValue">The default value if the property value is not defined.</param> /// <returns>The property value or the default value.</returns> public virtual T GetPropertyValue <T>(string name, T defaultValue) { if (name == null) { throw new ArgumentNullException("name"); } object obj; if (_values.TryGetValue(name, out obj)) { return(ConversionService.ChangeType(obj, defaultValue)); } return(defaultValue); }
public void ExtractFiles(string extractionPath, List <IVirtualFileEntry> files) { var saveService = new VirtualFileSaveService(); var extractor = new VirtualFileExtractionService(); foreach (var file in files) { WriteToConsole(Color.LightBlue, "Extracting " + file.Name); var fileData = extractor.GetDataForVirtualFile(file); var savefileType = file.FileData.Type; if (file.FileData.Type == FileType.Zap) { fileData = ConversionService.ConvertFromZapToJpg(fileData); savefileType = FileType.Jpg; } saveService.SaveFile(extractionPath, file.Name, savefileType, fileData); } }
private void StartWatchCommandExecute(object obj) { var node = obj as DirectoryModel; this.ReinitializeToken(); Task.Run(async() => { while (true) { if (Token.IsCancellationRequested) { return; } if (!DirectoryService.CheckDirectory(node.FullName)) { if (Messenger.Go("Root folder was changed or deleted, clear the tree to load a new directory?", "Directory not found", MessageBoxButton.OKCancel, MessageBoxImage.Question, MessageBoxResult.OK) == MessageBoxResult.OK) { Application.Current.Dispatcher.Invoke(() => Directory = null); base.OnPropertyChanged(nameof(SelfDirectory)); LoadFlag = true; WatcherFlag = false; } else { Messenger.Go("чтобы загрузить новую директория - очистите дерево", "Message"); } return; } var transfer_directory = await DirectoryService.GetDirectory(node.FullName); var model_directory = await ConversionService.ConvertToModel(transfer_directory); Application.Current.Dispatcher.Invoke(() => Watcher.Check(node, model_directory)); } }, Token); }
public async Task Convert_should_return_problem_details_when_rate_service_returns_problem_details() { const int code = 499; const string details = "Error message"; var rateServiceMock = new Mock <IRateService>(); rateServiceMock.Setup(m => m.Get(It.IsAny <Currencies>(), It.IsAny <Currencies>())) .ReturnsAsync(Result.Failure <decimal, ProblemDetails>(new ProblemDetails { Detail = details, Status = code })); var service = new ConversionService(new NullLoggerFactory(), rateServiceMock.Object, _fixture.Factory); var(_, isFailure, _, error) = await service.Convert(Currencies.USD, Currencies.AED, _values); Assert.True(isFailure); Assert.Equal(code, error.Status); Assert.Equal(details, error.Detail); }
public void TestConversionServiceExceptionResponseFromDataService() { ConversionService serv = new ConversionService(); using (Microsoft.QualityTools.Testing.Fakes.ShimsContext.Create()) { PdfConversion.Server.DataService.Fakes.ShimFileStatusRepositoryFactory.GetRepository = () => { var shim = new PdfConversion.Server.DataService.Fakes.StubIRepository<FileStatusEntity>(); //override saveChanges with NO-OP to protect the database; shim.SaveChanges = () => { }; shim.SearchForExpressionOfFuncOfT0Boolean = a => { throw new Exception(); }; return shim; }; var status = serv.GetFileState("test"); Assert.IsTrue(status == PdfConversionService.API.FileState.Missing); } }
public void ConvertCorrectly(string fromName, string toName, decimal amount, decimal rate) { //Arrange var mockCurrencySet = new Mock <DbSet <Currency> >(); mockCurrencySet.As <IQueryable <Currency> >().Setup(m => m.Provider).Returns(Currencies.Provider); mockCurrencySet.As <IQueryable <Currency> >().Setup(m => m.Expression).Returns(Currencies.Expression); mockCurrencySet.As <IQueryable <Currency> >().Setup(m => m.ElementType).Returns(Currencies.ElementType); mockCurrencySet.As <IQueryable <Currency> >().Setup(m => m.GetEnumerator()).Returns(Currencies.GetEnumerator()); var mockConversionSet = new Mock <DbSet <Conversion> >(); mockConversionSet.As <IQueryable <Conversion> >().Setup(m => m.Provider).Returns(Conversions.Provider); mockConversionSet.As <IQueryable <Conversion> >().Setup(m => m.Expression).Returns(Conversions.Expression); mockConversionSet.As <IQueryable <Conversion> >().Setup(m => m.ElementType).Returns(Conversions.ElementType); mockConversionSet.As <IQueryable <Conversion> >().Setup(m => m.GetEnumerator()).Returns(Conversions.GetEnumerator()); var mockLogger = new Mock <ILogger <BaseService> >(); var mockContext = new Mock <MainDbContext>(); mockContext.Setup(c => c.Currencies).Returns(mockCurrencySet.Object); mockContext.Setup(c => c.Conversions).Returns(mockConversionSet.Object); var mockConversionService = new Mock <IConversionAuditService>(); var from = Currencies.Single(x => x.Name == fromName); var to = Currencies.Single(x => x.Name == toName); var expected = amount * rate; //Act var sut = new ConversionService(mockContext.Object, mockConversionService.Object, mockLogger.Object); var actual = sut.Convert(from, to, amount).Result; //Assert //When this method was created it threw a not implemented exception //Red Assert Assert.That(() => sut.Convert(Currencies[0], Currencies[3]), Throws.Exception.TypeOf<NotImplementedException>()); Assert.AreEqual(actual, expected); }
public async Task <List <Transaction> > GetPendingTransactionsFromNodeAsync() { var body = new Models.Node.JsonRpcBody("eth_getBlockByNumber", 1); body.AddParam("pending"); body.AddParam(true); var client = new RestClient(GetNodeUrl()); var request = new RestRequest(Method.POST); request.AddParameter("application/json; charset=utf-8", Newtonsoft.Json.JsonConvert.SerializeObject(body), ParameterType.RequestBody); request.RequestFormat = DataFormat.Json; var cancellationTokenSource = new CancellationTokenSource(); var restResponse = await client.ExecuteTaskAsync(request, cancellationTokenSource.Token); if (restResponse.StatusCode == HttpStatusCode.OK) { var response = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.Node.GetBlockResponse>(restResponse.Content); var transactions = new List <Transaction>(); if (response.result != null) { foreach (var transaction in response.result.transactions) { transactions.Add(ConversionService.Convert(transaction)); } } return(transactions); } else { if (string.IsNullOrEmpty(restResponse.Content)) { throw new Exception($"Error posting to node: {restResponse.ErrorException}"); } else { throw new Exception($"Error posting to node: {restResponse.Content}"); } } }
/// <summary> /// Teksto apdorojimas /// </summary> /// <param name="r"></param> /// <param name="m"></param> /// <param name="q"></param> /// <param name="matrix"></param> /// <param name="expectedLength"></param> private static void HandleText(int r, int m, double q, Matrix matrix, int expectedLength) { Console.WriteLine("Please enter your text"); var text = Console.ReadLine(); Console.WriteLine("Initial text: ".PadRight(20) + text); // Teksto konvertavimas į baitų masyvą. var byteArray = Encoding.GetBytes(text); var(initialVectors, addedBits) = ConversionService.ConvertByteArrayToVectors(byteArray, expectedLength); // Vektorių kodavimas var encodedVectors = new List <int[]>(); initialVectors.ForEach(x => encodedVectors.Add(Encoder.EncodeVector(x, matrix))); // Siuntimas kanalu var distortedVectors = new List <int[]>(); var distortedPlainVectors = new List <int[]>(); encodedVectors.SkipLast(1).ToList().ForEach(x => distortedVectors.Add(Channel.Send(x, q))); distortedVectors.Add(Channel.Send(encodedVectors.Last(), q, addedBits)); initialVectors.ForEach(x => distortedPlainVectors.Add(Channel.Send(x, q))); // Vektorių dekodavimas var decodedVectors = new List <int[]>(); distortedVectors.ForEach(x => decodedVectors.Add(Decoder.DecodeVector(x, matrix, m, r))); var decodedText = Encoding.GetString(ConversionService.ConvertVectorsToByteArray(decodedVectors, addedBits)); var decodedTextWithoutEncoding = Encoding.GetString(ConversionService.ConvertVectorsToByteArray(distortedPlainVectors, addedBits)); // Replacing carriage return and new line char. decodedText = decodedText.Replace('\r', 'r'); decodedText = decodedText.Replace('\n', 'n'); decodedTextWithoutEncoding = decodedTextWithoutEncoding.Replace('\r', 'r'); decodedTextWithoutEncoding = decodedTextWithoutEncoding.Replace('\n', 'n'); Console.WriteLine("Without encoding: ".PadRight(20) + decodedTextWithoutEncoding); Console.WriteLine("Decoded text: ".PadRight(20) + decodedText); }
public async Task Convert_should_return_initial_values_when_source_and_target_currencies_are_the_same() { var rateServiceMock = new Mock <IRateService>(); rateServiceMock.Setup(s => s.Get(It.IsAny <Currencies>(), It.IsAny <Currencies>())) .ReturnsAsync(Result.Success <decimal, ProblemDetails>(1)); var service = new ConversionService(new NullLoggerFactory(), rateServiceMock.Object, _fixture.Factory); var(isSuccess, _, values, _) = await service.Convert(Currencies.USD, Currencies.USD, _values); Assert.True(isSuccess); Assert.Equal(_values.Count, values.Count); Assert.All(values, pair => { var(k, v) = pair; Assert.Equal(k, v); Assert.Contains(k.Amount, _values); }); }
public void Should_conversion_EUR_USD_49_fail_with_not_connected_currencies() { // ARRANGE List <ExchangeRate> exchangeRates = ConversionServiceFake.ExchangeRatesNotConnected; var conversionRequest = new ConversionRequest("USD", "UAH", 1); var mock = new Mock <IShortestPathService>(); mock.Setup(m => m.Get(It.IsAny <ConversionRequest>(), It.IsAny <IEnumerable <ExchangeRate> >())) .Returns(new ShortestPathResult(false, null)); var svc = new ConversionService(mock.Object); // ACT var result = svc.Convert(conversionRequest, exchangeRates); // ASSERT result.IsSuccess.Should().BeFalse(); result.Amount.Should().BeNull(); result.ErrorMessage.Should().Be(ConversionErrorMessage.NoPath); }
public async Task Convert_should_return_values_when_source_and_rate_service_returns_rates() { const decimal rate = 100m; var rateServiceMock = new Mock <IRateService>(); rateServiceMock.Setup(m => m.Get(It.IsAny <Currencies>(), It.IsAny <Currencies>())) .ReturnsAsync(Result.Success <decimal, ProblemDetails>(rate)); var service = new ConversionService(new NullLoggerFactory(), rateServiceMock.Object, _fixture.Factory); var(isSuccess, _, values, _) = await service.Convert(Currencies.USD, Currencies.AED, _values); Assert.True(isSuccess); Assert.Equal(_values.Count, values.Count); Assert.All(values, pair => { var(k, v) = pair; Assert.Equal(k.Amount * rate, v.Amount); Assert.Contains(k.Amount, _values); }); }
public void ParserCorrectlyToTableauInput() { var formulaParser = new Mock <IFormulaFactory>(); formulaParser.SetupSequence(t => t.Parse(It.IsAny <string>())) .Returns(new VariableFormula('a')) .Returns(new VariableFormula('b')); var conversionService = new ConversionService(formulaParser.Object); var(tableauInput, errorResponse) = conversionService.ParseTableauInput(_inputTwoFormulas); formulaParser.Verify(f => f.Parse(It.IsAny <string>()), Times.Exactly(2)); Assert.AreEqual(new VariableFormula('a'), tableauInput.TableauRoot.Formula); Assert.AreEqual(new VariableFormula('b'), tableauInput.TheoryAxioms[0].Formula); Assert.AreEqual(tableauInput.TableauRoot.TruthLabel, _inputTwoFormulas.FormulaParseRequests[0].UnparsedTableauNode.TruthLabel); Assert.AreEqual(tableauInput.TheoryAxioms[0].TruthLabel, _inputTwoFormulas.FormulaParseRequests[1].UnparsedTableauNode.TruthLabel); Assert.IsTrue(!errorResponse.HasErrorResponse()); }
public void TestConversionServiceSomeListResponseFromDataService() { ConversionService serv = new ConversionService(); using (Microsoft.QualityTools.Testing.Fakes.ShimsContext.Create()) { PdfConversion.Server.DataService.Fakes.ShimFileStatusRepositoryFactory.GetRepository = () => { var shim = new PdfConversion.Server.DataService.Fakes.StubIRepository<FileStatusEntity>(); shim.SaveChanges = () => { }; shim.GetAll = () => { var ls = new List<FileStatusEntity>(); var entity = new FileStatusEntity(); entity.FileState = FileState.Converting; ls.Add(entity); ls.Add(new FileStatusEntity()); return ls.AsQueryable<FileStatusEntity>(); }; return shim; }; var results = serv.GetAvailableFiles(); Assert.IsTrue(results.Count() == 2); } }
public void TestConversionServiceOfflineNullResponseFromDataService() { ConversionService serv = new ConversionService(); using (Microsoft.QualityTools.Testing.Fakes.ShimsContext.Create()) { PdfConversion.Server.DataService.Fakes.ShimFileStatusRepositoryFactory.GetRepository = () => { var shim = new PdfConversion.Server.DataService.Fakes.StubIRepository<FileStatusEntity>(); shim.SaveChanges = () => { }; shim.SearchForExpressionOfFuncOfT0Boolean = a => null; return shim; }; var status = serv.GetServerStatus(); Assert.IsTrue(status == PdfConversionService.API.ServerState.Offline); } }