def test_update_random_group_name(app): if app.group.count() == 0: app.group.create(Group(name="Group to be updated")) old_groups = app.group.get_group_list() index = randrange(len(old_groups)) group = Group(name="Updated Group Name") group.id = old_groups[index].id app.group.update_group_by_index(group, index) assert len(old_groups) == app.group.count() new_groups = app.group.get_group_list() group.header = old_groups[index].header group.footer = old_groups[index].footer group.id = old_groups[index].id old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_modify_group(app, db, check_ui): with allure.step("If there are no group create one"): if len(db.get_group_list()) == 0: app.group.create(Group(name="Group for modification")) with allure.step("Given a list of groups and the data for modification"): old_groups = db.get_group_list() old_group = random.choice(old_groups) group = Group() # Prepare data group.name = "%s %s" % (old_group.name, RandomData.get_random_string()) group.header = "%s %s" % (old_group.header, RandomData.get_random_string()) group.footer = "%s %s" % (old_group.footer, RandomData.get_random_string()) group.id = old_group.id with allure.step("When modifying the group"): app.group.modify_by_id(group.id, group) with allure.step( "Then the new list of groups is equal to the old list with a modified group" ): new_groups = db.get_group_list() old_groups.remove(old_group) old_groups.append(group) assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: for i in range(0, len(new_groups)): new_groups[i] = new_groups[i].clear() assert sorted(new_groups, key=Group.id_or_max) == sorted( app.group.get_group_list(), key=Group.id_or_max)
def test_modify_group_name(app, db, check_ui): with allure.step("If there are no groups create one"): if len(db.get_group_list()) == 0: app.group.create(Group(name="Group for modification")) with allure.step("Given a list of groups"): old_groups = db.get_group_list() old_group = random.choice(old_groups) group = Group(name="Only name " + str(old_group.id)) group.id = old_group.id with allure.step("When modifying only the name of the group"): app.group.modify_by_id(old_group.id, group) with allure.step( "Then the new list of groups is equal to the old list with a modified group" ): new_groups = db.get_group_list() old_groups.remove(old_group) old_groups.append(group.clear()) assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: for i in range(0, len(new_groups)): new_groups[i] = new_groups[i].clear() assert sorted(new_groups, key=Group.id_or_max) == sorted( app.group.get_group_list(), key=Group.id_or_max)
def get_groups(self, uname): # get all groups for this user group = None user_groups = None try: collection = self.user_collection user_groups = collection.find_one({'_id':uname},{"groups":True}) except Exception as inst: print "error reading groups" print inst if user_groups != None: group_cursor = user_groups["groups"] groups = [] for item in group_cursor: print item group = Group() group.id = str(item["_id"]) group.name = item["name"] group.hash = item["hash"] groups.append(group) return groups else: return None
def test_edit_group_name(app, db, check_ui): if app.group.count() == 0: # falls keine Gruppe gibt´s app.group.create(Group(name="New_group")) # erstellen wir eine Gruppe old_groups = db.get_group_list() # Liste der Gruppen bevors Hinzufügen einer neuen Gruppe # index = randrange(len(old_groups)) group = random.choice(old_groups) old_groups.remove(group) edit_group = Group(name="Edit_group") edit_group.id = group.id # eine id von der alte gruppe behalten wir bei old_groups.append(edit_group) app.group.edit_group_by_id(group.id, edit_group) new_groups = db.get_group_list() #assert len(old_groups) == len(new_groups) assert sorted(new_groups, key=Group.id_or_max) == sorted(old_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted(app.group.get_group_list(), key=Group.id_or_max)
def test_edit_random_group(app, db, check_ui): with allure.step('Create group if not exists'): if app.group.count() == 0: app.group.create( Group(name="created group", footer="created logo of group", header="created comment for group")) group = Group(name="edited_test group", footer="edited_logo of group", header="edited_comment for group") with allure.step('Get group list from DB'): old_groups = db.get_group_list() with allure.step('Get random group'): group_for_edit = random.choice(old_groups) id = group_for_edit.id group.id = id with allure.step('Edit group %s' % group_for_edit): app.group.edit_by_id(group_for_edit.id, group) with allure.step('Verify group was edited'): new_groups = db.get_group_list() assert len(old_groups) == len(new_groups) for i in range(len(old_groups)): if old_groups[i].id == group_for_edit.id: old_groups[i] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted( app.group.get_group_list(), key=Group.id_or_max)
def test_modify_group_name( app, db, check_ui): #модификация случайной группы- проверки из БД group = Group(name="Моя группа", header="Моя группа", footer="Моя группа" ) #значение, на которое будем менять выбранную группу if len(db.get_group_list()) == 0: #предусловие app.group.create(group) old_groups = db.get_group_list() #читаем группы до модификации old_group = random.choice( old_groups) # выбираем случайную группу из старого списка групп group.id = old_group.id # меняем id у новой группы на тот, который есть у группы, кот.собираемся менять app.group.modify_group_by_id( old_group.id, group ) #модифицируем у группы,выбранной по id, значения (имя, header,footer) new_groups = db.get_group_list() #читаем группы после модификации old_groups.remove(old_group) #удаляем из списка старую группу old_groups.append(group) #добавляем новую группу assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: ui_list = app.group.get_groups_list() # список, загруженный через UI## clean = app.group.clean_name() db_list = map(clean, db.get_group_list()) # список, загруженный через БД assert sorted(db_list, key=Group.id_or_max) == sorted(ui_list, key=Group.id_or_max)
def test_edit_group_by_id(app, db, check_ui): if app.group.count() == 0: app.group.create(Group(name="wwww", header="qqqq", footer="rrrr")) old_groups = db.get_group_list() index = randrange(len(old_groups)) group = Group(name="xxxx", header="yyyyy", footer="zzzz") group.id = old_groups[index].id app.group.edit_group_by_id(group, group.id) new_groups = db.get_group_list() old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted(app.group.get_group_list(), key=Group.id_or_max) # Редактирование группы по индексу #def test_edit_group(app): # if app.group.count() == 0: # app.group.create(Group(name="wwww", header="qqqq", footer="rrrr")) # old_groups = app.group.get_group_list() # index = randrange(len(old_groups)) # group = Group(name="xxxx", header="yyyyy", footer="zzzz") # group.id = old_groups[index].id # app.group.edit_group_by_index(group, index) # new_groups = app.group.get_group_list() # assert len(old_groups) == len(new_groups) # old_groups[index] = group # assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_edit_some_group(app, db, check_ui): if app.group.count() == 0: app.group.create( Group(name="test group", header="test group header", footer="test group footer")) with allure.step('Select group for edit'): old_groups = db.get_group_list() group_to_edit = random.choice(old_groups) group = Group(name="testEdit group", header="testEdit group header", footer="testEdit group footer") group.id = group_to_edit.id with allure.step('Edit selected group'): app.group.edit_group_by_id(group, group.id) with allure.step('Check that group is edited'): assert len(old_groups) == app.group.count() new_groups = db.get_group_list() old_groups[old_groups.index(group_to_edit)] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted( app.group.get_group_list(), key=Group.id_or_max)
def test_modify_group(app, db, check_ui): if len(db.get_group_list()) == 0: test_group = Group() test_group.dummy() app.group.create(test_group) old_groups = db.get_group_list() group = random.choice(old_groups) test_group_new = Group(name = "random") test_group_new.id = group.id app.group.modify_by_id(group.id, test_group_new) new_groups = db.get_group_list() assert len(old_groups) == len(new_groups) old_groups[old_groups.index(group)] = test_group_new assert old_groups == new_groups if check_ui: assert sorted(map(clean, new_groups), key = Group.id_or_max) == \ sorted(app.group.get_group_list(), key = Group.id_or_max)
def test_edit_first_group_name(app, db): # Если список групп отсутствует его необходимо создать if app.group.count() == 0: app.group.create( Group(name="Group1", header="Group1_Header", footer="Group1_Footer")) # Получение списка групп из пользовательского интерфейса #old_groups = app.group.get_group_list() # Получение списка групп из БД old_groups = db.get_group_list() # Генерируем индекс в пределах полученного списка index = randrange(len(old_groups)) # Создаем новый объект по которому будут изменения group = Group(name="Edit_name", header="Group1_Header", footer="Group1_Footer") # Получаем ид элемента у у объекта с сгенерированным индексом group.id = old_groups[index].id # Изменяем выбранный элемент app.group.edit_group_by_index(group, index) # Получение списка групп из пользовательского интерфейса #new_groups = app.group.get_group_list() new_groups = db.get_group_list() # Сравнивваем длинну списков до изменения и после изменения assert len(old_groups) == len(new_groups) # Присваиваем рпанее полученному объекту с выбранным индексом новое значение поля old_groups[index] = group # Сравниваем отсортированные списки групп до изменения и после assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_modify_some_group(app, db, check_ui): if len(db.get_group_list()) == 0: app.group.create(Group(name='', header="", footer="")) old_groups = db.get_group_list() index = randrange(len(old_groups)) group = Group(name="Group_Mod", header="Test 08.02.21_mod", footer="test 08.02.21_mod") group.id = old_groups[index].id app.group.modify_group_by_id(group.id, group) assert len(old_groups) == app.group.count() new_groups = db.get_group_list() old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted( app.group.get_group_list(), key=Group.id_or_max) #def test_modify_some_group(app): # if app.group.count() == 0: # app.group.create(Group(name='', header="", footer="")) # old_groups = app.group.get_group_list() # index = randrange(len(old_groups)) # group = Group(name="Group_Mod", header="Test 08.02.21_mod", footer="test 08.02.21_mod") # group.id = old_groups[index].id # app.group.modify_group_by_index(index, group) # assert len(old_groups) == app.group.count() # new_groups = app.group.get_group_list() # old_groups[index] = group # assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_edit_any_group(app): if app.group.count() == 0: group = Group().set_all_parameters_to_random_value() app.group.create(group) old_groups = app.group.get_group_list() group_new_state = Group().set_random_parameters_to_random_value() # get id of randomly chosen group group_id = app.group.edit_any_group(group_new_state) # check len of list was not changed assert app.group.count() == len(old_groups) # next(iterator, None) returns first group by condition or None if no element found # but we already got its id, so element exists! And we will not get None # so we can replace old group by new_state with new id is set edited_group = next( (group for group in old_groups if group.id == group_id), None) index = old_groups.index(edited_group) group_new_state.id = group_id old_groups[index] = group_new_state # if new list length is correct, then we can compare lists. # so we can get new list new_groups = app.group.get_group_list() # check equalizing of sorted lists assert new_groups.sort() == old_groups.sort()
def test_modify_group_name(app, db): if app.group.count() == 0: app.group.create() old_groups = db.get_group_list() index = randrange(len(old_groups)) group = Group(name="test") group.id = old_groups[index].id app.group.modify_group_by_index(index, group) assert len(old_groups) == app.group.count() new_groups = db.get_group_list() old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) #def test_modify_group_header(app): # old_groups = app.group.get_group_list() # if app.group.count() == 0: # app.group.create(Group(name = "test")) # app.group.modify_first_group((Group(header="New header"))) # new_groups = app.group.get_group_list() # assert len(old_groups) == len(new_groups) #def test_modify_group_footer(app): # old_groups = app.group.get_group_list() # if app.group.count() == 0: # app.group.create(Group(name = "test")) # app.group.modify_first_group((Group(footer="New footer"))) # new_groups = app.group.get_group_list() # assert len(old_groups) == len(new_groups)
def test_edit_group_name(app): if app.group.count() == 0: app.group.create(Group(name="test", header="test", footer="test")) old_groups = app.group.get_group_list() index = randrange(len(old_groups)) group = Group(name="new") group.id = old_groups[index].id app.group.edit_group_by_index(index, group) new_groups = app.group.get_group_list() assert len(old_groups) == len(new_groups) old_groups[index]=group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) #def test_edit_group_header(app): # if app.group.count() == 0: # app.group.create(Group(name="test", header="test", footer="test")) # old_groups = app.group.get_group_list() # group = Group(header="new") # group.id = old_groups[0].id # app.group.edit_first_group(group) # new_groups = app.group.get_group_list() # assert len(old_groups) == len(new_groups) # old_groups[0]=group # assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_edit_some_group_name(app, db, check_ui): with allure.step('When no groups presented in list'): if app.group.count() == 0: app.group.create( Group(name="test name", header="test header", footer="test footer")) with allure.step('Given a group list'): old_groups = db.get_group_list() with allure.step('Random group selected'): random_index = randrange(len(old_groups)) group = old_groups[random_index] with allure.step('Given a new data for group'): updated_group = Group(name="New test group") updated_group.id = group.id with allure.step('When I edit a group to new one %s' % updated_group): app.group.modify_group_by_id(group.id, updated_group) new_groups = db.get_group_list() with allure.step( 'Then the new group list is equal to the old list without modified group' ): assert len(old_groups) == len(new_groups) old_groups[random_index] = updated_group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted( app.group.get_group_list(), key=Group.id_or_max)
def test_edit_some_group(app, db, check_ui): if len(db.get_group_list()) == 0: app.group.create(Group(name="test1", header="test11", footer="test111")) with allure.step("Given a non-empty group list"): old_groups = db.get_group_list() with allure.step("Given a random group from the list"): edit_group = random.choice(old_groups) with allure.step("Given a new data for edited group"): group = Group(name="group2", header="group22", footer="group222") group.id = edit_group.id with allure.step("When I edit the group %s from list" % group): app.group.edit_group_by_id(edit_group.id, group) with allure.step( "Then the new group list is equal to the old with the edit group"): new_groups = db.get_group_list() assert len(old_groups) == len(new_groups) old_groups.remove(edit_group) old_groups.append(group) assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted( app.group.get_group_list(), key=Group.id_or_max)
def test_modify_group_name(app, db, check_ui): if len(db.get_group_list() ) == 0: # Если в базе данных нет групп, создаем группу app.group.create( Group(name="Group Test", header="Header Test", footer="Footer Test")) # Создаём новую группу group = Group(name="New Group", header="New Header", footer="New Footer") # Новые параметры заносим в переменную old_groups = db.get_group_list( ) # Получение списка групп из БД до модификации index = randrange( len(old_groups)) # Получение номера случайной группы для модификации group.id = old_groups[index].id # Получаем id выбранной группы app.group.modify_group_by_id(group.id, group) # Модифицируем выбранную группу по id new_groups = db.get_group_list( ) # Сохранение списка групп ПОСЛЕ модификации old_groups[ index] = group # Добавляем параметры в выбранную группу по index # Сравниваем отсортированные по ключу (id) списки групп assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: # Включение проверки графического интерфейса при наличии ключа "--check_ui" # Сравниваем отсортированные по ключу (id) списки групп assert sorted(new_groups, key=Group.id_or_max) == sorted( app.group.get_group_list(), key=Group.id_or_max)
def test_edit_any_group(app, db, check_ui): with allure.step(f'Given non-empty group list'): if len(db.get_group_list()) == 0: group = Group().set_all_parameters_to_random_value() app.group.create(group) old_groups = db.get_group_list() with allure.step(f'Given new state for group to edit'): group_new_state = Group().set_random_parameters_to_random_value() with allure.step(f'When edit random group to new state {group_new_state}'): # get id of randomly chosen group group_id = app.group.edit_any_group(group_new_state) with allure.step(f'Then group list count is not changed'): # check len of list was not changed assert app.group.count() == len(old_groups) with allure.step(f'Then new group list is equals to the old group list with 1 group changed'): # next(iterator, None) returns first group by condition or None if no element found # but we already got its id, so element exists! And we will not get None # so we can replace old group by new_state with new id is set edited_group = next((group for group in old_groups if group.id == group_id), None) index = old_groups.index(edited_group) group_new_state.id = group_id old_groups[index].update(group_new_state) # if new list length is correct, then we can compare lists. # so we can get new list new_groups = db.get_group_list() # check equalizing of sorted lists assert sorted(new_groups) == sorted(old_groups) if check_ui: assert sorted(new_groups) == sorted(app.group.get_group_list())
def test_edit_group_name(app, db, check_ui): if app.group.count() == 0: app.group.create(Group(name="test")) old_groups = db.get_group_list() index = randrange(len(old_groups)) group = Group(name="uweywu") group.id = old_groups[index].id app.group.edit_group_by_id(group.id, group) new_groups = app.group.get_group_list() assert len(old_groups) == len(new_groups) old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: new_groups = map(app.group.clean_group_name, db.get_group_list()) assert sorted(new_groups, key=Group.id_or_max) == sorted( app.group.get_group_list(), key=Group.id_or_max) # def test_edit_group_header(app): # if app.group.count() == 0: # app.group.create(Group(name="test")) # old_groups = app.group.get_group_list() # index = randrange(len(old_groups)) # group = Group(header="leiiwwq") # group.id = old_groups[index].id # app.group.edit_group_by_index(index, group) # new_groups = app.group.get_group_list() # assert len(old_groups) == len(new_groups) # old_groups[index] = group # assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_modify_group_name(app): if app.group.count() == 0: app.group.create(Group(name="test")) old_groups = app.group.get_group_list() index = randrange(len(old_groups)) app.group.open_groups_page() group = Group(name="New group") group.id = old_groups[index].id app.group.modify_group_by_index(index, group) app.contact.return_to_home() new_groups = app.group.get_group_list() assert len(old_groups) == len(new_groups) old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) #def test_modify_group_header(app): #if app.group.count() == 0: #app.group.create(Group(header="test")) #old_groups = app.group.get_group_list() #app.group.open_groups_page() #app.group.modify_first_group(Group(header="New header")) #app.contact.return_to_home() #new_groups = app.group.get_group_list() #assert len(old_groups) == len(new_groups)
def test_modify_group_name(app): group = Group(name="To be modified") if app.group.count() == 0: app.group.create(Group(name="New group name")) old_groups = app.group.get_group_list() index = randrange(len(old_groups)) group.id = old_groups[index].id app.group.modify_group_by_index(group, index) assert len(old_groups) == app.group.count() new_groups = app.group.get_group_list() old_groups[index] = group assert sorted(old_groups, key = Group.id_or_max) == sorted(new_groups, key = Group.id_or_max) # def test_modify_group_header(app): # if app.group.count() == 0: # app.group.create(Group(header="To be modified")) # app.group.modify_first_group(Group(header="New group header")) # old_groups = app.group.get_group_list() # new_groups = app.group.get_group_list() # assert len(old_groups) == len(new_groups) # # def test_modify_group_footer(app): # if app.group.count() == 0: # app.group.create(Group(footer="To be modified")) # app.group.modify_first_group(Group(footer="New group footer")) # old_groups = app.group.get_group_list() # new_groups = app.group.get_group_list() # assert len(old_groups) == len(new_groups)
def test_editing_some_name(app, db, check_ui): if len(db.get_group_list()) == 0: app.group.create(Group(name="test")) old_groups = db.get_group_list() group = random.choice(old_groups) new_group_date = Group(name="New group") new_group_date.id = group.id app.group.editing_group_by_id(group.id, new_group_date) new_groups = db.get_group_list() old_groups.remove(group) old_groups.append(new_group_date) assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: groups_from_ui = app.group.get_group_list() def clean(group): return Group(id=group.id, name=group.name.strip()) groups_from_db = map(clean, new_groups) assert sorted(groups_from_db, key=Group.id_or_max) == sorted(groups_from_ui, key=Group.id_or_max) #def test_editing_first_header(app): # old_groups = app.group.get_group_list() # app.group.editing_first_group(Group(header="New header")) # new_groups = app.group.get_group_list() # #сделаем простую проверку, убедимся, что новый список длинее чем старый на ед-цу # assert len(old_groups) == len(new_groups)
def test_modify_some_group(app, db, check_ui): if len(db.get_group_list()) == 0: app.group.create(Group(name="test")) old_groups = db.get_group_list() modified_group = random.choice(old_groups) group = Group(name="modified", header="modified", footer="modified") group.id = modified_group.id app.group.modify_by_id(group, group.id) assert len(old_groups) == app.group.count() new_groups = db.get_group_list() index = old_groups.index(modified_group) old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted( app.group.get_group_list(), key=Group.id_or_max) #def test_modify_group_name(app): # if app.group.count() == 0: # app.group.create(Group(name="test")) # old_groups = app.group.get_group_list() # app.group.modify_first(Group(name="New group")) # new_groups = app.group.get_group_list() # assert len(old_groups) == len(new_groups) #def test_modify_group_header(app): # if app.group.count() == 0: # app.group.create(Group(name="test")) # old_groups = app.group.get_group_list() # app.group.modify_first(Group(header="New header")) # new_groups = app.group.get_group_list() # assert len(old_groups) == len(new_groups)
def test_add_contact_in_group(app, db, check_ui): new_contact = Contact(first_name="name_" + str(random.randint(1, 9999)), last_name="aosdksp" + str(random.randint(1, 9999)), address="somewhere", birthday="25-November-1765") new_group = Group(name="superGroup" + str(random.randint(1, 9999)), header="abcd", footer="asd6577") old_contacts_list = db.get_contact_list() old_groups = db.get_group_list() #Create contact and check app.contact.add(new_contact) new_contacts_list = db.get_contact_list() old_contacts_list.append(new_contact) assert sorted(old_contacts_list, key=Contact.id_or_max) == sorted(new_contacts_list, key=Contact.id_or_max), \ "Contact wasn't added" #Create group and check app.group.create(new_group) new_group.id = db.get_group_id(new_group) new_groups = db.get_group_list() old_groups.append(new_group) assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) , \ "Group wasn't added" #Add contact to the group app.contact.add_contact_to_group(new_contact, new_group) assert db.is_contact_in_group( new_contact, new_group), "Contact wasn't added to the group" if check_ui: assert app.contact.is_contact_in_group( new_contact, new_group), "Contact wasn't added to the group"
def test_edit_some_group(app): if app.group.count() == 0: app.group.create(Group(name="for edition")) old_groups = app.group.get_groups_list() group = Group("EditName", "EditHeader", "EditFooter") index = randrange(len(old_groups)) group.id = old_groups[index].id app.group.edit_group_by_index(group, index) assert len(old_groups) == app.group.count() new_groups = app.group.get_groups_list() old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) #def test_edit_first_group_name(app): # if app.group.count() == 0: # app.group.create(Group(name="for edition")) # old_groups = app.group.get_groups_list() # app.group.edit_first(Group(name="JustName")) # new_groups = app.group.get_groups_list() # assert len(old_groups) == len(new_groups) #def test_edit_first_group_header(app): # if app.group.count() == 0: # app.group.create(Group(name="for edition")) #old_groups = app.group.get_groups_list() # app.group.edit_first(Group(header="JustHeader")) # new_groups = app.group.get_groups_list() # assert len(old_groups) == len(new_groups)
def test_modify_group_name(app): # Проверяем наличие групп. Если их нет, то создаем. if app.group.count() == 0: app.group.create(Group(name="test")) # Получаем старый список групп old_groups = app.group.get_group_list() # Вычисляем случайный индекс модифицируемой группы и длинны списка групп index = randrange(len(old_groups)) # Создаем локальную переменную для передачи в не объекта модифицируемой группы group = Group(name="New group") # Сохраняем ид модифицируемой группы из старого списка и присваиваем его первому элементу списка который будем # добавлять для сравнения. Нужно для сравнения. т.к. ид измениться не должен. group.id = old_groups[index].id # Модификация первой группы. Изменение имени. app.group.modify_group_by_index(group, index) # Получаем новый список групп new_groups = app.group.get_group_list() # Проверяем что длина предыдущего списка групп равнасписку групп после изменения assert len(old_groups) == len(new_groups) # Присваиваем первому элементу списка с которым будем сравнивать, сохраненный ранее элемент с полученным из него ид. old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) # Возврат на страницу со списком групп app.session.return_home_page()
def test_modify_group(app, db, check_ui): if len(db.get_group_list()) == 0: test_group = Group() test_group.dummy() app.group.create(test_group) old_groups = db.get_group_list() group = random.choice(old_groups) test_group_new = Group(name="random") test_group_new.id = group.id app.group.modify_by_id(group.id, test_group_new) new_groups = db.get_group_list() assert len(old_groups) == len(new_groups) old_groups[old_groups.index(group)] = test_group_new assert old_groups == new_groups if check_ui: assert sorted(map(clean, new_groups), key = Group.id_or_max) == \ sorted(app.group.get_group_list(), key = Group.id_or_max)
def test_edit_some_group(app, db, check_ui): group = Group(name="Some name", header="Some header", footer="Some footer") if len(db.get_group_list()) == 0: app.group.create(group) old_groups = db.get_group_list() random_group = random.choice(old_groups) app.group.modify_group_by_id(random_group.id, group) # assert len(old_groups) == app.group.count() new_groups = db.get_group_list() # need to select group with same id from the list of old groups and replace with already edited group group.id = random_group.id old_groups.remove(random_group) old_groups.append(group) assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) def clean(group): return Group(id=group.id, name=group.name.strip()) new_groups = map(clean, db.get_group_list()) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted( app.group.get_group_list(), key=Group.id_or_max) #def test_edit_first_group_header(app): # if app.group.count() == 0: # app.group.create(Group(header="Some header")) # old_groups = app.group.get_group_list() # app.group.modify(Group(header="New edited header")) # new_groups = app.group.get_group_list() # assert len(old_groups) == len(new_groups)
def test_modify_group(app, db, check_ui): with allure.step('I check if exist any group in group list'): if len(db.get_group_list()) == 0: app.group.create(Group(name="test")) with allure.step('Given a group list from database'): old_groups = db.get_group_list() with allure.step('Random group selected from list'): random_group = random.choice(old_groups) index = old_groups.index(random_group) with allure.step('Given a new group data'): new_group_data = Group(name="New group") new_group_data.id = old_groups[index].id with allure.step('When I add new data to a group %s from the list' % new_group_data.id): app.group.modify_group_by_id(random_group.id, new_group_data) with allure.step( 'Then the new group list is equal to the old list with the added new data %s' % new_group_data): new_groups = db.get_group_list() old_groups[index] = new_group_data assert len(old_groups) == len(new_groups) assert old_groups == new_groups if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted( app.group.get_group_list(), key=Group.id_or_max)
def test_update_group(app, db, check_ui): app.group.create_if_absent() # preparation new_group = Group(name='groupUpdated', header='headerUpdated', footer='footerUpdated') old_groups = db.get_group_list() random_group = random.choice(old_groups) new_group.id = random_group.id app.group.update_by_id(random_group.id, new_group) # checking new_groups = db.get_group_list() # replacing old contact which was updated for n in range(len(old_groups)): if old_groups[n].id == new_group.id: old_groups[n] = new_group break assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted( app.group.get_group_list(), key=Group.id_or_max)
def test_modify_some_group(app, db, check_ui): if len(db.get_group_list()) == 0: app.group.create(Group(name='test')) old_groups = db.get_group_list() random_group = random.choice(old_groups) group = Group(name="update") group.id = random_group.id app.group.modify_group_by_id(group) new_groups = db.get_group_list() assert len(old_groups) == len(new_groups) i = 0 for x in old_groups: if x.id == random_group.id: old_groups[i] = group i += 1 assert old_groups == new_groups if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted(app.group.get_group_list(), key=Group.id_or_max) #def test_modify_group_header(app): # old_groups = app.group.get_group_list() # app.group.modify_first_group(Group(header="update")) # new_groups = app.group.get_group_list() # assert len(old_groups) == len(new_groups)
def test_edit_group_name_by_index(app, db, check_ui): if len(db.get_group_list()) == 0: app.groups.create(Group(name="Test")) old_groups = db.get_group_list() group = random.choice(old_groups) newG = Group(name="New name") newG.id = group.id app.groups.edit_by_id(group.id, newG) new_groups = db.get_group_list() old_groups.remove(group) old_groups.append(newG) assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) def clean(group): group.name = re.sub(" +", " ", group.name) return Group(id=group.id, name=group.name.strip()) if check_ui: ui_list = app.groups.get_groups_list() db_list = map(clean, new_groups) assert sorted(db_list, key=Group.id_or_max) == sorted(ui_list, key=Group.id_or_max)
def test_modify_gname(app): old_groups = app.group.get_group_list() group = Group(name= 'New Group') group.id = old_groups[0].id app.group.modify_first_group(group) new_groups = app.group.get_group_list() assert len(old_groups) == len(new_groups) old_groups[0]= group assert sorted(old_groups,key=Group.id_or_max) == sorted(new_groups,key=Group.id_or_max)
def test_modify_group_name(app): old_groups = app.group.get_group_list() group = Group(name="New name") group.id = old_groups[0].id app.group.modify_first_group(group) new_groups = app.group.get_group_list() assert_that(len(old_groups) == len(new_groups)).is_true() old_groups[0] = group assert_that(old_groups == new_groups)
def test_modify_group_name(app, db, check_ui): if app.group.count() == 0: app.group.create(Group(name="TestGroupName")) old_groups = db.get_group_list() old_group = random.choice(old_groups) group = Group(name="ModifyGroup") group.id = old_group.id old_groups.remove(old_group) app.group.modify_group_by_id(group) app.group.check_add_or_modify_success(db, group, old_groups, check_ui)
def test_modify_group_name(app): if app.group.count() == 0: app.group.create(Group(name="test", header="test", footer="test")) old_groups = app.group.get_group_list() index = randrange(len(old_groups)) group = Group(name="Change name") group.id = old_groups[index].id app.group.modify_group_by_index(index, group) new_groups = app.group.get_group_list() assert len(old_groups) == len(new_groups)
def test_modify_group_name(app, orm): check_for_group(app) old_groups = orm.get_group_list() group = random.choice(old_groups) gr_obj = Group(name="popopo") gr_obj.id = group.id old_groups.remove(group) old_groups.append(gr_obj) app.group.modify_by_id(gr_obj) new_groups = orm.get_group_list() assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_modify_group_name(app): if app.group.count() == 0: app.group.create(Group(name="testing")) old_groups = app.group.get_group_list() group = Group (name= "NewGroup") group.id = old_groups[0].id app.group.modify_first_group(group) new_groups = app.group.get_group_list() assert len(old_groups) == len (new_groups) old_groups[0]=group assert sorted(old_groups,key=Group.id_or_max) == sorted(new_groups,key=Group.id_or_max)
def test_modify_group_name(app): if app.group.count() == 0: app.group.create(Group(name="some name", header="some logo", footer="some footer")) old_groups = app.group.get_groups_list() index = randrange(len(old_groups)) group = Group(name="new name") group.id = old_groups[index].id app.group.modify_group_by_index(index, group) new_groups = app.group.get_groups_list() assert len(old_groups) == len(new_groups) old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_edit_some_group_name(app): if app.group.count() ==0: app.group.create(Group(gr_name="for edit group")) old_groups = app.group.get_group_list() index = randrange(len(old_groups)) group = Group(gr_name="edit_test111111") group.id = old_groups[index].id app.group.edit_group_by_index(index, group) new_groups = app.group.get_group_list() assert len(old_groups) == len(new_groups) old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_edit_group_name(gen): if gen.group.count() == 0: gen.group.create(Group(name="test")) old_groups = gen.group.get_group_list() index = randrange(len(old_groups)) group = Group(name="New name") group.id = old_groups[index].id gen.group.edit_group_by_index(index, group) assert len(old_groups) == gen.group.count() new_groups = gen.group.get_group_list() old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_modify_some_group(app): group = Group(name="New group") if app.group.count() == 0: app.group.create(group) old_groups = app.group.get_group_list() index = randrange(len(old_groups)) group.id = old_groups[index].id app.group.modify_group_by_index(index, group) assert len(old_groups) == app.group.count() new_groups = app.group.get_group_list() old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_modify_group_by_index(app): old_groups = app.group.get_group_list() index = randrange(len(old_groups)) group = Group(name="test group") group.id = old_groups[index].id if app.group.count()== 0: app.group.create(Group(name="test group")) app.group.modify_group_by_index(index, group) new_groups = app.group.get_group_list() assert len(old_groups) == len(new_groups) old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max)== sorted (new_groups, key=Group.id_or_max)
def test_edit_group(app, db, check_ui): if len(db.get_group_list()) == 0: app.group.create(Group(name="name_name", header="head_head")) old_groups = db.get_group_list() group = random.choice(old_groups) group_new = Group(name="new_name", header="new_header", footer="new_footer") group_new.id = group.id app.group.edit_group_by_id(group.id, group_new) new_groups = db.get_group_list() # assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted(app.group.get_group_list(), key=Group.id_or_max)
def test_mod_some_group_name(app): if app.group.count() == 0: app.group.create(Group(name="test")) old_groups = app.group.get_group_list() index = randrange(len(old_groups)) group = Group(name="new group") group.id = old_groups[index].id app.group.modify_group_by(group,index) new_groups = app.group.get_group_list() assert len(old_groups) == app.group.count() old_groups[index] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_edit_group(app): if app.group.count() == 0: app.group.create(Group(name="test")) old_groups = app.group.get_group_list() index = randrange(len(old_groups)) group=Group(name="aaaaa", header="kkk", footer="ccc") group.id = old_groups[index].id app.group.edit_group_by_index(index, group) new_groups = app.group.get_group_list() assert len(old_groups) == len(new_groups) old_groups[index] =group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_edit_first_group(app, db): if len(db.get_group_list()) == 0: app.group.create(Group(name="sdfsf")) old_groups = db.get_group_list() target_group = random.choice(old_groups) group = Group(name="test") group.id = target_group.id app.group.edit_by_id(target_group.id, group) assert len(old_groups) == app.group.count() new_groups = db.get_group_list() old_groups = [group if gr.id == group.id else gr for gr in old_groups] assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_edit_some_group(app, db, check_ui): if len(db.get_group_list()) == 0: app.group.create(Group(name="not enough groups")) old_groups = db.get_group_list() group = random.choice(old_groups) edited_group = Group(name="edited_name", header="edited_header", footer="edited_footer") edited_group.id = group.id app.group.edit_group_by_id(edited_group, group.id) new_groups = db.get_group_list() old_groups.remove(group) old_groups.append(edited_group) assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted(app.group.get_groups_list(), key=Group.id_or_max)
def test_edit_some_group_name(app, db, check_ui): if len(db.get_group_list())==0: app.group.create(Group(name="test")) old_groups = db.get_group_list() group = random.choice(old_groups) group_new = Group(name="new name") app.group.edit_group_by_id(group.id, group_new) group_new.id=group.id new_groups = db.get_group_list() old_groups.remove(group) old_groups.append(group_new) assert sorted(old_groups, key = Group.id_gr_max) == sorted(new_groups, key = Group.id_gr_max) if check_ui: assert sorted(new_groups, key=Group.id_gr_max) == sorted(app.group.get_group_list(), key=Group.id_gr_max)
def test_modify_group_fields(app): app.session.login(username="******", password="******") if app.group.count() == 0: app.group.create(Group(name="test", header="test", footer="test")) old_groups = app.group.get_group_list() group = Group(name="updated", header="updated", footer="updated") group.id = old_groups[0].id app.group.modify_first_group(group) assert len(old_groups) == app.group.count() new_groups = app.group.get_group_list() old_groups[0] = group assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) app.session.logout()
def test_modify_group_name(app, db, check_ui): if len(db.get_group_list()) == 0: app.group.create(Group(name="test")) old_groups = db.get_group_list() group = random.choice(old_groups) modified_group = Group(name="New group") modified_group.id = group.id app.group.modify_group_by_id(modified_group.id, modified_group) new_groups = db.get_group_list() old_groups.remove(group) old_groups.append(modified_group) assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted(app.group.get_group_list(), key=Group.id_or_max)
def test_modify_group_name(app, db, check_ui): if len(db.get_group_list()) == 0: app.group.create(Group(name="new", header="header", footer="footer")) old_groups = db.get_group_list() random_group = random.choice(old_groups) group_index = old_groups.index(random_group) group = Group(name="updated group", header="updated header", footer="updated footer") group.id = random_group.id app.group.modify_group_by_id(group, random_group.id) new_groups = db.get_group_list() old_groups[group_index] = group assert sorted(old_groups, key = Group.id_or_max) == sorted(new_groups, key = Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted(app.group.get_group_list(), key=Group.id_or_max)
def create_user_groups(): user = validate_cookie(request) print user.__str__() responseWrapper = ResponseWrapper() print "hello new group" response = any_response(request) if user != None: group = Group() try: # form_data = request.form['data'] print request.form form_data = request.form['data'] json_data = json.loads(form_data) group.name = json_data['group_name'] print "appending to group user ", user.id group.users.append(user.id) except Exception as inst: print inst print "Error reading form data" responseWrapper.set_error(True) responseWrapper.set_data([inst]) response.data = json.dumps(responseWrapper, default=ResponseWrapper.__str__) response.mimetype = "application/json" return response new_group_id = groupDAO.insert_group(group) group.id = new_group_id result = userDAO.append_group(user.id,group) if result != None: responseWrapper.set_error(False) new_group_id = str(new_group_id) responseWrapper.set_data([{"group_id":new_group_id}]) else: responseWrapper.set_error(True) responseWrapper.set_data(["error writing group"]) else: responseWrapper.set_error(True) responseWrapper.set_data(["User not found. Please login again"]) response.status_code = 302 response.data = json.dumps(responseWrapper, default=ResponseWrapper.__str__) response.mimetype = "application/json" return response
def test_change_some_group_name(app, db, check_ui): if len(db.get_group_list()) == 0: app.group.create(Group(name="group", header="new", footer="new_1")) old_groups = db.get_group_list() old_group = random.choice(old_groups) id = old_group.id group = Group(name="change_group") app.group.change_by_id(id, group) new_groups = db.get_group_list() group.id = id old_groups.insert(old_groups.index(old_group), group) old_groups.remove(old_group) assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted(app.group.get_group_list(), key=Group.id_or_max)
def test_edit_first_group(app, db, check_ui, data_groups): with pytest.allure.step('Given a non-empty group list'): if len(db.get_list_groups()) == 0: app.group.create(data_groups) old_list_groups = db.get_list_groups() edit_group = Group(name="Name_of_group_new", header="Header_of_group_new", footer="Footer_of_group_new") with pytest.allure.step('When I edit a first group from the list to edit group %s' % edit_group): edit_group.id = old_list_groups[0].id app.group.edit_group_by_id(edit_group) with pytest.allure.step('Then the new group list is equal to the old group list with edited group'): new_list_groups = db.get_list_groups() old_list_groups[0] = edit_group assert sorted(new_list_groups, key=Group.id_or_max) == sorted(old_list_groups, key=Group.id_or_max) if check_ui: assert sorted(new_list_groups, key=Group.id_or_max) == sorted(app.group.get_list_groups(), key=Group.id_or_max)
def test_modify_group_name(app, db, check_ui): odl_groups = db.get_group_list() if len(db.get_group_list()) == 0: app.group.create(Group(name="test")) new_data= Group(name="New Name of Group") index = randrange(len(odl_groups)) new_data.id = odl_groups[index].id app.group.modify_group_by_id(new_data.id, new_data) new_groups = db.get_group_list() assert len(odl_groups) == len(new_groups) odl_groups[index] = new_data assert sorted(odl_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: list_group_after_mod = app.group.get_group_list() assert sorted(list_group_after_mod, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max)
def test_modify_group_name_to(app, db, check_ui): if len(db.get_groups_list()) == 0: app.group.create(Group(name="TestName")) old_groups = db.get_groups_list() group = random.choice(old_groups) new_group = Group(name="NewName") new_group.id = group.id app.group.modify_group_by_id(new_group.id, new_group) assert len(old_groups) == app.group.count() new_groups = db.get_groups_list() index = old_groups.index(group) old_groups[index] = new_group assert old_groups == new_groups if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted(app.group.get_groups_list(), key=Group.id_or_max)
def test_rename_first_group(app,db,check_ui): if app.group.count() == 0: app.group.create(Group(name="test")) old_groups = db.get_group_list() chosen_group = random.choice(old_groups) index = old_groups.index(chosen_group) group = Group(name="edited1", header="edited", footer="edited") group.id=chosen_group.id app.group.edit_group_by_id(group.id, group) new_groups = db.get_group_list() assert len(old_groups) == len(new_groups) old_groups[index]=group assert sorted(old_groups, key = Group.id_or_max) == sorted(new_groups,key = Group.id_or_max) if check_ui: assert sorted(new_groups, key = Group.id_or_max) == sorted(app.group.get_group_list(), key = Group.id_or_max)
def test_update_group_name(app, orm, check_ui): if len(orm.get_groups()) == 0: app.group.add(Group(name='first group')) old_groups = orm.get_groups() group = random.choice(old_groups) index = old_groups.index(group) new_data = Group(name='new name') new_data.id = group.id app.group.update_by_id(group.id, new_data) new_groups = orm.get_groups() assert len(old_groups) == len(new_groups) old_groups[index] = new_data assert sorted(old_groups, key=Group.id_or_max) == sorted(new_groups, key=Group.id_or_max) if check_ui: assert sorted(new_groups, key=Group.id_or_max) == sorted(app.group.get_groups(), key=Group.id_or_max)