public void AirlineFacadeChangeMyPasswordMethod()
{
ILoggedInAdministratorFacade adminFacade = (ILoggedInAdministratorFacade)TestConfig.fcs.Login(AirlineProjectConfig.ADMIN_USERNAME, AirlineProjectConfig.ADMIN_PASSWORD, out ILoginToken adminToken);
adminFacade.CreateNewAirline((LoginToken <Administrator>)adminToken, TestData.airline1);
ILoggedInAirlineFacade airlineFacade = (ILoggedInAirlineFacade)TestConfig.fcs.Login(TestData.airline1.UserName, TestData.airline1.Password, out ILoginToken airlineToken);
airlineFacade.ChangeMyPassword((LoginToken <AirlineCompany>)airlineToken, TestData.airline1.Password, "54321");
IAnonymousUserFacade anonymousFacade = (IAnonymousUserFacade)TestConfig.fcs.Login("", "", out ILoginToken anonymousToken);
Assert.AreEqual("54321", anonymousFacade.GetAirlineCompanyById(TestData.airline1.ID).Password);
}
public void CustomerControllerPurchaseTicketAPI()
{
ILoggedInAdministratorFacade adminFacade = (ILoggedInAdministratorFacade)TestConfig.fcs.Login(AirlineProjectConfig.TEST_ADMIN_USERNAME, AirlineProjectConfig.TEST_ADMIN_PASSWORD, out ILoginToken adminToken);
adminFacade.CreateNewAirline((LoginToken <Administrator>)adminToken, TestData.airline1);
adminFacade.CreateNewCustomer((LoginToken <Administrator>)adminToken, TestData.customer1);
Flight flight1 = new Flight(0, 0, TestData.argentinaID, TestData.barbadosID, TestData.futureDate1, TestData.futureDate2, 200);
ILoggedInAirlineFacade airlineFacade1 = (ILoggedInAirlineFacade)TestConfig.fcs.Login(TestData.airline1.UserName, TestData.airline1.Password, out ILoginToken airlineToken1);
airlineFacade1.CreateFlight((LoginToken <AirlineCompany>)airlineToken1, flight1);
// ----------------------------------------------
HttpClient client = new HttpClient();
client.BaseAddress = new Uri(CustomerURL);
// Add an Accept header for JSON format.
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
string customerCreds = string.Format($"{TestData.customer1.UserName}:{TestData.customer1.Password}");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.Default.GetBytes(customerCreds)));
HttpResponseMessage response = client.PostAsync("", new StringContent(JsonConvert.SerializeObject(flight1), Encoding.Default, "application/json")).Result;
Ticket purchasedTicket;
if (response.IsSuccessStatusCode)
{
purchasedTicket = response.Content.ReadAsAsync <Ticket>().Result;
}
else
{
purchasedTicket = new Ticket(0, 0, 0);
}
// -----------------------------------------------------------------------------
IAnonymousUserFacade anonymousFacade = (IAnonymousUserFacade)TestConfig.fcs.Login("testAnonymous", "99999", out ILoginToken anonymousToken);
IList <Flight> flights = anonymousFacade.GetAllFlights();
Flight purchasedFlight = flights[0];
Assert.AreEqual(TestData.customer1.ID, purchasedTicket.CustomerId);
Assert.AreEqual(purchasedFlight.ID, purchasedTicket.FlightId);
}
public void AdminFacadeCreateNewAirlineMethod()
{
ILoggedInAdministratorFacade adminFacade = (ILoggedInAdministratorFacade)TestConfig.fcs.Login(AirlineProjectConfig.ADMIN_USERNAME, AirlineProjectConfig.ADMIN_PASSWORD, out ILoginToken adminToken);
adminFacade.CreateNewAirline((LoginToken <Administrator>)adminToken, TestData.airline1);
IAnonymousUserFacade anonymousFacade = (IAnonymousUserFacade)TestConfig.fcs.Login("", "", out ILoginToken anonymousToken);
AirlineCompany actualAirline = anonymousFacade.GetAirlineCompanyById(TestData.airline1.ID);
Assert.AreEqual(TestData.airline1.ID, actualAirline.ID);
Assert.AreEqual(TestData.airline1.AirlineName, actualAirline.AirlineName);
Assert.AreEqual(TestData.airline1.UserName, actualAirline.UserName);
Assert.AreEqual(TestData.airline1.Password, actualAirline.Password);
Assert.AreEqual(TestData.airline1.CountryCode, actualAirline.CountryCode);
}
public void AddToCountryList(ILoggedInAdministratorFacade administratorFacade, LoginToken <Administrator> t)
{
Country country = null;
countryList = new List <string>();
country = new Country();
for (int i = 0; i < CountryArray.Names.Length - 1; i++)
{
country = administratorFacade.GetCountryByName(t, CountryArray.Names[i]);
if (country == null)
{
countryList.Add(CountryArray.Names[i]);
}
}
}
public void CustomerFacadePurchaseTicketMethodNoMoreTicketsException()
{
ILoggedInAdministratorFacade adminFacade = (ILoggedInAdministratorFacade)TestConfig.fcs.Login(AirlineProjectConfig.ADMIN_USERNAME, AirlineProjectConfig.ADMIN_PASSWORD, out ILoginToken adminToken);
adminFacade.CreateNewAirline((LoginToken <Administrator>)adminToken, TestData.airline1);
adminFacade.CreateNewCustomer((LoginToken <Administrator>)adminToken, TestData.customer1);
ILoggedInAirlineFacade airlineFacade1 = (ILoggedInAirlineFacade)TestConfig.fcs.Login(TestData.airline1.UserName, TestData.airline1.Password, out ILoginToken airlineToken1);
Flight flight1 = new Flight(0, 0, TestData.argentinaID, TestData.barbadosID, TestData.futureDate1, TestData.futureDate2, 0);
airlineFacade1.CreateFlight((LoginToken <AirlineCompany>)airlineToken1, flight1);
ILoggedInCustomerFacade customerFacade1 = (ILoggedInCustomerFacade)TestConfig.fcs.Login(TestData.customer1.UserName, TestData.customer1.Password, out ILoginToken customerToken1);
customerFacade1.PurchaseTicket((LoginToken <Customer>)customerToken1, flight1);
}
public void REMOVE_ALLDATA_FROM_DB()
{
bool actual = true;
LoginService ls = new LoginService();
LoginToken <Administrator> ltAdmin = null;
bool res = ls.TryAdminLogin("9999", "admin", out ltAdmin);
if (res == true)
{
FlyingCenterSystem fs = FlyingCenterSystem.Instance;
ILoggedInAdministratorFacade iAdminFS = fs.GetFacade <ILoggedInAdministratorFacade>();
iAdminFS.RemoveAllFromDB(ltAdmin);
actual = iAdminFS.CheckIfDBIsEmpty(ltAdmin);
Assert.IsTrue(actual);
}
}
public void AirlineFacadeCancelFlightMethod()
{
ILoggedInAdministratorFacade adminFacade = (ILoggedInAdministratorFacade)TestConfig.fcs.Login(AirlineProjectConfig.ADMIN_USERNAME, AirlineProjectConfig.ADMIN_PASSWORD, out ILoginToken adminToken);
adminFacade.CreateNewAirline((LoginToken <Administrator>)adminToken, TestData.airline1);
ILoggedInAirlineFacade airlineFacade = (ILoggedInAirlineFacade)TestConfig.fcs.Login(TestData.airline1.UserName, TestData.airline1.Password, out ILoginToken airlineToken);
Flight newFlight = new Flight(0, 0, TestData.argentinaID, TestData.barbadosID, TestData.futureDate1, TestData.futureDate2, 200);
airlineFacade.CreateFlight((LoginToken <AirlineCompany>)airlineToken, newFlight);
airlineFacade.CancelFlight((LoginToken <AirlineCompany>)airlineToken, newFlight);
IAnonymousUserFacade anonymousFacade = (IAnonymousUserFacade)TestConfig.fcs.Login("testAnonymous", "99999", out ILoginToken anonymousToken);
Assert.AreEqual(null, anonymousFacade.GetFlight(newFlight.ID));
}
public void AdminFacadeCreateNewCustomerMethod()
{
ILoggedInAdministratorFacade adminFacade = (ILoggedInAdministratorFacade)TestConfig.fcs.Login(AirlineProjectConfig.ADMIN_USERNAME, AirlineProjectConfig.ADMIN_PASSWORD, out ILoginToken adminToken);
adminFacade.CreateNewCustomer((LoginToken <Administrator>)adminToken, TestData.customer1);
Customer actualCustomer = TestConfig.testFacade.GetCustomerById(TestData.customer1.ID);
Assert.AreEqual(TestData.customer1.ID, actualCustomer.ID);
Assert.AreEqual(TestData.customer1.FirstName, actualCustomer.FirstName);
Assert.AreEqual(TestData.customer1.LastName, actualCustomer.LastName);
Assert.AreEqual(TestData.customer1.UserName, actualCustomer.UserName);
Assert.AreEqual(TestData.customer1.Password, actualCustomer.Password);
Assert.AreEqual(TestData.customer1.Address, actualCustomer.Address);
Assert.AreEqual(TestData.customer1.PhoneNo, actualCustomer.PhoneNo);
Assert.AreEqual(TestData.customer1.CreditCardNumber, actualCustomer.CreditCardNumber);
}
public void AirlineFacadeModifyAirlineDetailsMethodUsernameAlreadyExistsException()
{
ILoggedInAdministratorFacade adminFacade = (ILoggedInAdministratorFacade)TestConfig.fcs.Login(AirlineProjectConfig.ADMIN_USERNAME, AirlineProjectConfig.ADMIN_PASSWORD, out ILoginToken adminToken);
adminFacade.CreateNewAirline((LoginToken <Administrator>)adminToken, TestData.airline1);
adminFacade.CreateNewAirline((LoginToken <Administrator>)adminToken, TestData.airline2);
ILoggedInAirlineFacade airlineFacade1 = (ILoggedInAirlineFacade)TestConfig.fcs.Login(TestData.airline1.UserName, TestData.airline1.Password, out ILoginToken airlineToken1);
airlineFacade1.ModifyAirlineDetails((LoginToken <AirlineCompany>)airlineToken1, TestData.airline1);
ILoggedInAirlineFacade airlineFacade2 = (ILoggedInAirlineFacade)TestConfig.fcs.Login(TestData.airline2.UserName, TestData.airline2.Password, out ILoginToken airlineToken2);
AirlineCompany modifiedAirline = new AirlineCompany(TestData.airline2.ID, TestData.airline2.AirlineName, TestData.airline1.UserName, TestData.airline2.Password, TestData.airline2.CountryCode);
modifiedAirline.UserName = TestData.airline1.UserName;
airlineFacade2.ModifyAirlineDetails((LoginToken <AirlineCompany>)airlineToken2, modifiedAirline);
}
public IHttpActionResult GetAllAirlineCompanies()
{
GetLoginToken();
if (adminLoginToken == null)
{
return(Unauthorized());
}
FCS = FlyingCenterSystem.GetFlyingCenterSystemInstance();
ILoggedInAdministratorFacade administratorFacade = FCS.GetFacade(adminLoginToken) as ILoggedInAdministratorFacade;
IList <AirlineCompany> airlineCompanies = administratorFacade.GetAllAirlineCompanies(adminLoginToken);
if (airlineCompanies.Count == 0)
{
return(NotFound());
}
return(Ok(airlineCompanies));
}
public void AdminFacadeUpdateAirlineDetailsMethod()
{
ILoggedInAdministratorFacade adminFacade = (ILoggedInAdministratorFacade)TestConfig.fcs.Login(AirlineProjectConfig.TEST_ADMIN_USERNAME, AirlineProjectConfig.TEST_ADMIN_PASSWORD, out ILoginToken adminToken);
adminFacade.CreateNewAirline((LoginToken <Administrator>)adminToken, TestData.airline1);
AirlineCompany updatedAirline = new AirlineCompany(TestData.airline1.ID, "Alpho", "AlphoUser", "AlphoPass", TestData.argentinaID);
adminFacade.UpdateAirlineDetails((LoginToken <Administrator>)adminToken, updatedAirline);
IAnonymousUserFacade anonymousFacade = (IAnonymousUserFacade)TestConfig.fcs.Login("testAnonymous", "99999", out ILoginToken anonymousToken);
AirlineCompany actualAirline = anonymousFacade.GetAirlineCompanyById(TestData.airline1.ID);
Assert.AreEqual(updatedAirline.ID, actualAirline.ID);
Assert.AreEqual(updatedAirline.AirlineName, actualAirline.AirlineName);
Assert.AreEqual(updatedAirline.UserName, actualAirline.UserName);
Assert.AreEqual(updatedAirline.Password, actualAirline.Password);
Assert.AreEqual(updatedAirline.CountryCode, actualAirline.CountryCode);
}
public void AdministratorFacade_CreateNewCustomer_AddCustomer()
{
AddToLogFile("Run CreateNewCustome");
ILoggedInAdministratorFacade administratorFacade = GetAdministratorFacade(out LoginToken <Administrator> t);
newCustomer = CreateNewCustomer();
Customer c = administratorFacade.GetCustomerByUserName(t, newCustomer.USER_NAME);
if (c != null)
{
administratorFacade.RemoveCustomer(t, c);
}
long ID = administratorFacade.CreateNewCustomer(t, newCustomer);
newCustomer.ID = ID;
c = administratorFacade.GetCustomerById(t, ID);
Assert.AreEqual(c, newCustomer);
}
public void AirlineCompanyFacadeFacade_ModififyAirlineDetails_DetailsModified()
{
AirlineCompany newAirlineCompany = null;
InitDBUnitTest.InitDB();
AirlineCompany airlineCompany1 = AdministratorFacade_CreateNewAirline1();
ILoggedInAirlineFacade airlineCompanyFacade = GetAirlineCompanyFacade(out LoginToken <AirlineCompany> tAirlineCompany);
ILoggedInAdministratorFacade administratorFacade = GetAdministratorFacade(out LoginToken <Administrator> tAdministrator);
newAirlineCompany = CreateNewAirlineCompany();
newAirlineCompany.ID = airlineCompany1.ID;
newAirlineCompany.AIRLINE_NAME = TestResource.AirlineCompanyFacade_UpdatedName_AIRLINE_NAME;
newAirlineCompany.COUNTRY_CODE = airlineCompany1.COUNTRY_CODE;
airlineCompanyFacade.ModifyAirlineDetails(tAirlineCompany, newAirlineCompany);
AirlineCompany airlineCompany2 = administratorFacade.GetAirlineCompanyById(tAdministrator, newAirlineCompany.ID);
Assert.AreNotEqual(null, airlineCompany2);
Assert.AreEqual(TestResource.AirlineCompanyFacade_UpdatedName_AIRLINE_NAME, airlineCompany2.AIRLINE_NAME);
}
public void InsertCustomerToDb(ILoggedInAdministratorFacade administratorFacade, LoginToken <Administrator> t)
{
int counter = 0;
string path = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) + @"\JSON\MOCK_DATA.json";
string json = File.ReadAllText(path);
List <RootObject> playerList = JsonConvert.DeserializeObject <List <RootObject> >(json);
customersArray = new Customer[playerList.Count];
Customer newCustomer;
for (int i = 0; i < customersArray.Length; i++)
{
newCustomer = new Customer();
newCustomer.FIRST_NAME = playerList[i].FirstName;
newCustomer.LAST_NAME = playerList[i].LastName;
newCustomer.USER_NAME = playerList[i].UserName;
newCustomer.PASSWORD = playerList[i].Password;
newCustomer.ADDRESS = playerList[i].Address;
newCustomer.PHONE_NO = playerList[i].PhoneNumber;
newCustomer.CREDIT_CARD_NUMBER = playerList[i].CreditCardNumber;
customersArray[i] = newCustomer;
}
counter = 0;
while (true)
{
random1 = new Random();
index = random1.Next(0, customersArray.Length);
Customer customer = administratorFacade.GetCustomerByUserName(t, customersArray[index].USER_NAME);
if (customer == null)
{
administratorFacade.CreateNewCustomer(t, customersArray[index]);
progressCounter++;
Progress = 100 * progressCounter / totalResources;
CounterCustomers++;
break;
}
counter++;
if (counter > customersArray.Length)
{
break;
}
}
}
public void AnonymousFacadeGetAllFlightsVacancyMethod()
{
ILoggedInAdministratorFacade adminFacade = (ILoggedInAdministratorFacade)TestConfig.fcs.Login(AirlineProjectConfig.ADMIN_USERNAME, AirlineProjectConfig.ADMIN_PASSWORD, out ILoginToken adminToken);
adminFacade.CreateNewAirline((LoginToken <Administrator>)adminToken, TestData.airline1);
ILoggedInAirlineFacade airlineFacade = (ILoggedInAirlineFacade)TestConfig.fcs.Login(TestData.airline1.UserName, TestData.airline1.Password, out ILoginToken airlineToken);
Flight flight1 = new Flight(0, 0, TestData.argentinaID, TestData.barbadosID, TestData.futureDate1, TestData.futureDate2, 200);
Flight flight2 = new Flight(0, 0, TestData.chadID, TestData.denmarkID, TestData.futureDate1, TestData.futureDate2, 190);
airlineFacade.CreateFlight((LoginToken <AirlineCompany>)airlineToken, flight1);
airlineFacade.CreateFlight((LoginToken <AirlineCompany>)airlineToken, flight2);
IAnonymousUserFacade anonymousFacade = (IAnonymousUserFacade)TestConfig.fcs.Login("testAnonymous", "99999", out ILoginToken anonymousToken);
Dictionary <Flight, int> flightsVacancy = anonymousFacade.GetAllFlightsVacancy();
Assert.AreEqual(flight1.RemainingTickets, flightsVacancy[flight1]);
Assert.AreEqual(flight2.RemainingTickets, flightsVacancy[flight2]);
}
public void InsetTicketsToDb(ILoggedInAdministratorFacade administratorFacade, LoginToken <Administrator> t)
{
int count = 0;
int index1 = 0;
int index2 = 0;
IList <Customer> customerList = administratorFacade.GetAllCustomers(t);
Customer[] customerArray = new Customer[customerList.Count];
for (int i = 0; i < customerArray.Length; i++)
{
customerArray[i] = customerList[i];
}
IList <Flight> flightsList = administratorFacade.GetAllFlights(t);
Flight[] flightsArray = new Flight[flightsList.Count];
for (int i = 0; i < flightsArray.Length; i++)
{
flightsArray[i] = flightsList[i];
}
count = 0;
while (true)
{
random1 = new Random();
random2 = new Random();
index1 = random1.Next(0, customerArray.Length);
index2 = random2.Next(0, flightsArray.Length);
Ticket ticket = administratorFacade.GetTicketByCustomerId(t, customerArray[index1].ID);
if ((ticket == null || ticket.FLIGHT_ID != flightsArray[index2].ID) && !(flightsArray[index2].REMANING_TICKETS <= 0))
{
administratorFacade.AddTicket(t, customerArray[index1].ID, flightsArray[index2].ID);
progressCounter++;
Progress = 100 * progressCounter / totalResources;
counterTickets++;
break;
}
count++;
if (count > 10)
{
break;
}
}
}
public void AdministratorFacade_UpdateAirlineDetail_AirlineCompanyUpdated()
{
AddToLogFile("Run UpdateAirlineDetail");
AirlineCompany ua = null;
AirlineCompany updatedAirlineCompany = new AirlineCompany
{
AIRLINE_NAME = TestResource.AdministratorFacade_UpdateAirlineDetail_AirlineCompanyUpdated_AIRLINE_NAME,
USER_NAME = TestResource.AdministratorFacade_UpdateAirlineDetail_AirlineCompanyUpdated_USER_NAME,
PASSWORD = TestResource.AdministratorFacade_UpdateAirlineDetail_AirlineCompanyUpdated_PASSWORD,
};
ILoggedInAdministratorFacade administratorFacade = GetAdministratorFacade(out LoginToken <Administrator> t);
newAirlineCompany = CreateNewAirlineCompany();
AirlineCompany a = administratorFacade.GetAirlineCompanyByAirlineName(t, newAirlineCompany.AIRLINE_NAME);
if (a != null)
{
updatedAirlineCompany.ID = a.ID;
updatedAirlineCompany.COUNTRY_CODE = a.COUNTRY_CODE;
administratorFacade.UpdateAirlineDetails(t, updatedAirlineCompany);
}
else
{
newCountry1 = CreateNewCountry1();
Country c = administratorFacade.GetCountryByName(t, newCountry1.COUNTRY_NAME);
long countryCode = 0;
if (c == null)
{
countryCode = administratorFacade.CreateNewCountry(t, newCountry1);
newCountry1.ID = countryCode;
c = newCountry1;
}
newAirlineCompany.COUNTRY_CODE = c.ID;
long ID = administratorFacade.CreateNewAirline(t, newAirlineCompany);
updatedAirlineCompany.ID = ID;
updatedAirlineCompany.COUNTRY_CODE = newAirlineCompany.COUNTRY_CODE;
administratorFacade.UpdateAirlineDetails(t, updatedAirlineCompany);
}
ua = administratorFacade.GetAirlineCompanyById(t, updatedAirlineCompany.ID);
Assert.AreEqual(updatedAirlineCompany, ua);
}
public void AdminFacadeUpdateCustomerDetailsMethod()
{
ILoggedInAdministratorFacade adminFacade = (ILoggedInAdministratorFacade)TestConfig.fcs.Login(AirlineProjectConfig.ADMIN_USERNAME, AirlineProjectConfig.ADMIN_PASSWORD, out ILoginToken adminToken);
adminFacade.CreateNewCustomer((LoginToken <Administrator>)adminToken, TestData.customer1);
Customer updatedCustomer = new Customer(TestData.customer1.ID, "Alphonse", "Alric", "AlphonseUser", "AlphonsePass", "AlphonseAddress", "050-aaaaaaa", "creditaaa");
adminFacade.UpdateCustomerDetails((LoginToken <Administrator>)adminToken, updatedCustomer);
Customer actualCustomer = TestConfig.testFacade.GetCustomerById(TestData.customer1.ID);
Assert.AreEqual(updatedCustomer.ID, actualCustomer.ID);
Assert.AreEqual(updatedCustomer.FirstName, actualCustomer.FirstName);
Assert.AreEqual(updatedCustomer.LastName, actualCustomer.LastName);
Assert.AreEqual(updatedCustomer.UserName, actualCustomer.UserName);
Assert.AreEqual(updatedCustomer.Password, actualCustomer.Password);
Assert.AreEqual(updatedCustomer.Address, actualCustomer.Address);
Assert.AreEqual(updatedCustomer.PhoneNo, actualCustomer.PhoneNo);
Assert.AreEqual(updatedCustomer.CreditCardNumber, actualCustomer.CreditCardNumber);
}
public void ADD_COUNTRY2()
{
bool actual = false;
LoginService ls = new LoginService();
LoginToken <Administrator> ltAdmin = null;
bool res = ls.TryAdminLogin("9999", "admin", out ltAdmin);
if (res == true)
{
FlyingCenterSystem fs = FlyingCenterSystem.Instance;
ILoggedInAdministratorFacade iAdminFS = fs.GetFacade <ILoggedInAdministratorFacade>();
Country country = new Country(2, "Latvia");
iAdminFS.CreateCountry(ltAdmin, country);
if (country == iAdminFS.GetCountryByName(ltAdmin, "Latvia"))
{
actual = true;
}
Assert.IsTrue(actual);
}
}
public void AdministratorFacade_CreateNewCountry_AddCountry()
{
AddToLogFile("Run CreateNewCountry");
ILoggedInAdministratorFacade administratorFacade = GetAdministratorFacade(out LoginToken <Administrator> t);
newCountry1 = CreateNewCountry1();
long countryCode1 = administratorFacade.CreateNewCountry(t, newCountry1);
newCountry1.ID = countryCode1;
Country c1 = administratorFacade.GetCountryByCode(t, countryCode1);
newCountry2 = CreateNewCountry2();
long countryCode2 = administratorFacade.CreateNewCountry(t, newCountry2);
newCountry2.ID = countryCode2;
Country c2 = administratorFacade.GetCountryByCode(t, countryCode2);
Assert.AreEqual(c1, newCountry1);
Assert.AreEqual(c2, newCountry2);
}
public void UPDATE_CUSTOMER()
{
bool actual = false;
LoginService ls = new LoginService();
LoginToken <Administrator> ltAdmin = null;
bool res = ls.TryAdminLogin("9999", "admin", out ltAdmin);
if (res == true)
{
FlyingCenterSystem fs = FlyingCenterSystem.Instance;
ILoggedInAdministratorFacade iAdminFS = fs.GetFacade <ILoggedInAdministratorFacade>();
Customer customer = new Customer(1, "Naty", "kazman", "Naty", "121212", "Riga", "+371555555", "1234567876543212");
iAdminFS.UpdateCustomerDetails(ltAdmin, customer);
if (customer == iAdminFS.GetCustomerByid(ltAdmin, 1))
{
actual = true;
}
Assert.IsTrue(actual);
}
}
public void REMOVE_CUSTOMER()
{
bool actual = false;
LoginService ls = new LoginService();
LoginToken <Administrator> ltAdmin = null;
bool res = ls.TryAdminLogin("9999", "admin", out ltAdmin);
if (res == true)
{
FlyingCenterSystem fs = FlyingCenterSystem.Instance;
ILoggedInAdministratorFacade iAdminFS = fs.GetFacade <ILoggedInAdministratorFacade>();
Customer customer = new Customer(1, "Naty", "kazman", "Naty", "121212", "Riga", "+371555555", "1234567876543212");
iAdminFS.RemoveCustomer(ltAdmin, customer);
if (iAdminFS.CheckIfCustomersTableIsEmpty(ltAdmin))
{
actual = true;
}
Assert.IsTrue(actual);
}
}
public void CREATE_FLIGHT_STATUS2()
{
bool actual = false;
LoginService ls = new LoginService();
LoginToken <Administrator> ltAdmin = null;
bool res = ls.TryAdminLogin("9999", "admin", out ltAdmin);
if (res == true)
{
FlyingCenterSystem fs = FlyingCenterSystem.Instance;
ILoggedInAdministratorFacade iAdminFS = fs.GetFacade <ILoggedInAdministratorFacade>();
FlightStatus flStatus = new FlightStatus(2, "landing");
iAdminFS.CreateFlightStatus(ltAdmin, flStatus);
if (flStatus == iAdminFS.GetFlightStatusById(ltAdmin, 2))
{
actual = true;
}
Assert.IsTrue(actual);
}
}
public void CREATE_CUSTOMER2()
{
bool actual = false;
LoginService ls = new LoginService();
LoginToken <Administrator> ltAdmin = null;
bool res = ls.TryAdminLogin("9999", "admin", out ltAdmin);
if (res == true)
{
FlyingCenterSystem fs = FlyingCenterSystem.Instance;
ILoggedInAdministratorFacade iAdminFS = fs.GetFacade <ILoggedInAdministratorFacade>();
Customer customer = new Customer(2, "Inna", "Kibetz", "inna34", "0021", "oooooo1", "+9723488473", "11133355577767");
iAdminFS.CreateNewCustomer(ltAdmin, customer);
if (customer == iAdminFS.GetCustomerByid(ltAdmin, 2))
{
actual = true;
}
Assert.IsTrue(actual);
}
}
public IHttpActionResult UpdateAirlineDetails(int id, [FromBody] AirlineCompany airlineCompany)
{
GetLoginToken();
if (adminLoginToken == null)
{
return(Unauthorized());
}
FCS = FlyingCenterSystem.GetFlyingCenterSystemInstance();
ILoggedInAdministratorFacade administratorFacade = FCS.GetFacade(adminLoginToken) as ILoggedInAdministratorFacade;
airlineCompany = administratorFacade.GetAirlineCompanyById(adminLoginToken, id);
if (airlineCompany == null)
{
return(BadRequest("Id not found"));
}
else
{
administratorFacade.UpdateAirlineDetails(adminLoginToken, airlineCompany);
return(Ok($"Airline company with ID = {id} updated"));
}
}
public void InsertAdministratorsToDb(ILoggedInAdministratorFacade administratorFacade, LoginToken <Administrator> t)
{
int counter = 0;
string path = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) + @"\JSON\MOCK_DATA.json";
string json = File.ReadAllText(path);
List <RootObject> playerList = JsonConvert.DeserializeObject <List <RootObject> >(json);
admisitratorArray = new Administrator[playerList.Count];
Administrator newAdministrator = null;
for (int i = 0; i < admisitratorArray.Length; i++)
{
newAdministrator = new Administrator();
newAdministrator.FIRST_NAME = playerList[i].FirstName;
newAdministrator.LAST_NAME = playerList[i].LastName;
newAdministrator.USER_NAME = playerList[i].UserName;
newAdministrator.PASSWORD = playerList[i].Password;
admisitratorArray[i] = newAdministrator;
}
counter = 0;
while (true)
{
random1 = new Random();
index = random1.Next(0, admisitratorArray.Length);
Administrator administrator = administratorFacade.GetAdministratorByUserName(t, admisitratorArray[index].USER_NAME);
if (administrator == null)
{
administratorFacade.CreateNewAdministrator(t, admisitratorArray[index]);
progressCounter++;
Progress = 100 * progressCounter / totalResources;
counterAdministrator++;
break;
}
counter++;
if (counter > admisitratorArray.Length)
{
break;
}
}
}
public void InsertFlightsToDb(ILoggedInAdministratorFacade administratorFacade, LoginToken <Administrator> t)
{
Flight newFlight = null;
bool equalsOroginCountry = true;
IList <AirlineCompany> airlineCompaniesListFromDb = new List <AirlineCompany>();
airlineCompaniesListFromDb = administratorFacade.GetAllAirlineCompanies(t);
string[] airlineCompaniesArrayFromDb = new string[airlineCompaniesListFromDb.Count];
for (int i = 0; i < airlineCompaniesArrayFromDb.Length; i++)
{
airlineCompaniesArrayFromDb[i] = airlineCompaniesListFromDb[i].AIRLINE_NAME;
}
random1 = new Random();
index = random1.Next(0, airlineCompaniesArrayFromDb.Length);
AirlineCompany airlineCompany = administratorFacade.GetAirlineCompanyByAirlineName(t, airlineCompaniesArrayFromDb[index]);
newFlight = new Flight();
while (equalsOroginCountry)
{
random1 = new Random();
index = random1.Next(0, countriesToAddArray.Length);
Country destinationCountry = administratorFacade.GetCountryByName(t, countriesToAddArray[index]);
if (destinationCountry.ID != airlineCompany.COUNTRY_CODE)
{
newFlight.DESTINATION_COUNTRY_CODE = destinationCountry.ID;
equalsOroginCountry = false;
break;
}
}
newFlight.AIRLINECOMPANY_ID = airlineCompany.ID;
newFlight.ORIGIN_COUNTRY_CODE = airlineCompany.COUNTRY_CODE;
newFlight.DEPARTURE_TIME = RandomDepartureDate();
newFlight.LANDING_TIME = RandomLandingDate();
newFlight.REMANING_TICKETS = 300;
newFlight.TOTAL_TICKETS = 300;
administratorFacade.CreateFlight(t, newFlight);
progressCounter++;
Progress = 100 * progressCounter / totalResources;
counterFlights++;
}
public void AnonymousFacadeGetFlightsByOriginCountryMethod()
{
ILoggedInAdministratorFacade adminFacade = (ILoggedInAdministratorFacade)TestConfig.fcs.Login(AirlineProjectConfig.ADMIN_USERNAME, AirlineProjectConfig.ADMIN_PASSWORD, out ILoginToken adminToken);
adminFacade.CreateNewAirline((LoginToken <Administrator>)adminToken, TestData.airline1);
ILoggedInAirlineFacade airlineFacade = (ILoggedInAirlineFacade)TestConfig.fcs.Login(TestData.airline1.UserName, TestData.airline1.Password, out ILoginToken airlineToken);
Flight flight1 = new Flight(0, 0, TestData.argentinaID, TestData.barbadosID, TestData.futureDate1, TestData.futureDate2, 200);
Flight flight2 = new Flight(0, 0, TestData.argentinaID, TestData.chadID, TestData.futureDate1, TestData.futureDate3, 190);
Flight flight3 = new Flight(0, 0, TestData.barbadosID, TestData.chadID, TestData.futureDate2, TestData.futureDate3, 180);
airlineFacade.CreateFlight((LoginToken <AirlineCompany>)airlineToken, flight1);
airlineFacade.CreateFlight((LoginToken <AirlineCompany>)airlineToken, flight2);
airlineFacade.CreateFlight((LoginToken <AirlineCompany>)airlineToken, flight3);
IAnonymousUserFacade anonymousFacade = (IAnonymousUserFacade)TestConfig.fcs.Login("testAnonymous", "99999", out ILoginToken anonymousToken);
IList <Flight> flights = anonymousFacade.GetFlightsByOriginCountry(TestData.argentinaID);
Assert.AreEqual(flight1, flights[0]);
Assert.AreEqual(flight2, flights[1]);
Assert.AreEqual(2, flights.Count);
}
public void AnonymousFacadeGetFlightMethod()
{
ILoggedInAdministratorFacade adminFacade = (ILoggedInAdministratorFacade)TestConfig.fcs.Login(AirlineProjectConfig.ADMIN_USERNAME, AirlineProjectConfig.ADMIN_PASSWORD, out ILoginToken adminToken);
adminFacade.CreateNewAirline((LoginToken <Administrator>)adminToken, TestData.airline1);
ILoggedInAirlineFacade airlineFacade = (ILoggedInAirlineFacade)TestConfig.fcs.Login(TestData.airline1.UserName, TestData.airline1.Password, out ILoginToken airlineToken);
Flight flight1 = new Flight(0, 0, TestData.argentinaID, TestData.barbadosID, TestData.futureDate1, TestData.futureDate2, 200);
airlineFacade.CreateFlight((LoginToken <AirlineCompany>)airlineToken, flight1);
IAnonymousUserFacade anonymousFacade = (IAnonymousUserFacade)TestConfig.fcs.Login("testAnonymous", "99999", out ILoginToken anonymousToken);
Flight actualFlight = anonymousFacade.GetFlight(flight1.ID);
Assert.AreEqual(flight1.ID, actualFlight.ID);
Assert.AreEqual(flight1.AirlineCompanyId, actualFlight.AirlineCompanyId);
Assert.AreEqual(flight1.OriginCountryCode, actualFlight.OriginCountryCode);
Assert.AreEqual(flight1.DestinationCountryCode, actualFlight.DestinationCountryCode);
Assert.AreEqual(flight1.DepartureTime, actualFlight.DepartureTime);
Assert.AreEqual(flight1.LandingTime, actualFlight.LandingTime);
Assert.AreEqual(flight1.RemainingTickets, actualFlight.RemainingTickets);
}
//public ILoggedInAdministratorFacade adminFacade;
public bool TryGetConnector(out ILoggedInAdministratorFacade adminFacade, out LoginToken <Administrator> token)
{
if (Request.Properties["facade"] != null && Request.Properties["token"] != null)
{
if (Request.Properties["facade"] is ILoggedInAdministratorFacade && Request.Properties["token"] is LoginToken <Administrator> )
{
adminFacade = (ILoggedInAdministratorFacade)Request.Properties["facade"];
token = (LoginToken <Administrator>)Request.Properties["token"];
return(true);
}
}
adminFacade = null;
token = null;
return(false);
//ILoginToken token;
//airlineFacade = (ILoggedInAirlineFacade)fcs.Login("DeltaRune", "UnderTale", out token);
//return token;
}
