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