public void Initialize()
{
DALContext = new InMemDAL();
luggageStatus = new LuggageStatus(status)
{
LuggageStatusId = luggageStatusId,
StatusDescription = testStatusDescription,
Location = new GeoLocation(latitude, longitude),
DateTimeStamp = lastStatusChange,
};
luggage = new Luggage(luggageId, name)
{
Weight = weight,
Measurement = measurement,
Description = description,
Status = luggageStatus,
LastStatusChange = lastStatusChange,
};
passenger = new Passenger(passengerId, pnr, passengerFirstName, passengerLastName)
{
PassengerMiddleName = passengerMiddleName,
FlightNumber = flightNo,
SeatNumber = seatNo,
Address = address,
Phone = phone,
EMail = email,
Remarks = remarks,
Subscribed = subscribed,
Luggages = luggages,
};
}
public async Task UpdateLuggageStatus(string luggageId, LuggageStatus luggageStatus)
{
try
{
Luggage luggage = await DAL.GetLuggage(luggageId);
// LuggageStatusEnum status = (LuggageStatusEnum) Enum.Parse(typeof(LuggageStatusEnum), luggageStatus, true);
if (luggage == null)
{
throw new ArgumentException("No such luggage to update");
}
else
{
luggage.Status = luggageStatus;
luggage.LastStatusChange = DateTime.Now;
await DAL.UpdateLuggage(luggage);
}
}
catch (ArgumentException ex)
{
throw new LuggageTrackerBizContextException("Invalid Argument", ex)
{
StatusCode = HttpStatusCode.BadRequest,
};
}
catch (Exception ex)
{
throw new LuggageTrackerBizContextException("Failed to update luggage status", ex)
{
StatusCode = HttpStatusCode.InternalServerError,
};
}
}
public async Task ShouldUpdateLuggageSuccessfully()
{
luggageId = Guid.NewGuid().ToString();
name = "Updated_Name";
weight = "Updates_Weight";
measurement = "Updates_Measurement";
description = "Updates_Description";
luggageStatus = new LuggageStatus(LuggageStatusEnum.Registered);
lastStatusChange = DateTime.Now;
luggage.LuggageId = luggageId;
HttpResponseMessage createResult = await luggageController.AddLuggage(luggage);
Assert.AreEqual(createResult.StatusCode, HttpStatusCode.Created, "Verify luggage created");
luggage.Name = name;
luggage.Weight = weight;
luggage.Measurement = measurement;
luggage.Description = description;
luggage.Status = luggageStatus;
luggage.LastStatusChange = lastStatusChange;
luggageController.ControllerContext = new ControllerContext();
HttpResponseMessage updatedResult = await luggageController.UpdateLuggage(luggage);
Assert.AreEqual(updatedResult.StatusCode, HttpStatusCode.OK, "Verify luggage modified");
HttpResponseMessage getResult = await luggageController.GetLuggage(luggageId);
Assert.AreEqual(getResult.StatusCode, HttpStatusCode.OK, "verify luggage get");
string json = await getResult.Content.ReadAsStringAsync();
Luggage newLuggage = JsonConvert.DeserializeObject <Luggage>(json);
Assert.AreEqual(newLuggage.LuggageId, luggageId);
Assert.AreEqual(newLuggage.Name, name);
Assert.AreEqual(newLuggage.Weight, weight);
Assert.AreEqual(newLuggage.Measurement, measurement);
Assert.AreEqual(newLuggage.Description, description);
Assert.AreEqual(newLuggage.Status.Status, luggageStatus.Status);
Assert.AreEqual(newLuggage.LastStatusChange, lastStatusChange);
}
public async Task ShouldUpdateLuggageStatusSuccessfully()
{
LuggageStatus status = new LuggageStatus(LuggageStatusEnum.Registered);
status.LuggageStatusId = 1234;
status.StatusDescription = "Old Status description";
status.Location = new GeoLocation("111", "222");
status.DateTimeStamp = DateTime.MaxValue;
LuggageStatus UpdatedStatus = new LuggageStatus(LuggageStatusEnum.CheckedIn);
UpdatedStatus.StatusDescription = "Status description";
UpdatedStatus.LuggageStatusId = 123;
UpdatedStatus.Location = new GeoLocation("11", "22");
UpdatedStatus.DateTimeStamp = DateTime.MinValue;
string tag = Guid.NewGuid().ToString();
luggage.LuggageId = tag;
luggage.Status = status;
await BizContext.AddLuggage(luggage);
await BizContext.UpdateLuggageStatus(tag, UpdatedStatus);
Luggage updatedLuggage = await BizContext.GetLuggage(tag);
Assert.AreEqual(tag, updatedLuggage.LuggageId);
Assert.AreEqual("Status description", updatedLuggage.Status.StatusDescription);
Assert.AreEqual((UInt64)123, updatedLuggage.Status.LuggageStatusId);
Assert.AreEqual("11", updatedLuggage.Status.Location.Latitude);
Assert.AreEqual("22", updatedLuggage.Status.Location.Longitude);
Assert.AreEqual(DateTime.MinValue, updatedLuggage.Status.DateTimeStamp);
Assert.AreEqual(LuggageStatusEnum.CheckedIn, (object)updatedLuggage.Status.Status);
}
public async Task <HttpResponseMessage> UpdateLuggageStatus(string luggageId, LuggageStatus status)
{
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
try
{
await BizContext.UpdateLuggageStatus(luggageId, status);
response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("Luggage status updated successfully")
};
}
catch (LuggageTrackerBizContextException ex)
{
response = new HttpResponseMessage(ex.StatusCode)
{
Content = new StringContent(ex.Message)
};
}
catch (ArgumentException ex)
{
response = new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent(ex.Message)
};
}
catch (Exception ex)
{
response = new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(ex.Message)
};
}
return(response);
}
