public void CompareGroupsUI_DB()
{
if (PERFORM_LONG_UI_CHECKS)
{
List <GroupData> fromUI = app.Groups.GetGroupList();
List <GroupData> fromDB = GroupData.GetAll();
fromUI.Sort();
fromDB.Sort();
Assert.AreEqual(fromUI, fromDB);
}
}
public void RemoveGroupTest()
{
List <GroupData> groupsBefore = GroupData.GetAll();
GroupData toBeRemoved = groupsBefore[0];
appManager.GroupHelper.RemoveGroup(toBeRemoved);
List <GroupData> groupsAfter = GroupData.GetAll();
Assert.AreEqual(groupsBefore.Count - 1, appManager.GroupHelper.GetGroupCount());
groupsBefore.RemoveAt(0);
Assert.AreEqual(groupsBefore, groupsAfter);
}
public void GroupCreationTest(GroupData newData)
{
List <GroupData> oldGroups = GroupData.GetAll();
app.Groups.Create(newData);
Assert.AreEqual(oldGroups.Count + 1, app.Groups.GetGroupCount());
oldGroups.Add(newData);
List <GroupData> newGroups = GroupData.GetAll();
oldGroups.Sort();
newGroups.Sort();
Assert.AreEqual(oldGroups, newGroups);
}
public void CompareGroupsFromUiWithDB()
{
if (!IsCompareUiWithDb)
{
return;
}
var fromUi = appManager.GroupHelper.GetGroupsList();
var fromDb = GroupData.GetAll();
fromUi.Sort();
fromDb.Sort();
Assert.AreEqual(fromUi, fromDb);
}
public void GroupCreationTest(GroupData groupData)
{
List <GroupData> oldGroup = GroupData.GetAll();
app.GroupH.Create(groupData);
oldGroup.Add(groupData);
List <GroupData> newGroup = GroupData.GetAll();
oldGroup.Sort();
newGroup.Sort();
Assert.AreEqual(oldGroup, newGroup);
}
public void TestDBConnectivity()
{
DateTime start = DateTime.Now;
List <GroupData> fromUi = app.Groups.GetGroupList();
DateTime end = DateTime.Now;
System.Console.Out.WriteLine(end.Subtract(start));
start = DateTime.Now;
List <GroupData> fromDb = GroupData.GetAll();
end = DateTime.Now;
System.Console.Out.WriteLine(end.Subtract(start));
}
//[Test, TestCaseSource("GroupDataFromXmlFile")]
//[Test, TestCaseSource("RandomGroupDataProvider")]
//[Test, TestCaseSource("GroupDataFromFile")]
public void NewGroupCreation(GroupData group)
{
List <GroupData> oldGroups = GroupData.GetAll();
app.Groups.Create(group);
Assert.AreEqual(oldGroups.Count + 1, app.Groups.GetGroupCount());
List <GroupData> newGroups = GroupData.GetAll();
oldGroups.Add(group);
oldGroups.Sort();
newGroups.Sort();
Assert.AreEqual(oldGroups, newGroups);
}
public void TestAddContactToGroup()
{
var groupData = GroupData.GetAll()[0];
var oldList = groupData.GetContacts();
var contact = ContactData.GetAll().Except(oldList).First();
appManager.ContactHelper.AddContactToGroup(contact, groupData);
var newList = groupData.GetContacts();
oldList.Add(contact);
newList.Sort();
oldList.Sort();
Assert.AreEqual(oldList, newList);
}
public void TestRemoveContactToGroup()
{
GroupData group = GroupData.GetAll()[0];
List <UserData> oldList = group.GetContactsInGroup(); //читаем начальное значение
UserData contact = UserData.GetAll().Except(oldList).First(); //исключаем
appManager.User.RemoveContactToGroup(contact, group);
List <UserData> newList = group.GetContacts(); //читаем начальное значение
oldList.Add(contact);
newList.Sort();
oldList.Sort();
Assert.AreEqual(oldList, newList);
}
public void TestAddingContactToGroup()
{
GroupData group = GroupData.GetAll()[0];
List <ContactData> oldList = group.GetContacts();
ContactData contact = ContactData.GetAll().Except(oldList).First();
app.Contacts.AddContactToGroup(contact, group);
List <ContactData> newList = group.GetContacts();
oldList.Add(contact);
newList.Sort();
oldList.Sort();
Assert.AreEqual(oldList, newList);
}
public void TestRemovingContactFromGroup()
{
GroupData group = GroupData.GetAll()[0];
List <ContactData> oldListContacts = group.GetContacts();
ContactData contact = ContactData.GetAll().First();
app.Contacts.RemoveContactFromGroup(contact, group);
//actions
List <ContactData> newListContacts = group.GetContacts();
oldListContacts.Remove(contact);
oldListContacts.Sort();
newListContacts.Sort();
Assert.AreEqual(oldListContacts, newListContacts);
}
public void GroupCreationTest(GroupData group)
{
//action
//1. get old list
List <GroupData> oldGroups = GroupData.GetAll(); //get from DB
//2. create
app.Groups.Create(group);
//verification
List <GroupData> newGroups = GroupData.GetAll(); //get new list
oldGroups.Add(group);
oldGroups.Sort();
newGroups.Sort();
Assert.AreEqual(oldGroups, newGroups); //compare data
Assert.AreEqual(oldGroups.Count, newGroups.Count); //compare count
}
public void TestAddingContactToGroup()
{
GroupData group = GroupData.GetAll()[0];
//получаем список контактов, не входящих в выбранную группу, и берем первый из списка
List <ContactData> oldList = group.GetContacts();
ContactData contact = ContactData.GetAll().Except(oldList).First();
//действия
app.Contacts.AddContactToGroup(contact, group);
List <ContactData> newList = group.GetContacts();
oldList.Add(contact);
oldList.Sort();
newList.Sort();
Assert.AreEqual(oldList, newList);
}
public void TestRemoveContactFromGroup()
{
GroupData group = GroupData.GetAll()[0]; //select group with index 0 = from DB
List <ContactData> oldList = group.GetContacts(); //list of contacts in group [0]
ContactData contact = ContactData.GetAll().Except(oldList).First(); //1) full list 2)except those group [0] 3)select the fisrt
//actions on UI
//app.Contacts.RemoveContactFromGroup(contact, group);
//verification
List <ContactData> newList = group.GetContacts();
oldList.Add(contact);
newList.Sort();
oldList.Sort();
Assert.AreEqual(oldList, newList);
}
public void GroupCreationTest(GroupData data)
{
appManager.NavigationHelper.GoToGroupsPage();
List <GroupData> groupsBefore = GroupData.GetAll();
appManager.GroupHelper.CreateNewGroup(data);
appManager.NavigationHelper.ReturnToGroupsPage();
List <GroupData> groupsAfter = GroupData.GetAll();
Assert.AreEqual(groupsBefore.Count + 1, appManager.GroupHelper.GetGroupCount());
groupsBefore.Add(data);
groupsAfter.Sort();
groupsBefore.Sort();
Assert.AreEqual(groupsBefore, groupsAfter);
}
public void GroupRemovalTest()
{
List <GroupData> oldGroups = GroupData.GetAll();
var toBeRemoved = oldGroups[0];
app.Groups.Remove(toBeRemoved);
Assert.AreEqual(oldGroups.Count - 1, app.Groups.GetGroupCount());
List <GroupData> newGroups = GroupData.GetAll();
oldGroups.RemoveAt(0);
Assert.AreEqual(oldGroups, newGroups);
foreach (var group in newGroups)
{
Assert.AreNotEqual(group.Id, toBeRemoved.Id);
}
}
public void TestDBConnectivity()
{
/*
* DateTime start = DateTime.Now;
* List<GroupData> fromUI = app.Groups.GetGroupList();
* DateTime end = DateTime.Now;
* System.Console.Out.WriteLine(end.Subtract(start));
*
* start = DateTime.Now;
* List<GroupData> fromDB = GroupData.GetAll();
* end = DateTime.Now;
* System.Console.Out.WriteLine(end.Subtract(start));
*/
foreach (ContactData contact in GroupData.GetAll()[0].GetContacts())
{
System.Console.Out.WriteLine(contact);
}
}
public void RemoveContactFromGroup()
{
GroupData group = GroupData.GetAll()[0];
List <ContactData> oldList = group.GetContacts();
if (oldList.Count == 0)
{
app.Contacts.AddContactDataToGroup(ContactData.GetAll()[0], group);
}
ContactData contactToBeRemoved = group.GetContacts()[0];
app.Contacts.RemoveContactDataFromGroup(contactToBeRemoved, group);
List <ContactData> newList = group.GetContacts();
oldList.Remove(contactToBeRemoved);
newList.Sort();
oldList.Sort();
Assert.AreEqual(oldList, newList);
}
public void GroupModificationTests()
{
List <GroupData> groupsBefore = GroupData.GetAll();
GroupData toBeModified = groupsBefore[0];
var data = new GroupData(
$"groupName{Guid.NewGuid()}",
$"groupHeader{Guid.NewGuid()}",
$"groupFooter{Guid.NewGuid()}");
appManager.GroupHelper.EditGroup(toBeModified, data);
appManager.NavigationHelper.ReturnToGroupsPage();
List <GroupData> groupsAfter = GroupData.GetAll();
Assert.AreEqual(groupsBefore.Count, appManager.GroupHelper.GetGroupCount());
groupsBefore[0] = data;
groupsAfter.Sort();
groupsBefore.Sort();
Assert.AreEqual(groupsBefore, groupsAfter);
}
public void GroupRemovalTest()
{
if (!app.Groups.GroupExists())
{
app.Groups.Create(new GroupData("1", "2", "3"));
}
List <GroupData> oldGroups = GroupData.GetAll();
GroupData toBeRemoved = oldGroups[0];
app.Groups.Remove(0);
Assert.AreEqual(oldGroups.Count - 1, app.Groups.GetGroupCount());
List <GroupData> newGroups = GroupData.GetAll();
//GroupData toBeRemoved = oldGroups[0];
oldGroups.RemoveAt(0);
Assert.AreEqual(oldGroups, newGroups);
foreach (GroupData group in newGroups)
{
Assert.AreNotEqual(group.Id, toBeRemoved.Id);
}
}
public void TestDBConnect()
{
DateTime start = DateTime.Now;
List <GroupData> fromUI = appManager.Groups.GetGroupList();
DateTime end = DateTime.Now;
Console.Out.Write(end.Subtract(start)); //из конца вычитаем начало интервала
start = DateTime.Now;
/*using (AddressBookDB db = new AddressBookDB()) //перенесли метод в GroupData
* {
* return List < GroupData > fromDB = (from g in db.Groups select g).ToList();
* //db.Close(); //используя using метод выполняется автоматически
* }*/
List <GroupData> fromDB = GroupData.GetAll();
end = DateTime.Now;
Console.Out.Write(end.Subtract(start));
}
public void GroupModificationTest()
{
if (!app.Groups.IsGroupPresent())
{
//Создание группы
GroupCreationTests newGroup = new GroupCreationTests();
newGroup.SetupApplicationManager();
IEnumerable <GroupData> grData = GroupCreationTests.RandomGroupDataProvider();
newGroup.GroupCreationTest(grData.ElementAt(1));
}
List <GroupData> oldGroups = GroupData.GetAll();
GroupData oldData = oldGroups[0];
//Изменение группы
GroupData newData = new GroupData(GenerateRandomString(5))
{
Header = GenerateRandomString(10),
Footer = GenerateRandomString(10)
};
app.Groups.Modify(oldData, newData);
Assert.AreEqual(oldGroups.Count, app.Groups.GetGroupCount());
List <GroupData> newGroups = GroupData.GetAll();
oldGroups[0].Name = newData.Name;
oldGroups.Sort();
newGroups.Sort();
Assert.AreEqual(oldGroups, newGroups);
foreach (GroupData group in newGroups)
{
if (group.Id == oldData.Id)
{
Assert.AreEqual(newData.Name, group.Name);
}
}
}
public void GroupRemovalTest()
{
if (!appManager.Groups.GroupIsAvailable())
{
GroupData group = new GroupData("name");
group.Header = "header";
group.Footer = "footer";
appManager.Groups.Create(group);
Console.Out.Write("group added");
appManager.Groups.Remove(0);
//редко необходимая проверка
int count = appManager.Groups.GetGroupCount();
Console.Out.Write("group deleted");
}
else //если группы нет - создаем перед удалением
{
//List<GroupData> oldGroups = appManager.Groups.GetGroupList(); //читаем начальное количество элементов групп
List <GroupData> oldGroups = GroupData.GetAll(); //замена операции
GroupData toBeRemoved = oldGroups[0];
appManager.Groups.Remove(toBeRemoved); //передаем 0, а не 1 т.к поправили XPath
//редко необходимая проверка
int count = appManager.Groups.GetGroupCount();
Assert.AreEqual(oldGroups.Count - 1, count);
Console.Out.Write("group deleted");
List <GroupData> newGroups = GroupData.GetAll(); //читаем значение после выполнения удаления группы
//GroupData toBeRemoved = oldGroups[0];
oldGroups.RemoveAt(0); //удаляем элемент
Assert.AreEqual(oldGroups, newGroups); //сравнение списков
foreach (GroupData group in newGroups)
{
Assert.AreNotEqual(group.Id, toBeRemoved.Id);
}
}
}
public void AddingContactToGroup()
{
GroupData group = GroupData.GetAll()[0];
List <ContactData> oldList = group.GetContacts();
IEnumerable <ContactData> contactsNotInGroup = ContactData.GetAll().Except(oldList);
if (!contactsNotInGroup.Any())
{
app.Contacts.InitContactCreation();
app.Contacts.Create(new ContactData("test", "contact"));
}
ContactData contact = ContactData.GetAll().Except(oldList).First();
app.Contacts.AddContactDataToGroup(contact, group);
List <ContactData> newList = group.GetContacts();
oldList.Add(contact);
newList.Sort();
oldList.Sort();
Assert.AreEqual(oldList, newList);
}
public void GroupModificationTest()
{
GroupData newDataG = new GroupData("Friends");
newDataG.Header = null;
newDataG.Footer = null;
GroupData group = new GroupData("Colleagues");
group.Header = "Head";
group.Footer = "Goal";
app.Navigator.GoToGroupsPage();
if (!app.Groups.IsGroupExist())
{
app.Groups.Create(group);
}
List <GroupData> oldGroups = GroupData.GetAll();
GroupData oldData = oldGroups[0];
app.Groups.Modify(group, 1, newDataG);
Assert.AreEqual(oldGroups.Count, app.Groups.GetGroupCount());
List <GroupData> newGroups = GroupData.GetAll();
oldGroups.Sort();
newGroups.Sort();
Assert.AreEqual(oldGroups, newGroups);
foreach (GroupData groupM in newGroups)
{
if (groupM.Id == oldData.Id)
{
Assert.AreEqual(newDataG.Name, groupM.Name);
}
}
}
public void AddingContactToGroupTest()
{
ContactData tempData = new ContactData("q", "q");
GroupData tempGroup = new GroupData("z", "z", "z");
app.ContactH.CheckCountContacts(tempData);
app.GroupH.CheckCountGroups(tempGroup);
//-------------------
GroupData group = new GroupData();
ContactData contact = ContactData.GetAll().First();
List <GroupData> contactGroups = contact.GetGroups();
IEnumerable <GroupData> freeGroups = GroupData.GetAll().Except(contactGroups);
if (freeGroups.Count() == 0)
{
app.ContactH.Create(tempData);
contact = ContactData.GetAll().Last();
freeGroups = GroupData.GetAll();
}
group = freeGroups.First();
List <ContactData> oldCont = group.GetContacts();
//-------------------
app.ContactH.AddContactToGroup(contact, group);
List <ContactData> newCont = group.GetContacts();
oldCont.Add(contact);
oldCont.Sort();
newCont.Sort();
Assert.AreEqual(oldCont, newCont);
}
public void DeleteContactFromGroupTest()
{
ContactData tempData = new ContactData("q", "q");
GroupData tempGroup = new GroupData("z", "z", "z");
app.ContactH.CheckCountContacts(tempData);
app.GroupH.CheckCountGroups(tempGroup);
//-----------------
GroupData group = new GroupData();
ContactData contact = ContactData.GetAll().First();
List <GroupData> contactGroups = contact.GetGroups();
if (contactGroups.Count() == 0)
{
group = GroupData.GetAll().First();
app.ContactH.AddContactToGroup(contact, group);
}
else
{
group = contactGroups.First();
}
List <ContactData> oldCont = group.GetContacts();
//-----------------
app.ContactH.RemoveContactFromGroup(contact, group);
List <ContactData> newCont = group.GetContacts();
oldCont.Remove(contact);
oldCont.Sort();
newCont.Sort();
Assert.AreEqual(oldCont, newCont);
}
public void GroupModificationTest()
{
GroupData newData = new GroupData("fff");
List <GroupData> oldGroups = GroupData.GetAll();
GroupData toBeChanged = oldGroups[0];
app.Groups.Modify(newData, toBeChanged);
Assert.AreEqual(oldGroups.Count, app.Groups.GetGroupCount());
List <GroupData> newGroups = GroupData.GetAll();
oldGroups[0].Name = newData.Name;
oldGroups.Sort();
newGroups.Sort();
Assert.AreEqual(oldGroups, newGroups);
foreach (var group in newGroups)
{
if (group.Id == toBeChanged.Id)
{
Assert.AreEqual(newData.Name, group.Name);
}
}
}
public void GroupModificationTest()
{
GroupData groupToModify = new GroupData("grouptomodify");
GroupData newData = new GroupData("qwerty");
newData.Header = null;
newData.Footer = null;
if (!app.Groups.GroupPresent())
{
app.Groups.Create(groupToModify);
}
List <GroupData> oldGroups = GroupData.GetAll();
GroupData oldData = oldGroups[0];
app.Groups.Modify(0, newData);
Assert.AreEqual(oldGroups.Count, app.Groups.GetGroupCount());
List <GroupData> newGroups = GroupData.GetAll();
oldGroups[0].Name = newData.Name;
oldGroups.Sort();
newGroups.Sort();
Assert.AreEqual(oldGroups, newGroups);
foreach (GroupData group in newGroups)
{
if (group.Id == oldData.Id)
{
Assert.AreEqual(newData.Name, group.Name);
}
}
}
public void GroupRemovalTest()
{
GroupData group = new GroupData("Colleagues");
group.Header = "Head";
group.Footer = "Goal";
app.Navigator.GoToGroupsPage();
if (!app.Groups.IsGroupExist())
{
app.Groups.Create(group);
}
List <GroupData> oldGroups = GroupData.GetAll();
GroupData toBeRemoved = oldGroups[0];
//app.Groups.Remove(group, 0);
app.Groups.Remove(toBeRemoved);
Assert.AreEqual(oldGroups.Count - 1, app.Groups.GetGroupCount());
List <GroupData> newGroups = GroupData.GetAll();
//GroupData toBeRemoved = oldGroups[0];
oldGroups.RemoveAt(0);
oldGroups.Sort();
newGroups.Sort();
Assert.AreEqual(oldGroups, newGroups);
foreach (GroupData groupF in newGroups)
{
Assert.AreNotEqual(groupF.Id, toBeRemoved.Id);
}
}
