public void Should_return_error_when_domain_exists()
{
_mockCommerceRepository.Setup(x => x.NameExists(It.IsAny <string>(), null))
.Returns(false);
_mockCommerceRepository.Setup(x => x.DomainExists(It.IsAny <string>(), null))
.Returns(true);
var handler = new CreateCommerceHandler(_mockCommerceRepository.Object);
var command = new CreateCommerceCommand
{
Name = "Test Name",
SiteDomain = "test.com",
Country = "Brasil",
State = "São Paulo",
City = "São Paulo"
};
var result = handler.Handle(command);
Assert.False(handler.Valid);
Assert.False(result.Success);
Assert.Equal("Domain", handler.Notifications
.Select(x => x.Property)
.FirstOrDefault(x => x == "Domain"));
}
public async Task Create_commerce_should_return_bad_request_when_command_is_invalid(string url)
{
var body = new CreateCommerceCommand()
{
Name = "",
Country = "",
State = "",
City = "",
SiteDomain = ""
};
var stringBody = JsonConvert.SerializeObject(body);
var stringContent = new StringContent(stringBody, Encoding.UTF8, "application/json");
// Act
var response = await _client.PostAsync(url, stringContent);
var jsonResponse = await response.Content.ReadAsStringAsync();
dynamic result = JObject.Parse(jsonResponse);
// Assert
Assert.False((bool)result.success, (string)result.message);
Assert.Equal("Não foi possível cadastrar o comércio.", (string)result.message);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task Create_commerce_should_return_success(string url)
{
var body = new CreateCommerceCommand()
{
Name = "CommerceName",
Country = "Brazil",
State = "São Paulo",
City = "São Paulo",
SiteDomain = "testdomain"
};
var stringBody = JsonConvert.SerializeObject(body);
var stringContent = new StringContent(stringBody, Encoding.UTF8, "application/json");
// Act
var response = await _client.PostAsync(url, stringContent);
// Assert Response
response.EnsureSuccessStatusCode();
var jsonResponse = await response.Content.ReadAsStringAsync();
dynamic result = JObject.Parse(jsonResponse);
// Assert
Assert.True((bool)result.success, (string)result.message);
Assert.Equal("Comércio cadastrado com sucesso.", (string)result.message);
}
public void Should_return_error_when_command_is_invalid()
{
var handler = new CreateCommerceHandler(_mockCommerceRepository.Object);
var command = new CreateCommerceCommand();
var result = handler.Handle(command);
Assert.False(command.Valid);
Assert.False(handler.Valid);
Assert.False(result.Success);
}
public void Should_be_invalid_when_site_domain_is_empty()
{
var command = new CreateCommerceCommand
{
SiteDomain = ""
};
command.Validate();
Assert.True(command.Invalid);
Assert.Equal("SiteDomain", command.Notifications
.Select(x => x.Property)
.FirstOrDefault(x => x == "SiteDomain"));
}
public void Should_be_invalid_when_name_surpass_max_length_50_chars()
{
var command = new CreateCommerceCommand
{
Name = new string('a', 51)
};
command.Validate();
Assert.True(command.Invalid);
Assert.Equal("Name", command.Notifications
.Select(x => x.Property)
.FirstOrDefault(x => x == "Name"));
}
public void Should_be_invalid_when_name_does_not_has_min_length_3_chars()
{
var command = new CreateCommerceCommand
{
Name = "a"
};
command.Validate();
Assert.True(command.Invalid);
Assert.Equal("Name", command.Notifications
.Select(x => x.Property)
.FirstOrDefault(x => x == "Name"));
}
public void Should_be_invalid_when_name_is_null()
{
var command = new CreateCommerceCommand
{
Name = null
};
command.Validate();
Assert.True(command.Invalid);
Assert.Equal("Name", command.Notifications
.Select(x => x.Property)
.FirstOrDefault(x => x == "Name"));
}
public void Should_be_invalid_when_city_is_empty()
{
var command = new CreateCommerceCommand
{
City = ""
};
command.Validate();
Assert.True(command.Invalid);
Assert.Equal("City", command.Notifications
.Select(x => x.Property)
.FirstOrDefault(x => x == "City"));
}
public async Task Update_commerce_should_return_success(string url)
{
var bodyCreate = new CreateCommerceCommand()
{
Name = "CommerceName123",
Country = "Brazil",
State = "São Paulo",
City = "São Paulo",
SiteDomain = "testdomain"
};
var stringBodyCreate = JsonConvert.SerializeObject(bodyCreate);
var stringContentCreate = new StringContent(stringBodyCreate, Encoding.UTF8, "application/json");
var responseCreate = await _client.PostAsync(url, stringContentCreate);
responseCreate.EnsureSuccessStatusCode();
var jsonResponseCreate = await responseCreate.Content.ReadAsStringAsync();
dynamic resultCreate = JObject.Parse(jsonResponseCreate);
var entityId = (Guid)resultCreate.result.id;
var bodyUpdate = new UpdateCommerceCommand()
{
Name = "CommerceName123",
Country = "test",
State = "São Paulo",
City = "São Paulo",
SiteDomain = "testdomain123"
};
var stringBodyUpdate = JsonConvert.SerializeObject(bodyUpdate);
var stringContentUpdate = new StringContent(stringBodyUpdate, Encoding.UTF8, "application/json");
var responseUpdate = await _client.PatchAsync($"{url}/{entityId}", stringContentUpdate);
responseUpdate.EnsureSuccessStatusCode();
var jsonResponseUpdate = await responseUpdate.Content.ReadAsStringAsync();
dynamic resultUpdate = JObject.Parse(jsonResponseUpdate);
// Assert
Assert.True((bool)resultUpdate.success, (string)resultUpdate.message);
Assert.Equal("Comércio atualizado com sucesso.", (string)resultUpdate.message);
}
public void Should_be_valid()
{
var command = new CreateCommerceCommand
{
Name = _valid_name,
SiteDomain = _valid_domain,
Country = _valid_country,
State = _valid_state,
City = _valid_city
};
command.Validate();
Assert.True(command.Valid);
}
public IActionResult Create([FromBody] CreateCommerceCommand command)
{
var result = _createCommerce.Handle(command);
if (!result.Success)
{
return(BadRequest(result));
}
var createdEntity = (CreateCommerceResult)result.Result;
var createdUri = new Uri($"{Request.Path}/{createdEntity.Id}", UriKind.Relative);
return(Created(createdUri, result));
}
public void Should_return_success()
{
var handler = new CreateCommerceHandler(_mockCommerceRepository.Object);
var command = new CreateCommerceCommand
{
Name = "Test Name",
SiteDomain = "test.com",
Country = "Brasil",
State = "São Paulo",
City = "São Paulo"
};
var result = handler.Handle(command);
Assert.True(result.Success);
Assert.True(handler.Valid);
}
