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