public void CreateAccountAndDeleteAccount()
{
string CurEmailID = Guid.NewGuid().ToString().Substring(0, 5) + "@gmail.com";
GeneralThreadAffineContext.Run(async() =>
{
App.Locator.Login.UserEmail = CurEmailID;
App.Locator.Login.UserPassword = "******";
var result = await App.Locator.Login.CreateAccount("TestFirstName"
, "TestLastName"
, "TestModel"
, "TestPlateform"
, "TestVersion"
, _uniqueDeviceId
, "fr");
var data = ServiceLocator.Current.GetInstance <IDataService>();
string Userid = App.CurrentUserEnvironment.User.IdUser.ToString();
var deleteuserresult = await data.DeleteUser(Userid);
bool expectedAnswer = false;
if (result == true && deleteuserresult == 1)
{
expectedAnswer = true;
}
Assert.AreEqual(result, expectedAnswer);
});
}
/// <summary>
/// Executes all needed code necessary for a test run of this instance in a particular order.
/// </summary>
public void Run()
{
this.specification.Initialize();
this.DetermineTypesOfThisSpec();
this.ExecuteExtensions(WorkflowPosition.TypeRegistration);
this.specification.RegisterTypes();
this.ExecuteExtensions(WorkflowPosition.SUTCreation);
if (this.specification.WorkflowExtension != null)
{
this.specification.WorkflowExtension();
}
this.ExecuteExtensions(WorkflowPosition.Default, WorkflowPosition.Given);
this.specification.Given();
GeneralThreadAffineContext.Run(this.specification.GivenAsync);
this.ExecuteExtensions(WorkflowPosition.When);
this.specification.When();
GeneralThreadAffineContext.Run(this.specification.WhenAsync);
}
public void V_DeleteUser()
{
GeneralThreadAffineContext.Run(async() =>
{
int expectedAnswer = 1;
var result = await _dataService.DeleteUser(_iduser.ToString());
Assert.AreEqual(result, expectedAnswer);
});
}
/// <summary>
/// This method returns:
/// -1 if failed
/// x>0 if worked
/// </summary>
private void DeleteMode()
{
GeneralThreadAffineContext.Run(async() =>
{
string id = _idmode.ToString();
var result = await _dataService.DeleteMode(id);
AssertN1IsBiggerThanN2(result, 1);
});
}
public void U_DeleteSeekios()
{
GeneralThreadAffineContext.Run(async() =>
{
int id = _idseekios;
int expectedAnswer = 1;
var result = await _dataService.DeleteSeekios(id);
Assert.AreEqual(result, expectedAnswer);
});
}
public void I_RequestBatteryLevel()
{
//Asserting it worked
GeneralThreadAffineContext.Run(async() =>
{
int expectedAnswer = 1;
var result = await _dataService.RequestBatteryLevel(_idseekios);
Assert.AreEqual(result, expectedAnswer);
});
}
public void H_RefreshSeekios()
{
//Asserting everything is ok
GeneralThreadAffineContext.Run(async() =>
{
var result = await _dataService.RefreshSeekios(_idseekios,
_iduser);
Assert.IsNotNull(result);
});
}
public void F_InsertSeekios()
{
//Asserting evrything went ok
GeneralThreadAffineContext.Run(async() =>
{
var result = await _dataService.InsertSeekios(_seekios);
_idseekios = result.Idseekios;
Assert.IsNotNull(result);
});
}
public void S_InsertModeDontMove()
{
GeneralThreadAffineContext.Run(async() =>
{
_mode.ModeDefinition_idmodeDefinition = (int)ModeDefinitionEnum.ModeDontMove;
_mode.Device_iddevice = _idDevice;
var result = await _dataService.InsertModeDontMove(_mode, alertes);
_idmode = result;
AssertN1IsBiggerThanN2(result, 1);
});
}
public void K_UpdateMode()
{
GeneralThreadAffineContext.Run(async() =>
{
_mode.Device_iddevice = _idDevice;
_mode.Idmode = _idmode;
_mode.Trame = "2";
var result = await _dataService.UpdateMode(_mode);
AssertN1IsBiggerThanN2(result, 1);
});
}
public void G_UpdateSeekios()
{
//Asserting update went ok
GeneralThreadAffineContext.Run(async() =>
{
_seekios.SeekiosName = "UnitTestSeekios2";
_seekios.Idseekios = _idseekios;
var result = await _dataService.UpdateSeekios(_seekios);
AssertN1IsBiggerThanN2(result, 1);
});
}
public void Q_InsertMode()
{
GeneralThreadAffineContext.Run(async() =>
{
//Asserting evrything is ok : we insert the mode zone previously inserted
//it will only have a different id
_mode.Device_iddevice = _idDevice;
var result = await _dataService.InsertMode(_mode);
_idmode = result;
AssertN1IsBiggerThanN2(result, 1);
});
}
public void J_InsertModeZone()
{
GeneralThreadAffineContext.Run(async() =>
{
//Asserting it worked
_mode.ModeDefinition_idmodeDefinition = (int)ModeDefinitionEnum.ModeZone;
_mode.Device_iddevice = _idDevice;
var result = await _dataService.InsertModeZone(_mode, _listAlertWithRecipient);
_idmode = result;
AssertN1IsBiggerThanN2(result, 1);
});
}
public void C_UpdateUser()
{
GeneralThreadAffineContext.Run(async() =>
{
//Asserting we managed to update the user
_user.FirstName = "TestFirstname2";
_user.LastName = "TestLastname2";
_user.IdUser = _iduser;
var result = await _dataService.UpdateUser(_user);
AssertN1IsBiggerThanN2(result, 1);
});
}
public void N_UpdateAlertWithRecipient()
{
GeneralThreadAffineContext.Run(async() =>
{
//Asserting everything went ok
_alertwithrecipient.IdAlert = _idalert;
_alertwithrecipient.Title = "Test 3";
_alertwithrecipient.Content = "Test 3";
_alertwithrecipient.LsRecipients.First().IdAlert = _idalert;
var result = await _dataService.UpdateAlertWithRecipient(_alertwithrecipient);
AssertN1IsBiggerThanN2(result, 1);
});
}
public void M_UpdateAlert()
{
GeneralThreadAffineContext.Run(async() =>
{
//Asserting everything went ok
_alert.IdAlert = _idalert;
_alert.Title = "Test 2";
_alert.IdMode = _idmode;
var result = await _dataService.UpdateAlert(_alert);
AssertN1IsBiggerThanN2(result, 1);
});
}
public void A_IsSeekiosVersionApplicationNeedForceUpdate()
{
GeneralThreadAffineContext.Run(async() =>
{
//Asserting we need to update : case 1
var result = await _dataService.IsSeekiosVersionApplicationNeedForceUpdate("1.01.3010.807", "1");
Assert.AreEqual(result, 1);
//Asserting we don't need to update : case 0
var result2 = await _dataService.IsSeekiosVersionApplicationNeedForceUpdate(LAST_APP_VERSION, "1");
Assert.AreEqual(result2, 0);
});
}
public void AutoConnect()
{
GeneralThreadAffineContext.Run(async() =>
{
App.Locator.Login.Email = _Email;
App.Locator.Login.Password = _PasswordHash;
var result = await App.Locator.Login.AutoConnect("TestModel"
, "TestPlateform"
, "TestVersion"
, _uniqueDeviceId
, "fr");
bool expectedAnswer = true;
Assert.AreEqual(result, expectedAnswer);
});
}
public void B_InsertUser()
{
GeneralThreadAffineContext.Run(async() =>
{
//Asserting the user is correctly added : case return IdUser
var result = await _dataService.InsertUser(_user);
_iduser = result;
AssertN1IsBiggerThanN2(result, 1);
//Asserting the user already exists : case 0
//we might need to wait a little bit as the database is being updated (to be tested)
var result2 = await _dataService.InsertUser(_user);
Assert.AreEqual(result2, 0);
});
}
public void L_GetAlertsByMode()
{
GeneralThreadAffineContext.Run(async() =>
{
//Asserting everything is ok
int expectedAnswer = 1;
_mode.ModeDefinition_idmodeDefinition = (int)ModeDefinitionEnum.ModeZone;
_mode.Device_iddevice = _idDevice;
_mode.Idmode = _idmode;
var result = await _dataService.GetAlertsByMode(_mode);
Assert.IsNotNull(result);
var result2 = result.Count;
_idalert = result.First().IdAlert;
Assert.AreEqual(result2, expectedAnswer);
});
}
public void Login_Disconnect()
{
GeneralThreadAffineContext.Run(async() =>
{
App.CurrentUserEnvironment.User = _user;
var result = await App.Locator.Login.Disconnect();
int expectedAnswer = 1;
if (result == 1)
{
Assert.AreEqual(result, expectedAnswer);
}
else if (result == -1)
{
expectedAnswer = -1;
Assert.AreEqual(result, expectedAnswer);
}
else
{
Assert.AreEqual(result, expectedAnswer);
}
});
}
