public void DeserializationOfListOfMessageSubscriptionPayload() { ISerializerService serializerService = this.serializationFixture.SerializerService; var expectedCategoryId = "3df866bd-7e5f-47d1-bbe2-ca1d1f39a260"; string serialized = File.ReadAllText("Resources/Messages/MessageSubscriptionPayload.json"); var payload = serializerService.Deserialize <Payload>(serialized); Assert.NotNull(payload); var categoryCreatedPayload = payload as MessageSubscriptionPayload <Category>; Assert.NotNull(categoryCreatedPayload); Assert.Equal(expectedCategoryId, categoryCreatedPayload.Resource.Id); Assert.NotNull(categoryCreatedPayload.Message); var categoryCreatedMessage = categoryCreatedPayload.Message as CategoryCreatedMessage; Assert.NotNull(categoryCreatedMessage); Assert.Equal(expectedCategoryId, categoryCreatedMessage.Category.Id); }
public void DeserializeLocalizedString() { ISerializerService serializerService = this.serializationFixture.SerializerService; string serialized = @" { ""name"": { ""en"": ""name-en"", ""en-US"": ""name-en-us"" } } "; var product = serializerService.Deserialize <ProductProjection>(serialized); Assert.Equal("name-en", product.Name["en"]); Assert.Equal("name-en-us", product.Name["en-US"]); }
private async Task VerifyAsync(RemotableData remotableData, ISerializerService serializerService, CancellationToken cancellationToken) { using (var stream = new MemoryStream()) using (var writer = new ObjectWriter(stream, cancellationToken)) { await remotableData.WriteObjectToAsync(writer, cancellationToken).ConfigureAwait(false); stream.Position = 0; using (var reader = ObjectReader.TryGetReader(stream, cancellationToken)) { var value = serializerService.Deserialize <object>(remotableData.Kind, reader, cancellationToken); var checksum = serializerService.CreateChecksum(value, cancellationToken); Debug.Assert(checksum == remotableData.Checksum); } } }
public void DeserializeCustomField() { ISerializerService serializerService = this.serializationFixture.SerializerService; string serialized = @" { ""fields"": { ""foo"": ""bar"", ""Foos"": ""Bars"" } } "; var customFields = serializerService.Deserialize <CustomFields>(serialized); Assert.Equal("bar", customFields.Fields["foo"]); Assert.Equal("Bars", customFields.Fields["Foos"]); }
private static async Task <RemotableData> CloneAssetAsync(ISerializerService serializer, RemotableData asset) { using (var stream = SerializableBytes.CreateWritableStream()) using (var writer = new ObjectWriter(stream)) { await asset.WriteObjectToAsync(writer, CancellationToken.None).ConfigureAwait(false); stream.Position = 0; using (var reader = ObjectReader.TryGetReader(stream)) { var recovered = serializer.Deserialize <object>(asset.Kind, reader, CancellationToken.None); var assetFromStorage = SolutionAsset.Create(serializer.CreateChecksum(recovered, CancellationToken.None), recovered, serializer); Assert.Equal(asset.Checksum, assetFromStorage.Checksum); return(assetFromStorage); } } }
private static SolutionAsset CloneAsset(ISerializerService serializer, SolutionAsset asset) { using var stream = SerializableBytes.CreateWritableStream(); using var context = new SolutionReplicationContext(); using (var writer = new ObjectWriter(stream, leaveOpen: true)) { serializer.Serialize(asset.Value, writer, context, CancellationToken.None); } stream.Position = 0; using var reader = ObjectReader.TryGetReader(stream); var recovered = serializer.Deserialize <object>(asset.Kind, reader, CancellationToken.None); var assetFromStorage = new SolutionAsset(serializer.CreateChecksum(recovered, CancellationToken.None), recovered); Assert.Equal(asset.Checksum, assetFromStorage.Checksum); return(assetFromStorage); }
public void MessagesDeserializationOfDifferentTypes() { //Deserialize 3 of messages of different types ISerializerService serializerService = this.serializationFixture.SerializerService; string serialized = File.ReadAllText("Resources/Messages/Messages.json"); var messages = serializerService.Deserialize <List <Message> >(serialized); var categoryCreatedMessage = messages[0] as CategoryCreatedMessage; var customerCreatedMessage = messages[1] as CustomerCreatedMessage; var lineItemStateTransitionMessage = messages[2] as LineItemStateTransitionMessage; Assert.NotNull(categoryCreatedMessage); Assert.NotNull(categoryCreatedMessage.Category); Assert.NotNull(customerCreatedMessage); Assert.NotNull(customerCreatedMessage.Customer); Assert.NotNull(lineItemStateTransitionMessage); }
public void DeserializationOfListOfChangeSubscriptionPayloads() { ISerializerService serializerService = this.serializationFixture.SerializerService; string serialized = File.ReadAllText("Resources/Messages/Payloads.json"); var payloads = serializerService.Deserialize <List <Payload> >(serialized); Assert.NotNull(payloads); Assert.Equal(4, payloads.Count); var resourceCreatedPayload = payloads[0] as ResourceCreatedPayload <Customer>; var resourceUpdatedPayload = payloads[1] as ResourceUpdatedPayload <Category>; var resourceDeletedPayload = payloads[2] as ResourceDeletedPayload <Product>; var customerCreatedPayload = payloads[3] as MessageSubscriptionPayload <Customer>; Assert.NotNull(resourceCreatedPayload); Assert.NotNull(resourceUpdatedPayload); Assert.NotNull(resourceDeletedPayload); Assert.NotNull(customerCreatedPayload); Assert.Equal(2, resourceUpdatedPayload.OldVersion); }
public async Task <Conference> GetRemoteConferenceAsync() { var conference = new Conference(); if (_connectivityService.IsConnected) { try { var stream = await _httpService.GetResponseAsync(_appConfig.GuidebookAddress); var guidebook = await _serializerService.Deserialize <GuidebookDto> (stream); conference = _mapperService.MapGuidebookToConference(guidebook); } catch (Exception) { return(conference); } } return(conference); }
public void HighPrecisionMoneyDeserialization() { ISerializerService serializerService = this.serializationFixture.SerializerService; string serialized = @"{ ""type"": ""highPrecision"", ""currencyCode"": ""EUR"", ""centAmount"": 123456, ""preciseAmount"": 12345678, ""fractionDigits"": 4 }"; var deserialized = serializerService.Deserialize <BaseMoney>(serialized); Assert.IsType <HighPrecisionMoney>(deserialized); Assert.Equal("EUR", deserialized.CurrencyCode); Assert.Equal(MoneyType.HighPrecision, deserialized.Type); Assert.Equal(123456, deserialized.CentAmount); Assert.Equal(1234.5678M, deserialized.AmountToDecimal()); Assert.Equal(4, deserialized.FractionDigits); }
public Task Initialize() { ISerializerService serializer = ConceptMatrix.Services.Get <ISerializerService>(); string json = File.ReadAllText("MainOffsets.json"); MainOffsetFile file = serializer.Deserialize <MainOffsetFile>(json); // Set the names of all the offsets for debugging. PropertyInfo[] properties = file.GetType().GetProperties(); foreach (PropertyInfo property in properties) { Offset offset = (Offset)property.GetValue(file); offset.Name = property.Name; property.SetValue(file, offset); } Offsets.Main = file; return(Task.CompletedTask); }
public void DeserializeProductWithSetNestedAttribute() { ISerializerService serializerService = this.serializationFixture.SerializerService; string productSerialized = File.ReadAllText("Resources/Types/ProductWithSetNestedAttribute.json"); var product = serializerService.Deserialize <Product>(productSerialized); var attr = product.MasterData.Current.MasterVariant.Attributes[0]; Assert.True(attr.IsSetOfNestedAttribute()); var setOfNestedAttr = attr.ToSetOfNestedAttribute(); Assert.NotNull(setOfNestedAttr); Assert.Equal(2, setOfNestedAttr.Value.Count); var firstNestedAttr = setOfNestedAttr.Value.FirstOrDefault(); Assert.NotNull(firstNestedAttr); Assert.Equal(2, firstNestedAttr.Value.Count); Assert.True(firstNestedAttr.Value[0].IsNumberAttribute()); Assert.True(firstNestedAttr.Value[1].IsTextAttribute()); }
public async Task <Team> GetInfoAsync() { Team SportsTeams = null; var request = new HttpRequestMessage { Method = HttpMethod.Get, RequestUri = new Uri($"{Config.ApiUrl}/teams"), Headers = { { Config.ApiKeyHeader, Config.ApiKey }, { Config.ApiHostHeader, Config.ApiHost }, }, }; var client = new HttpClient(); var response = await client.SendAsync(request); if (response.IsSuccessStatusCode) { SportsTeams = _serializerService.Deserialize <Team>(await response.Content.ReadAsStringAsync()); } return(SportsTeams); }
public async Task <Team> GetSportsTeamsAsync() { Team SportsTeams = null; var request = new HttpRequestMessage { Method = HttpMethod.Get, RequestUri = new Uri("https://sportscore1.p.rapidapi.com/teams"), Headers = { { "x-rapidapi-key", "" }, { "x-rapidapi-host", "sportscore1.p.rapidapi.com" }, }, }; var client = new HttpClient(); var response = await client.SendAsync(request); if (response.IsSuccessStatusCode) { SportsTeams = serializerService.Deserialize <Team>(await response.Content.ReadAsStringAsync()); } return(SportsTeams); }
private static IList <(Checksum, object)> ReadAssets( Stream stream, int scopeId, ISet <Checksum> checksums, ISerializerService serializerService, CancellationToken cancellationToken) { var results = new List <(Checksum, object)>(); using var reader = ObjectReader.TryGetReader(stream, cancellationToken); // We only get a reader for data transmitted between live processes. // This data should always be correct as we're never persisting the data between sessions. Contract.ThrowIfNull(reader); var responseScopeId = reader.ReadInt32(); Contract.ThrowIfFalse(scopeId == responseScopeId); var count = reader.ReadInt32(); Contract.ThrowIfFalse(count == checksums.Count); for (var i = 0; i < count; i++) { var responseChecksum = Checksum.ReadFrom(reader); Contract.ThrowIfFalse(checksums.Contains(responseChecksum)); var kind = (WellKnownSynchronizationKind)reader.ReadInt32(); // in service hub, cancellation means simply closed stream var result = serializerService.Deserialize <object>(kind, reader, cancellationToken); results.Add((responseChecksum, result)); } return(results); }
public async Task <ObservableCollection <Ranking> > GetRankingAync(string queue, string tier, string division) { if (tier == "CHALLENGER" || tier == "GRANDMASTER" || tier == "MASTER") { division = "I"; } ObservableCollection <Ranking> ranking = null; var refitClient = RestService.For <IRankingApi>(Config.NaRankingApiUrl); var rankingResponse = await refitClient.GetRankingAync(queue, tier, division, Config.ApiKey); if (rankingResponse.IsSuccessStatusCode) { var jsonRanking = await rankingResponse.Content.ReadAsStringAsync(); ranking = SerializerService.Deserialize <ObservableCollection <Ranking> >(jsonRanking); ranking = new ObservableCollection <Ranking>(ranking.OrderByDescending(x => x.LeaguePoints)); } return(ranking); }
public void DeserializeAttributeListAndGetAttributeValue() { ISerializerService serializerService = this.serializationFixture.SerializerService; string serialized = File.ReadAllText("Resources/Attributes/List.json"); ProductVariant deserialized = serializerService.Deserialize <ProductVariant>(serialized); var attributes = deserialized.Attributes; Assert.NotEmpty(attributes); Assert.True(attributes[0].IsTextAttribute()); var textAttribute = attributes[0].ToTextAttribute(); Assert.NotNull(textAttribute); Assert.True(attributes[1].IsEnumAttribute()); var enumAttribute = attributes[1].ToEnumAttribute(); Assert.NotNull(enumAttribute); Assert.True(attributes[2].IsBooleanAttribute()); var boolAttribute = attributes[2].ToBooleanAttribute(); Assert.NotNull(boolAttribute); }
public void DeserializeOfSubscriptions() { ISerializerService serializerService = this.serializationFixture.SerializerService; string serialized = File.ReadAllText("Resources/Messages/Subscriptions.json"); var subscriptions = serializerService.Deserialize <List <Subscription> >(serialized); Assert.Equal(2, subscriptions.Count); Assert.IsType <SqsDestination>(subscriptions[0].Destination); Assert.IsType <SnsDestination>(subscriptions[1].Destination); var subscription1 = subscriptions[0]; var subscription2 = subscriptions[1]; Assert.IsType <PlatformFormat>(subscription1.Format); var subscription2Format = subscription2.Format as CloudEventsFormat; Assert.NotNull(subscription2Format); Assert.Equal("0.1", subscription2Format.CloudEventsVersion); Assert.Equal(SubscriptionHealthStatus.Healthy, subscription1.Status); Assert.Equal(SubscriptionHealthStatus.TemporaryError, subscription2.Status); Assert.Single(subscription1.Messages); Assert.Single(subscription2.Changes); Assert.Equal(SubscriptionResourceTypeId.Product, subscription1.Messages[0].GetResourceTypeIdAsEnum()); Assert.Equal(SubscriptionResourceTypeId.Unknown, subscription2.Changes[0].GetResourceTypeIdAsEnum()); }
public static async Task ProcessOrderCommandFunction([ServiceBusTrigger(ProcessPostCommand.CommandQueueName)] string message, ILogger logger) { logger.LogInformation(message); var command = serializerService.Deserialize <ProcessPostCommand>(message); await workerApplicationService.ProcessPostAsync(command); }
private void HistoryProcess(MessageReceivedEventArgs message) { var historyReponse = _serializerService.Deserialize <HistoryResponse>(message.Message); OnRepeater(ActionTypes.History, true, historyReponse); }
Settings ReadSettings() { var content = _fileSystemService.Read(_fileName); return(_serializerService.Deserialize <Settings>(content)); }
/// <summary> /// Reads from. /// </summary> /// <param name="stream">The stream.</param> /// <returns></returns> public T ReadFrom(Stream stream) { return(serializerService.Deserialize <T>(stream)); }