public void True_Condition_Ignores_Map() { TypeAdapterConfig <SimplePoco, SimpleDto> .NewConfig() .IgnoreIf((src, dest) => src.Name == "TestName", dest => dest.Name) .Compile(); var poco = new SimplePoco { Id = 1, Name = "TestName" }; SimpleDto dto = TypeAdapter.Adapt <SimplePoco, SimpleDto>(poco); dto.Id.ShouldBe(1); dto.Name.ShouldBeNull(); }
public void Connected_Complex_Contract_Must_Be_Hosted_And_Invoked_Correctly() { var contractType = typeof(IComplexContract); var invokationMethod = nameof(IComplexContract.GetSomeDto); var simpleDto = new SimpleDto { Index = 57, Name = "SomeName" }; CreateOpenConnectedHost(contractType); CallOnConnectedProxy(contractType, invokationMethod, new[] { simpleDto }); AssertInvokationOn(contractType, invokationMethod, new[] { simpleDto }); }
public void False_Condition_Primitive_Does_Not_Map() { TypeAdapterConfig <SimplePoco, SimpleDto> .NewConfig() .Map(dest => dest.Name, src => src.Name, cond => false) .Compile(); var poco = new SimplePoco { Id = Guid.NewGuid(), Name = "TestName" }; SimpleDto dto = TypeAdapter.Adapt <SimplePoco, SimpleDto>(poco); dto.Id.ShouldEqual(poco.Id); dto.Name.ShouldBeNull(); }
public void Interface_To_Interface_Is_Mapped_Successfully() { var now = DateTime.UtcNow; var dto = new SimpleDto { Id = Guid.Empty, Name = "Dto", Value = 42, Timestamp = now }; Mapper.Config <IDto, IDomain>() .MapProperty(d => d.Timestamp, t => t.Timestamp.ToString("U")); var domain = Mapper.Map <SimpleDto, SimpleDomain>(dto); Assert.NotNull(domain); Assert.Equal(dto.Timestamp.ToString("U"), domain.Timestamp); }
public void Passed_Condition_Primitive_Does_Map() { TypeAdapterConfig <SimplePoco, SimpleDto> .NewConfig() .Map(dest => dest.Name, src => src.Name, cond => cond.Name == "TestName") .Compile(); var poco = new SimplePoco { Id = Guid.NewGuid(), Name = "TestName" }; SimpleDto dto = TypeAdapter.Adapt <SimplePoco, SimpleDto>(poco); dto.Id.ShouldBe(poco.Id); dto.Name.ShouldBe("TestName"); }
public void Disconnected_Very_Complex_Contract_Must_Be_Hosted_And_Invoked_Correctly() { var contractType = typeof(IVeryComplexContract); var invokationMethod = nameof(IVeryComplexContract.DoSomethingOnInt); var simpleDto = new SimpleDto { Index = 57, Name = "SomeName" }; var message = "Hola! Very Complex Service."; CreateOpenDisconnectedHost(contractType); CallOnDisconnectedProxy(contractType, invokationMethod, new object[] { simpleDto, message }); AssertInvokationOn(contractType, invokationMethod, new object[] { simpleDto, message }); }
public async Task AutoIncrementIsWorking() { var simpleDto = new SimpleDto { Key = 0, Value = "test" }; var result = await _dao.TryInsertOrUpdateAsync(simpleDto).ConfigureAwait(false); var loadAll = _dbContextBuilder.CreateContext().Set <SimpleEntity>().ToList(); Assert.IsTrue(loadAll.Count == 1); Assert.IsTrue(loadAll.First().Key == 1); Assert.IsTrue(loadAll.First().Value == "test"); Assert.IsTrue(result.Key == 1); Assert.IsTrue(result.Value == "test"); }
public ExampleOneResponse Get() { var simpleDto = new SimpleDto { PrimaryKey = 52, Name = "Ben Hall", Active = true }; var simpleViewModel = _mapper.Map <SimpleViewModel>(simpleDto); return(new ExampleOneResponse { SimpleDto = simpleDto, SimpleViewModel = simpleViewModel }); }
public void Null_Condition_Ignores_Map_To_Target() { TypeAdapterConfig <SimplePoco, SimpleDto> .NewConfig() .IgnoreIf(null, dest => dest.Name) .Compile(); var poco = new SimplePoco { Id = 1, Name = "TestName" }; var dto = new SimpleDto { Id = 999, Name = "DtoName" }; TypeAdapter.Adapt(poco, dto); dto.Id.ShouldBe(1); dto.Name.ShouldBe("DtoName"); }
public void False_Condition_Does_Not_Ignore() { TypeAdapterConfig <SimplePoco, SimpleDto> .NewConfig() .IgnoreIf((src, dest) => src.Name == "TestName", dest => dest.Name) .Compile(); var poco = new SimplePoco { Id = 1, Name = "NotTestName" }; var dto = new SimpleDto { Id = 999, Name = "DtoName" }; TypeAdapter.Adapt(poco, dto); dto.Id.ShouldBe(1); dto.Name.ShouldBe("NotTestName"); }
public void True_Condition_On_Target_Ignores_Map_To_Target() { TypeAdapterConfig <SimplePoco, SimpleDto> .NewConfig() .IgnoreIf((src, dest) => !string.IsNullOrEmpty(dest.Name), dest => dest.Name) .Compile(); var poco = new SimplePoco { Id = 1, Name = "TestName" }; var dto = new SimpleDto { Id = 999, Name = "DtoName" }; TypeAdapter.Adapt(poco, dto); dto.Id.ShouldBe(1); dto.Name.ShouldBe("DtoName"); }
public void CanSerializeSimpleDto() { var writer = new SpanWriter(); var value = new SimpleDto { IntField = 42, StringField = "Hello" }; var storedDescriptorCtx = _mapping.StoreNewDescriptors(value); storedDescriptorCtx.FinishNewDescriptors(ref writer); storedDescriptorCtx.StoreObject(ref writer, value); storedDescriptorCtx.CommitNewDescriptors(); var reader = new SpanReader(writer.GetSpan()); _mapping.LoadTypeDescriptors(ref reader); var obj = (SimpleDto)_mapping.LoadObject(ref reader); Assert.Equal(value.IntField, obj.IntField); Assert.Equal(value.StringField, obj.StringField); }
public void CanDeserializeSimpleDtoToDynamic() { var value = new SimpleDto { IntField = 42, StringField = "Hello" }; var obj = ConvertToDynamicThroughSerialization(value); Assert.Equal(value.IntField, obj.IntField); Assert.Equal(value.StringField, obj.StringField); Assert.Throws <MemberAccessException>(() => { var garbage = obj.Garbage; }); var descriptor = _ts.DescriptorOf((object)obj); Assert.NotNull(descriptor); Assert.True(descriptor.ContainsField("IntField")); Assert.False(descriptor.ContainsField("Garbage")); }
public async Task CanReplaceDto() { var otherContext = _dbContextBuilder.CreateContext(); otherContext.Set <SimpleEntity>().Add(new SimpleEntity { Key = 8, Value = "test" }); await otherContext.SaveChangesAsync().ConfigureAwait(false); var simpleDto = new SimpleDto { Key = 8, Value = "blabla" }; await _dao.TryInsertOrUpdateAsync(simpleDto).ConfigureAwait(false); var loadAll = _dbContextBuilder.CreateContext().Set <SimpleEntity>().ToList(); Assert.IsTrue(loadAll.Count == 1); Assert.IsTrue(loadAll.First().Key == 8); Assert.IsTrue(loadAll.First().Value == "blabla"); }
public void Can_read_object_from_stream() { string jsonString = "{\"StringProperty\":\"A string\",\"IntProperty\":10,\"Timestamp\":\"2013-02-25T08:04:30.4136626+00:00\",\"NullableDouble\":23.456}\""; byte[] jsonBytes = System.Text.Encoding.UTF8.GetBytes(jsonString); MemoryStream stream = new MemoryStream(jsonBytes); object result = handler.ReadObject(null, stream, typeof(SimpleDto)); Assert.That(result, Is.Not.Null); SimpleDto dto = (SimpleDto)result; Assert.That(dto.IntProperty, Is.EqualTo(10)); Assert.That(dto.StringProperty, Is.EqualTo("A string")); Assert.That(dto.StringProperty, Is.EqualTo("A string")); Assert.That(dto.NullableDouble.HasValue, Is.True); Assert.That(dto.NullableDouble, Is.EqualTo(23.456)); }
public void NoErrorWhenMapped() { TypeAdapterConfig.GlobalSettings.RequireDestinationMemberSource = true; TypeAdapterConfig <SimpleDto, SimplePoco> .NewConfig() .TwoWays() .Map(dest => dest.Id, src => src.Id) .Map(dest => dest.Name, src => src.Name); var dto = new SimpleDto { Id = Guid.NewGuid(), Name = "TestName" }; var poco = dto.Adapt <SimplePoco>(); poco.Name.ShouldBe(dto.Name); var dto2 = poco.Adapt <SimpleDto>(); dto2.Name.ShouldBe(poco.Name); }
public void Can_write_object_to_output_stream() { SimpleDto dto = new SimpleDto(); dto.IntProperty = 10; dto.NullableDouble = 23.456; dto.StringProperty = "A string"; dto.Timestamp = DateTime.Now; MemoryStream stream = new MemoryStream(); handler.WriteObject(null, dto, stream); stream.Seek(0, SeekOrigin.Begin); byte[] bytes = stream.ToArray(); Assert.That(bytes.Length, Is.Not.EqualTo(0)); string jsonString = System.Text.Encoding.UTF8.GetString(bytes); Assert.That(jsonString, Is.Not.Null); }
public void Can_compress_and_decompress_SimpleDto() { var simpleDto = new SimpleDto(1, "name"); var simpleDtoXml = DataContractSerializer.Instance.SerializeToString(simpleDto); var simpleDtoZip = simpleDtoXml.Deflate(); Assert.That(simpleDtoZip.Length, Is.GreaterThan(0)); var deserializedSimpleDtoXml = simpleDtoZip.Inflate(); Assert.That(deserializedSimpleDtoXml, Is.Not.Empty); var deserializedSimpleDto = DataContractSerializer.Instance.DeserializeFromString<SimpleDto>( deserializedSimpleDtoXml); Assert.That(deserializedSimpleDto, Is.Not.Null); Assert.That(deserializedSimpleDto.Id, Is.EqualTo(simpleDto.Id)); Assert.That(deserializedSimpleDto.Name, Is.EqualTo(simpleDto.Name)); }
public void Can_compress_and_decompress_SimpleDto_with_Gzip() { var simpleDto = new SimpleDto(1, "name"); var simpleDtoXml = DataContractSerializer.Instance.SerializeToString(simpleDto); var simpleDtoZip = simpleDtoXml.GZip(); Assert.That(simpleDtoZip.Length, Is.GreaterThan(0)); var deserializedSimpleDtoXml = simpleDtoZip.GUnzip(); Assert.That(deserializedSimpleDtoXml, Is.Not.Empty); var deserializedSimpleDto = DataContractSerializer.Instance.DeserializeFromString <SimpleDto>( deserializedSimpleDtoXml); Assert.That(deserializedSimpleDto, Is.Not.Null); Assert.That(deserializedSimpleDto.Id, Is.EqualTo(simpleDto.Id)); Assert.That(deserializedSimpleDto.Name, Is.EqualTo(simpleDto.Name)); }
public async Task <string> GetResponseFromApi(string contentToSend) { CheckAndSetToken(); using (var client = new HttpClient()) { var transferObject = new SimpleDto { Text = contentToSend }; var contentBody = new StringContent(JsonConvert.SerializeObject(transferObject), Encoding.UTF8, "application/json"); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Token); var response = await client.PostAsync($"{ApiUrl}/text-infos/count-words", contentBody); if (!response.IsSuccessStatusCode) { CustomNLogger.LogException($"error occurred: \n{response.StatusCode} \n{response.RequestMessage.RequestUri}"); return("There is currently error in communication with API"); } return(await response.Content.ReadAsStringAsync()); } }
public void Can_compress_and_decompress_SimpleDto_with_Gzip() { var simpleDto = new SimpleDto(1, "name"); var simpleDtoXml = DataContractSerializer.Instance.Parse(simpleDto); var simpleDtoZip = simpleDtoXml.GZip(); Assert.That(simpleDtoZip.Length, Is.GreaterThan(0)); var deserializedSimpleDtoXml = simpleDtoZip.GUnzip(); Assert.That(deserializedSimpleDtoXml, Is.Not.Empty); var deserializedSimpleDto = DataContractDeserializer.Instance.Parse<SimpleDto>( deserializedSimpleDtoXml); Assert.That(deserializedSimpleDto, Is.Not.Null); Assert.That(deserializedSimpleDto.Id, Is.EqualTo(simpleDto.Id)); Assert.That(deserializedSimpleDto.Name, Is.EqualTo(simpleDto.Name)); }
public void Can_compress_and_decompress_SimpleDto() { var simpleDto = new SimpleDto(1, "name"); var simpleDtoXml = DataContractSerializer.Instance.Parse(simpleDto); var simpleDtoZip = simpleDtoXml.Deflate(); Assert.That(simpleDtoZip.Length, Is.GreaterThan(0)); var deserializedSimpleDtoXml = simpleDtoZip.Inflate(); Assert.That(deserializedSimpleDtoXml, Is.Not.Empty); var deserializedSimpleDto = DataContractDeserializer.Instance.Parse <SimpleDto>( deserializedSimpleDtoXml); Assert.That(deserializedSimpleDto, Is.Not.Null); Assert.That(deserializedSimpleDto.Id, Is.EqualTo(simpleDto.Id)); Assert.That(deserializedSimpleDto.Name, Is.EqualTo(simpleDto.Name)); }
public Guid DoSomethingOnInt(SimpleDto dto, string message) { invokeCounter.AddInvokation(nameof(DoSomethingOnInt), new object[] { dto, message }); return(Guid.NewGuid()); }
public IHttpActionResult CountWords(SimpleDto dto) { string result = $"number of words: { _textService.ReturnNumberOfWordsInText(dto.Text)}"; return(Ok(result)); }
public ResultWrapper(SimpleDto simpleDto) { this.simpleDto = simpleDto; }
public void GetSomeDto(SimpleDto dto) { invokeCounter.AddInvokation(nameof(GetSomeDto), new[] { dto }); }
public DtoWithNestedDto(int integer, double d, SimpleDto nestedDto) { Integer = integer; Double = d; NestedDto = nestedDto; }
public async Task <ActionResult> ChangeStatus([FromRoute] long id, [FromBody] SimpleDto <int> status) => Result(await _userService.ChangeStatusAsync(id, status.Value));
public void Post([FromBody] SimpleDto value) { }
public void Put(int id, [FromBody] SimpleDto value) { }