def setUp(self):
""" Creates one *address_book* with 2 groups and some people
in them """
self.address_book = AddressBook()
# Groups
self.jacksons = Group('Jacksons 5')
self.singers = Group('Singers')
# Michael jackson will be a member of both groups
self.mj = Person('Michael', 'Jackson')
# Members group #1
self.jacksons.addPerson(self.mj)
self.jacksons.addPerson(Person('Tito', 'Jackson'))
self.jacksons.addPerson(Person('Another', 'Jackson'))
# Members group #2
self.singers.addPerson(Person('Lionel', 'Ritchie'))
self.singers.addPerson(self.mj)
# Add groups to the Address Book
self.address_book.addGroup(self.jacksons)
self.address_book.addGroup(self.singers)
TestAddressBook.__addMockEmails(self.address_book)
def test_add_people_to_address_book(self):
""" Feature #1: Add a person to the address book. """
address_book = AddressBook()
jerry = Person('Jerry', 'Garcia')
janis = Person('Janis', 'Joplin')
address_book.addPerson(jerry)
address_book.addPerson(janis)
self.assertEqual(2, len(address_book.people))
def parse_json(self, js):
"""
解析上传数据包，并保存新用户
截取倒数20个
:param js: JSON数据包
:return:
"""
upload_count = len(js)
slice = js[-20:]
count = len(slice)
mysql = MysqlAdapter()
mysql.open()
find_count = 0
for i in range(count):
dic = slice[i]
p = Person()
p.uid = dic['uid']
p.nickname = dic['nickname']
p.gender = dic['gender']
p.follower_count = -1
p.following_count = -1
p.used = 0
result = p.check_save(mysql)
if result == 1:
find_count += 1
print('分析%d个用户，找到%d个新用户，上传%d个用户' % (count, find_count, upload_count))
mysql.close()
def test_add_emp_person(app):
app.open_home_page()
app.session.login(username="******", password="******")
app.person.open_add_page()
app.person.create_person(
Person(firstname="", middlename="", nickname="", birthYear=""))
app.session.logout()
def test_add_emp_person(self):
self.open_home_page()
self.login(username="******", password="******")
self.open_add_page()
self.create_person(
Person(firstname="", middlename="", nickname="", birthYear=""))
self.logout()
def get_person(id_p):
mysql_util = open_connect_mysql()
sql = "select * from Persons where id_p= " + "'" + id_p + "'"
person = mysql_util.mysql_query(sql)
N_Person = Person(person[0][0], person[0][1], person[0][2], person[0][3],
person[0][4], person[0][6])
close_connect_mysql(mysql_util)
return N_Person.to_string()
def series(self, tv_id: int()):
result = tmdb.TV(tv_id)
tv_info = result.info()
tv_credits = result.credits()
cast = list()
for actor in tv_credits['cast']:
cast.append(
Cast(id=actor['id'],
name=actor['name'],
character=actor['character'],
profile_path=actor['profile_path']))
crew = list()
for c in tv_credits['crew']:
crew.append(
Crew(id=c['id'],
name=c['name'],
profile_path=c['profile_path'],
job=c['job'],
department=c['department']))
credits = Credits(cast=cast, crew=crew)
prod_companies = list()
for company in tv_info['networks']:
prod_companies.append(
ProductionCompanies(id=company['id'],
name=company['name'],
logo_path=company['logo_path'],
origin_country=company['origin_country']))
show_creaters = list()
for creaters in tv_info['created_by']:
show_creaters.append(
Person(id=creaters['id'],
name=creaters['name'],
profile_path=creaters['profile_path'],
gender=creaters['gender']))
episode_runtime = [run for run in tv_info['episode_run_time']]
tv = TVSeries(id=tv_info['id'],
name=tv_info['name'],
original_name=tv_info['original_name'],
original_language=tv_info['original_language'],
overview=tv_info['overview'],
in_production=tv_info['in_production'],
first_air_date=tv_info['first_air_date'],
last_air_date=tv_info['last_air_date'],
homepage=tv_info['homepage'],
number_of_episodes=tv_info['number_of_episodes'],
number_of_seasons=tv_info['number_of_seasons'],
episode_runtime=episode_runtime,
created_by=show_creaters,
backdrop_path=tv_info['backdrop_path'],
poster_path=tv_info['poster_path'],
networks=prod_companies,
credits=credits)
return tv
def test_sort_people(self):
people = []
with open(TEST_FILE, 'r') as reader:
for line in reader.readlines():
people.append(Person(parse_line(line)))
self.assertEqual(sorted_list_1(people), SORTED_1_GENDER_THEN_LASTNAME)
self.assertEqual(sorted_list_2(people), SORTED_2_BIRTHDATE)
self.assertEqual(sorted_list_3(people), SORTED_3_LASTNAME_DESCENDING)
def setUp(self):
super(TestGrid, self).setUp()
self.list = [
Person('jose', 'perez'),
Person('marcos', 'dione'),
Person('john', 'lenton'),
]
columns = (
Column(name='Nombre', attribute='name'),
Column(name='Apellido', attribute='surname'),
)
self.parent = self.window = Window(title='Test', parent=self.app)
self.widget = self.grid = EditableGrid(parent=self.parent,
columns=columns,
cls=Person)
target = DummyTarget(self.list)
self.setUpControl(target=target, attr='dummy')
def __obj_converter(self, item_str: str) -> Person:
person = Person()
obj_array = item_str.split(';')
person.id = obj_array[0]
person.name = obj_array[1]
person.date_of_birth = obj_array[2]
person.type_person = obj_array[3]
person.cpf = obj_array[4]
person.cnpj = obj_array[5]
return person
def to_object(self, row):
if len(row) > 0:
return (Person(id_=int(row[0]),
name=row[1],
email=row[2],
role=row[3],
login=row[4],
password=row[5]))
return None
def test_addperson(self):
self.open_home_page()
self.login(username="******", password="******")
self.open_add_page()
self.create_person(
Person(firstname="Dastan",
middlename="Ergaly",
nickname="Dastish",
birthYear="2000"))
self.logout()
def test_edit_person(app, db, check_ui):
if len(db.get_person_list()) == 0:
app.person.create(Person(lname="Zadornov"))
old_persons = db.get_person_list()
i = randrange(len(old_persons))
op = old_persons[i]
person = Person(fname="Ivan", mname=op.mname, lname="Ivanov", nname=op.nname, homephone=op.homephone,
mobilephone=op.mobilephone, workphone=op.workphone, secondaryphone=op.secondaryphone,
allphones_from_home_page=op.allphones_from_home_page, email=op.email, email2=op.email2, email3=op.email3,
allemails_from_home_page=op.allemails_from_home_page, address=op.address, id=op.id)
app.person.edit_person_by_id(person)
new_persons = db.get_person_list()
assert len(old_persons) == len(new_persons)
old_persons[i] = person
assert sorted(old_persons, key=Person.id_or_max) == sorted(new_persons, key=Person.id_or_max)
if check_ui:
assert sorted(new_persons, key=Person.id_or_max) == sorted(app.person.get_person_list(), key=Person.id_or_max)
def test_add_members_to_group(self):
david = Person('David', 'Gilmour')
syd = Person('Syd', 'Barret')
self.group.addPerson(david)
self.group.addPerson(syd)
self.assertEqual(2, len(self.group.members))
# Verify that the People groups count got incremented
self.assertEqual(1, len(david.groups))
self.assertEqual(1, len(syd.groups))
# Try to add person to a group that they are already a member of
# and verify that the members count doesn't change
self.group.addPerson(syd)
self.assertEqual(2, len(self.group.members))
# The persons' group count did not get incremented neither
self.assertEqual(1, len(syd.groups))
def get_person_list():
if request.method == 'POST':
data = request.data
pageInfo = json.loads(data)
# persons = personDao.get_person_list(pageInfo['start'], pageInfo['pagesize'])
persons = personDao.get_person_list_like(pageInfo['searchName'],
pageInfo['start'],
pageInfo['pagesize'])
person_model = Person()
persons_json_array = person_model.get_persons_json_array(persons)
response = get_response(persons_json_array)
return response
def setUp(self):
super(TestEditor, self).setUp()
self.store = Store()
self.parent = self.window = cimarron.skin.Window()
# self.widget = cimarron.skin.Editor(store=self.store,
# attributes=['name', 'surname'])
self.widget = Editor.fromXmlFile('test/editor.xml')
self.widget.parent = self.parent
self.widget.store = self.store
self.entry = self.widget.entries.children[0]
self.setUpControl(target=Person('Marcos', 'Dione'), attr=None)
def editModel(self, *ignore):
if self.value is None:
value = Person()
value.name = self.name.value
value.surname = self.surname.value
# we do it this way because doing `self.value= Person()´
# would empty the Entry's values (due to refresh())
self.value = value
else:
self.value.name = self.name.value
self.value.surname = self.surname.value
self.value.isDirty = True
def get_person_info_from_view_page(self, index):
wd = self.app.wd
self.open_person_to_view_by_index(index)
text = wd.find_element_by_id("content").text
homephone = re.search("H: (.*)", text).group(1)
workphone = re.search("W: (.*)", text).group(1)
mobilephone = re.search("M: (.*)", text).group(1)
secondaryphone = re.search("P: (.*)", text).group(1)
return Person(homephone=homephone,
workphone=workphone,
mobilephone=mobilephone,
secondaryphone=secondaryphone)
def setUp(self):
super(TestSearchEntry, self).setUp()
self.parent = self.window = cimarron.skin.Window(title='Test',
parent=self.app)
self.columns = (
cimarron.skin.Column(name='Nombre', attribute='name'),
cimarron.skin.Column(name='Apellido', attribute='surname'),
)
self.widget = cimarron.skin.SearchEntry(
parent=self.parent,
columns=self.columns,
searcher=Person,
cls=Person,
)
Person.__values__ = self.data = [
Person('jose', 'perez'),
Person('marcos', 'dione'),
Person('john', 'lenton'),
Person('pedro', 'dargenio'),
]
self.setUpControl(target=self.data[0], attr=None)
def create_initialize_db(db_url, echo=False):
engine = create_engine(db_url, echo=echo)
Base.metadata.create_all(engine)
Session = sessionmaker(engine)
session = Session()
try:
permissions = [Permission(name=name) for name in Permission.ROLES]
session.add_all(permissions)
admin = Person(email="admin", password="******")
user = Person(email="user", password="******")
session.add_all([admin, user])
admin.permissions.append(permissions[0])
admin.permissions.append(permissions[1])
user.permissions.append(permissions[1])
session.commit()
except IntegrityError:
pass
except Exception, ex:
logging.warn(ex)
def post(self, company_number):
company = Company.query.get_or_404(company_number)
payload = Box(api.payload)
person = Person(
name=payload.name,
nationality=payload.nationality,
dob_year=payload.yearOfBirth,
notified_on=payload.notifiedOn,
natures_of_control=[],
address_line_1='',
address_line_2='',
address_care_of='',
address_country='',
address_locality='',
address_po_box='',
address_postal_code='',
address_premises='',
address_region='',
ceased_on=db.func.now(),
country_of_residence='',
dob_day=0,
dob_month=0,
etag='',
id_country_registered='',
id_legal_authority='',
id_legal_form='',
id_place_registered='',
id_registration_number='',
kind='',
link_self='',
link_statement='',
forename='',
other_forenames='',
surname='',
title=''
)
for nature in payload.naturesOfControl:
noc = NatureOfControl(nature_of_control=nature.natureOfControl)
person.natures_of_control.append(noc)
company.people.append(person)
db.session.commit()
return person, 201
def parse_file():
# Parse the command:
args = create_parser().parse_args()
input_path = args.Path
people = []
if not os.path.isfile(input_path):
print('The file specified was not found.')
else:
with open(input_path, 'r') as reader:
for line in reader.readlines():
people.append(Person(parse_line(line)))
for sort in sorts:
print(sort[1])
for line in sort[0](people):
print(line)
def test_delete_person(app, db, check_ui):
if len(db.get_person_list()) == 0:
app.person.create(Person(lname="Zadornov"))
old_persons = db.get_person_list()
i = randrange(len(old_persons))
person = old_persons[i]
app.person.delete_person_by_id(person.id)
new_persons = db.get_person_list()
assert len(old_persons) - 1 == len(new_persons)
old_persons[i:i + 1] = []
assert old_persons == new_persons
if check_ui:
assert sorted(new_persons, key=Person.id_or_max) == sorted(
app.person.get_person_list(), key=Person.id_or_max)
def get_person_list(self):
if self.person_cache is None:
wd = self.app.wd
wd.find_element_by_link_text("home").click()
time.sleep(1)
#self.open_groups_page()
self.person_cache = []
for row in wd.find_elements_by_name("entry"):
cells = row.find_elements_by_tag_name("td")
lastname = cells[1].text
firstname = cells[2].text
id = cells[0].find_element_by_name("selected[]").get_attribute(
"value")
all_emails = cells[4].text
all_phones = cells[5].text
self.person_cache.append(
Person(fname=firstname,
lname=lastname,
id=id,
allphones_from_home_page=all_phones,
allemails_from_home_page=all_emails))
return list(self.person_cache)
class TestPerson(unittest.TestCase):
"""Test cases for Person class"""
person = Person('Adeola', 'Adedire')
def test_new_person_class(self):
self.assertEqual(type(self.person), Person)
def test_new_person_first_name(self):
self.assertEqual(self.person.fullname, 'ADEOLA ADEDIRE')
def test_new_person_office_allocated(self):
self.assertEqual(self.person.office_allocated, False)
def test_new_person_office_space(self):
self.assertEqual(self.person.office, '')
def test_new_person_living_allocated(self):
self.assertEqual(self.person.living_allocated, False)
def test_new_person_living_allocated(self):
self.assertEqual(self.person.living, '')
def test_create_new_person_raises_error(self):
self.assertRaises(Exception, Person, 9, 'Ade')
def get_person_info_from_edit_page(self, index):
wd = self.app.wd
self.open_person_to_edit_by_index(index)
homephone = wd.find_element_by_name("home").get_attribute("value")
mobilephone = wd.find_element_by_name("mobile").get_attribute("value")
workphone = wd.find_element_by_name("work").get_attribute("value")
secondaryphone = wd.find_element_by_name("phone2").get_attribute(
"value")
email = wd.find_element_by_name("email").get_attribute("value")
email2 = wd.find_element_by_name("email2").get_attribute("value")
email3 = wd.find_element_by_name("email3").get_attribute("value")
firstname = wd.find_element_by_name("firstname").get_attribute("value")
lastname = wd.find_element_by_name("lastname").get_attribute("value")
id = wd.find_element_by_name("id").get_attribute("value")
return Person(fname=firstname,
lname=lastname,
id=id,
homephone=homephone,
workphone=workphone,
mobilephone=mobilephone,
secondaryphone=secondaryphone,
email=email,
email2=email2,
email3=email3)
def person(self, person_id: int()):
person = tmdb.People(person_id)
result = person.info()
cast = list()
for actor in person.movie_credits()['cast']:
cast.append(
Cast(id=actor['id'],
title=actor['title'],
poster_path=actor['poster_path'],
character=actor['character']))
crew = list()
for c in person.movie_credits()['crew']:
crew.append(
Crew(id=c['id'],
title=c['title'],
job=c['job'],
department=c['department'],
poster_path=c['poster_path']))
credits = Credits(cast=cast, crew=crew)
return Person(id=result['id'],
name=result['name'],
imdb_id=result['imdb_id'],
gender=result['gender'],
homepage=result['homepage'],
profile_path=result['profile_path'],
also_known_as=result['also_known_as'],
biography=result['biography'],
deathday=result['deathday'],
birthday=result['birthday'],
place_of_birth=result['place_of_birth'],
popularity=result['popularity'],
credits=credits)
def create(person):
'''
Handler function for POST 'create' request to /api/records:
creates a new person in the people structure based on the passed in person data.
:param person: person to create in people structure
:return: 201 on success, 406 on person exists
'''
line = person.get('line', None)
if not line:
abort(
422,
f'Cannot create Person from "None" data',
)
person_object = Person(parse_line(line))
if person_object in DATA_STORE:
abort(
406,
f'Person with last name "{person_object.lname}" already exists',
)
else:
DATA_STORE.append(person_object)
return make_response(f'"{str(person_object)}" successfully created',
201)
# res = get_person_list("0", "2")
# print(res)
# # get item in dict
# data = {"user": 1, "name": "Max", "three": 4}
# is_admin = data.get("user", False)
# print(is_admin)
#
# teams = ["Packers", "49ers", "Ravens", "Patriots"]
# keys = ["111", "222", "333", "444"]
# print({key: value for value, key in zip(teams, keys)})
rows = get_person_list_like("", "0", "10")
persons_key = [
"id_p", "firstname", "lastname", "address", "city", "create_date",
"telephone"
]
print(rows)
# data = []
# for row in rows:
# row_data = {}
# # for i in range(len(row)):
# # row_data["name"] = row[1]
# for k, v in zip(persons_key, row):
# row_data[k] = v
# data.append(row_data)
person = Person()
data = person.get_persons_json_array(rows)
print(data)
# for r_v in row:
# print(r_v)
# print(data)
def newPerson(self, *ignore):
self.value = Person()
