public ActionResult <User> UpdateMusician(MusicianViewModel model)
{
if (ModelState.IsValid)
{
User currUser = _userManager.FindByNameAsync(User.Identity.Name).Result;
currUser.MusicianName = model.Name;
currUser.Summary = model.Summary;
currUser.Location = model.Location;
currUser.ImageUrl = model.ImageUrl;
currUser.Instruments = model.Instruments;
foreach (Instrument inst in model.Instruments)
{
if (inst.InstrumentId == 0)
{
_context.Instruments.Add(inst);
}
else
{
_context.Instruments.Attach(inst);
}
}
_context.SaveChanges();
return(currUser);
}
return(NotFound());
}
public async Task ReturnsCreatedGivenValidData()
{
var musician = new MusicianViewModel
{
FirstName = "A",
LastName = "B",
DateOfBirth = DateTime.Today.AddYears(-90),
DateOfDeath = DateTime.Today
};
HttpResponseMessage response = await _client.PostAsJsonAsync(BaseUrl, musician);
string responseContent = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var musicianCreated = JsonConvert.DeserializeObject <MusicianViewModel>(responseContent);
Assert.Equal("A", musicianCreated.FirstName);
Assert.Equal("B", musicianCreated.LastName);
Assert.Equal(DateTime.Today.AddYears(-90), musicianCreated.DateOfBirth);
Assert.Equal(DateTime.Today, musicianCreated.DateOfDeath);
Assert.True(musicianCreated.Id > 0);
Assert.Contains($"{BaseUrl}/{musicianCreated.Id}", response.Headers.Location.ToString(), StringComparison.InvariantCultureIgnoreCase);
}
public async Task <MusicianViewModel> Get(int id)
{
Musician musician = await _musicianRepository.GetByIdAsync(id);
MusicianViewModel musicianViewModel = musician.Adapt <MusicianViewModel>();
return(musicianViewModel);
}
public async Task ReturnsMusicianForValidId()
{
HttpResponseMessage response = await _client.GetAsync($"{BaseUrl}/4");
response.EnsureSuccessStatusCode();
string responseContent = await response.Content.ReadAsStringAsync();
MusicianViewModel band = JsonConvert.DeserializeObject <MusicianViewModel>(responseContent);
Assert.Equal("Thom", band.FirstName);
Assert.Equal("Yorke", band.LastName);
}
public ViewResult Index()
{
ViewBag.Date = DateTime.Now.ToString("MM/dd/yyyy");
var musicianVm = new MusicianViewModel {
Authenticated = false
};
if (HttpContext.User.Identity.IsAuthenticated)
{
musicianVm.FirstName = HttpContext.User.Identity.Name;
musicianVm.Authenticated = true;
}
return(View(musicianVm));
}
public async Task ReturnsBadRequestGivenIdMismatch()
{
var musician = new MusicianViewModel
{
Id = 4,
FirstName = "A",
LastName = "B",
DateOfBirth = DateTime.Today.AddYears(-90),
DateOfDeath = DateTime.Today
};
HttpResponseMessage response = await _client.PutAsJsonAsync($"{BaseUrl}/5", musician);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task ReturnsBadRequestGivenNoLastName()
{
var musician = new MusicianViewModel
{
FirstName = "A",
DateOfBirth = DateTime.Today
};
HttpResponseMessage response = await _client.PostAsJsonAsync(BaseUrl, musician);
string responseContent = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
Assert.Contains("LastName", responseContent);
Assert.Contains("The LastName field is required.", responseContent);
}
public async Task <IActionResult> Post([FromBody] MusicianViewModel model)
{
var musician = new Musician
{
FirstName = model.FirstName,
LastName = model.LastName,
DateOfBirth = model.DateOfBirth,
DateOfDeath = model.DateOfDeath
};
await _musicianRepository.AddAsync(musician);
MusicianViewModel musicianViewModel = musician.Adapt <MusicianViewModel>();
return(CreatedAtAction(nameof(Get), new { id = musician.Id }, musicianViewModel));
}
public async Task ReturnsBadRequestGivenDateOfBirthLessThan1January1900()
{
var musician = new MusicianViewModel
{
FirstName = "A",
LastName = "B",
DateOfBirth = new DateTime(1899, 12, 31)
};
HttpResponseMessage response = await _client.PostAsJsonAsync(BaseUrl, musician);
string responseContent = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
Assert.Contains("DateOfBirth", responseContent);
Assert.Contains($"The field DateOfBirth must be between {new DateTime(1900, 1, 1)} and {DateTime.Today}.", responseContent);
}
public async Task ReturnsBadRequestGivenLastNameOver50Chars()
{
var musician = new MusicianViewModel
{
FirstName = "A",
LastName = "B".PadLeft(51),
DateOfBirth = DateTime.Today
};
HttpResponseMessage response = await _client.PostAsJsonAsync(BaseUrl, musician);
string responseContent = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
Assert.Contains("LastName", responseContent);
Assert.Contains("The field LastName must be a string with a maximum length of 50.", responseContent);
}
public async Task ReturnsBadRequestGivenDateOfBirthGreaterThanDateOfDeath()
{
var musician = new MusicianViewModel
{
FirstName = "A",
LastName = "B",
DateOfBirth = DateTime.Today,
DateOfDeath = DateTime.Today.AddDays(-1)
};
HttpResponseMessage response = await _client.PostAsJsonAsync(BaseUrl, musician);
string responseContent = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
Assert.Contains("Date of Birth must be prior to Date of Death.", responseContent);
}
public async Task ReturnsNotFoundForInvalidId()
{
var musician = new MusicianViewModel
{
Id = 0,
FirstName = "A",
LastName = "B",
DateOfBirth = DateTime.Today.AddYears(-90),
DateOfDeath = DateTime.Today
};
HttpResponseMessage response = await _client.PutAsJsonAsync($"{BaseUrl}/0", musician);
string responseContent = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
Assert.Equal("0", responseContent);
}
public async Task ReturnsBadRequestGivenDateOfBirthGreaterThanToday()
{
var musician = new MusicianViewModel
{
Id = 4,
FirstName = "A",
LastName = "B",
DateOfBirth = DateTime.Today.AddDays(1)
};
HttpResponseMessage response = await _client.PutAsJsonAsync($"{BaseUrl}/4", musician);
string responseContent = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
Assert.Contains("DateOfBirth", responseContent);
Assert.Contains($"The field DateOfBirth must be between {new DateTime(1900, 1, 1)} and {DateTime.Today}.", responseContent);
}
public async Task <IActionResult> Put(int id, [FromBody] MusicianViewModel model)
{
if (id != model.Id)
{
return(BadRequest());
}
Musician musician = await _musicianRepository.GetByIdAsync(id);
musician.FirstName = model.FirstName;
musician.LastName = model.LastName;
musician.DateOfBirth = model.DateOfBirth;
musician.DateOfDeath = model.DateOfDeath;
await _musicianRepository.UpdateAsync(musician);
return(NoContent());
}
