def add(*args, **kwargs):
n_data = []
for n in range(10):
n_data.append(random.randint(1, 101))
logger.info("Loop ke : {}. {}".format(args[0], n_data))
return n_data
def click(self, locator):
try:
self.find_element(locator).click()
logger.info(u'点击%s成功' % (list(locator)))
except Exception as msg:
logger.error(u'点击%s失败' % (list(locator)))
logger.error("报错信息是：%s" % msg)
def get_issues(self):
block_size = 100
block_num = 0
while True:
start_idx = block_num * block_size
list_issues = \
self.jira.search_issues(jql_str=JIRA_QUERY,
startAt=start_idx,
maxResults=block_size,
expand='changelog')
if len(list_issues) == 0:
# Retrieve issues until there are no more to come
break
self.total_issues = self.total_issues + list_issues
block_num += 1
logger.info(
"Processing block of JIRA issues number: {}".format(block_num))
logger.info("Total number of JIRA issues: {}".format(
len(self.total_issues)))
return self.total_issues
def swipe_left(self, t=1000):
size = self.get_size()
y = int(size[1] * 0.5)
x1 = int(size[0] * 0.9)
x2 = int(size[0] * 0.1)
self.driver.swipe(x1, y, x2, y, t)
logger.info(u'向左滑动成功')
def send_meassurements(self, meassurements):
logger.info('Sending meassurements to Monasca...')
d = list()
d = [
self.payload_meassure(row) for row in meassurements.values
]
flatten_payload = [item for sublist in d for item in sublist]
logger.debug('Payload: {}'.format(flatten_payload))
try:
r = requests.post(self.url, json=flatten_payload,
headers=self.headers)
r.raise_for_status()
except requests.exceptions.HTTPError as errh:
logger.error("Http Error: {}".format(errh))
sys.exit(1)
except requests.exceptions.ConnectionError as errc:
logger.error("Error Connecting: {}".format(errc))
sys.exit(1)
except requests.exceptions.Timeout as errt:
logger.error("Timeout Error: {}".format(errt))
sys.exit(1)
except requests.exceptions.RequestException as err:
logger.error("OOps: Something Else: {}".format(err))
sys.exit(1)
logger.info(
'Meassurements sent to Monasca, status code: {}'.format(r.status_code))
def swipe_right(self, t=1000):
size = self.get_size()
y = int(size[1] * 0.5)
x1 = int(size[0] * 0.25)
x2 = int(size[0] * 0.75)
self.driver.swipe(x1, y, x2, y, t)
logger.info(u'向下滑动成功')
def get_token(self):
logger.info('Requesting token to Keytone...')
try:
r = requests.post(self.url,
json=self.payload,
headers=self.headers)
r.raise_for_status()
except requests.exceptions.HTTPError as errh:
logger.error("Http Error: {}".format(errh))
sys.exit(1)
except requests.exceptions.ConnectionError as errc:
logger.error("Error Connecting: {}".format(errc))
sys.exit(1)
except requests.exceptions.Timeout as errt:
logger.error("Timeout Error: {}".format(errt))
sys.exit(1)
except requests.exceptions.RequestException as err:
logger.error("OOps: Something Else: {}".format(err))
sys.exit(1)
token = r.headers['X-Subject-Token']
logger.info('Token obtained, status code: {}'.format(r.status_code))
logger.debug('Token: {}'.format(token))
return token
def get_service(api_name):
logger.info("Get Google service for API {}".format(api_name))
service = {'sheets': 'v4', 'analytics': 'v3', 'analyticsreporting': 'v4'}
discoveryServiceUrl = {
'sheets':
'https://sheets.googleapis.com/$discovery/rest?version=v4',
'analytics':
'none',
'analyticsreporting':
'https://analyticsreporting.googleapis.com/$discovery/rest'
}
try:
credentials = get_credentials(api=api_name)
except ValueError:
raise
else:
http_auth = credentials.authorize(Http())
if api_name is 'analytics':
result = discovery.build(serviceName=api_name,
version=service[api_name],
http=http_auth,
cache_discovery=False)
else:
result = discovery.build(
serviceName=api_name,
version=service[api_name],
http=http_auth,
discoveryServiceUrl=discoveryServiceUrl[api_name],
cache_discovery=False)
return result
def swipe_down(self, t=1000):
size = self.get_size()
x = int(size[0] * 0.5)
y1 = int(size[1] * 0.1)
y2 = int(size[1] * 0.9)
self.driver.swipe(x, y1, x, y2, t)
logger.info(u'向下滑动成功')
def main_publisher_distributed():
n_data = []
for x in range(0, 100000):
res = add.delay(x)
with allow_join_result():
n_data.append(res.get())
logger.info("Result data : {} ".format(n_data))
def login_action(self,username,password):
logger.info('============login_action==============')
logger.info('username is:%s' %username)
self.driver.find_element(*self.username_type).send_keys(username)
logger.info('password is:%s'%password)
self.driver.find_element(*self.password_type).send_keys(password)
logger.info('click loginBtn')
self.driver.find_element(*self.loginBtn).click()
logger.info('login finished!')
def find_elements(self, locator, loc_time=10):
try:
elements = WebDriverWait(self.driver, loc_time).until(
ec.presence_of_all_elements_located(locator))
logger.info(u'找到元素' + '%s' % (list(locator)))
return elements
except Exception as msg:
logger.error('未找到元素' + '%s' % list(locator))
logger.error("报错信息是：%s" % msg)
def check_loginStatus(self):
logger.info('====check_loginStatus======')
time.sleep(2)
try:
element = self.driver.find_element(*self.loginCheck)
except NoSuchElementException:
logger.error('login Fail!')
self.getScreenShot('login')
return False
else:
logger.info('login success!')
return True
def switch_to_context(self, con_type):
try:
if con_type == '1':
self.driver.switch_to.context('NATIVE_APP')
logger.info(u'切换到NATIVE_APP成功')
else:
contexts = self.get_contexts()
self.driver.switch_tocontent(contexts[1])
logger.info(u'切换到%s成功' % contexts[1])
except Exception as msg:
logger.error(u'切换content失败')
logger.error("报错信息是：%s" % msg)
def get_ele_attribute(self, locator, ele_type):
try:
element = self.find_element(locator)
if ele_type == 'text':
return element.text
else:
return element.get_attribute(ele_type)
except Exception as msg:
logger.error(u"获取%s失败" % list(locator))
logger.effor("报错信息是：%s" % msg)
else:
logger.info(u"获取%s成功，值为：%s" % (list(locator), element.text))
def get_credentials(api):
"""Gets valid user credentials from storage.
If nothing has been stored, or if the stored credentials are invalid,
the OAuth2 flow is completed to obtain the new credentials.
:param api:
api - API from which we want to obtain the credentials.
:return:
Credentials, the obtained credential.
"""
logger.info("Get Google credential for API {}".format(api))
# If modifying these scopes, delete your previously saved credentials
# at ./.credentials/sheets.googleapis.com.json
scope = {
'sheets': 'https://www.googleapis.com/auth/spreadsheets',
'analytics': 'https://www.googleapis.com/auth/analytics.readonly',
'analyticsreporting':
'https://www.googleapis.com/auth/analytics.readonly'
}
credential_folder = os.path.join(CODE_HOME, CREDENTIAL_DIR)
logger.debug("Credential dir: {}".format(credential_folder))
if not os.path.exists(credential_folder):
try:
os.makedirs(credential_folder)
except OSError as e:
logger.error(
"Unable to create the corresponding directory: {}".format(
e.message))
credential_path = os.path.join(credential_folder, CREDENTIAL_FILE)
if api == 'sheets':
store = Storage(credential_path)
credentials = store.get()
if not credentials or credentials.invalid:
flow = client.flow_from_clientsecrets(CREDENTIAL, scope[api])
flow.user_agent = APPLICATION_NAME
credentials = tools.run_flow(flow, store, flags)
else:
credentials = ServiceAccountCredentials.from_json_keyfile_name(
os.path.join(SERVICE_ACCOUNT_KEY_HOME, SERVICE_ACCOUNT_KEY),
scopes=scope[api])
return credentials
def find_element(self, locator, loc_time=10):
"""
查找元素
:param locator: 元素的元祖参数
:param loc_time: 查找时间，默认超时时间10s
:return:
"""
try:
element = WebDriverWait(self.driver, loc_time).until(
ec.presence_of_element_located(locator))
return element
except WebDriverException:
logger.error('未找到元素' + '%s' % list(locator))
else:
logger.info(u'找到元素%s' % (list(locator)))
def get_driver(plat_name, device_name, plat_version, app_package,
app_activity):
desired_caps = {
'platformName': plat_name,
'deviceName': device_name,
'platformVersion': plat_version,
'appPackage': app_package,
'appActivity': app_activity,
'unicodeKeyboard': True,
'resetKeyboard': True,
"noReset": True
}
driver = webdriver.Remote('http://127.0.0.1:4723/wd/hub', desired_caps)
logger.info(u'获取driver成功')
return driver
def send_text(self, locator, text):
"""
:param locator: 定位元素
:param text: 输入的文本信息
:return:
"""
try:
element = self.find_element(locator)
element.clear()
element.send_keys(text)
except Exception as msg:
logger.error(u'输入%s失败，原因是%s' % (text, msg))
else:
logger.info(u'输入%s成功' % text)
def select(self, locator1, locator2, locator3):
"""
:param locator1: 第一个点击的元素，点击进入弹框页面
:param locator2: 定位弹框里的一组元素，任意选择其中的一个点击
:param locator3: 弹框中的确定按钮
:return:
"""
try:
self.find_element(locator1).click()
elements = self.find_elements(locator2)
num = random.randint(0, len(elements) - 1)
elements[num].click()
self.find_element(locator3).click()
logger.info(u'选择%s成功' % list(locator2))
except Exception as msg:
logger.info(u'选择%s失败' % list(locator2))
logger.error("报错信息是：%s" % msg)
def send_to_text(self, locator1, locator2, text, locator3):
"""
定位到元素后，点击在新的页面填写内容，保存后再回到之前页面
:param locator1: 定位的元素
:param locator2: 输入内容框的元素
:param locator3: 保存按钮
:param text: 输入的内筒
:return:
"""
try:
self.find_element(locator1).click()
self.send_text(locator2, text)
self.find_element(locator3).click()
logger.info(u'输入%s成功' % text)
except Exception as msg:
logger.error(u'输入%s失败' % text)
logger.error("报错信息是：%s" % msg)
def upsert_tweets_username(log_user, tweets):
"""
Insere um log_user na tabela de log_update_tweets
Insere um array de objetos de tweets no banco de dados
Caso já exista então atualiza
Parâmetros
----------
log_user : dict
Dicionário com o username para ser inserido/atualizado.
exemplo dict(username='******', updated='2019-02-01T14:34:11Z')
tweets : list
list de dicionários com os tweets para serem inseridos/atualizados.
exemplo: [dict(id_tweet='1', username='******', text='tweet')]
"""
session = Session()
insert_log_user = insert(Log_update_tweets).values(log_user)
update_columns_username = {
col.name: col
for col in insert_log_user.excluded if col.name not in ('username')
}
do_update_username = insert_log_user.on_conflict_do_update(
index_elements=['username'], set_=update_columns_username)
session.execute(do_update_username)
if (len(tweets) > 0):
insert_tweet = insert(Tweet).values(tweets)
update_columns_tweet = {
col.name: col
for col in insert_tweet.excluded if col.name not in ('id_tweet')
}
do_update_stmt = insert_tweet.on_conflict_do_update(
index_elements=['id_tweet'], set_=update_columns_tweet)
session.execute(do_update_stmt)
else:
logger.info("Nenhum novo tweet foi capturado para " +
log_user['username'])
# Realiza commit e encerra sessão
session.commit()
session.close()
def get_tweets_by_username(username, since_date, until_date):
"""
Recupera tweets de um usuário para um intervalo de datas
----------
username : str
username do perfil no Twitter
since_date : datetime
Data inicial do intervalo de captura
until_date : datetime
Data final do intervalo de captura
"""
tweets = []
query = "from:"+username+" since:" + \
since_date.strftime('%Y-%m-%d')+" until:" + \
until_date.strftime('%Y-%m-%d')
try:
logger.info(query)
result = subprocess.run(["snscrape", "--jsonl", "twitter-search", query],
universal_newlines=True, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
for r in result.stdout.split('\n'):
try:
res = json.loads(r)
id_tweet = res['id']
text = re.sub('\n', ' ', res['content'])
text = text.replace('\"', '“')
date = res['date']
url = res['url']
reply_count = int(res['replyCount'])
retweet_count = int(res['retweetCount'])
like_count = int(res['likeCount'])
quote_count = int(res['quoteCount'])
tweet = dict(id_tweet=id_tweet, username=username, text=text,
date=date, url=url,
reply_count=reply_count, retweet_count=retweet_count,
like_count=like_count, quote_count=quote_count)
tweets.append(tweet)
except Exception as e:
# print(e)
pass
except Exception as e:
raise Exception("Não foi possível baixar os dados dos tweets")
return tweets
def obtain(self):
for source in db.query(Source):
logger.info(source.name)
# if source.name != 'Academy': continue
metrics = db.query(Metric).filter_by(source_id=source.id).all()
try:
op_source = eval('{}()'.format(source.name))
except Exception as e:
logger.error('source {} is not implemented'.format(
source.name))
logger.error(e)
continue
for metric in metrics:
try:
value = op_source.get_measurement(metric)
except NotDefined:
value = 'Not Defined'
except NotImplemented:
value = 'No Impl'
except InvalidConection:
value = 'No Connect'
except Exception as e:
logger.error(e)
value = 'No Access'
params = {
'metric_id': metric.id,
'date': datetime.now(),
'value': value.replace(',', '')
}
logger.debug(params)
measurement = Measurement(**params)
db.add(measurement)
else:
db.commit()
def appium_desired():
#从config包中app_caps.yaml文件中读取配置信息
with open('../config/app_caps.yaml', 'r', encoding='utf-8') as file:
data = yaml.load(file)
desired_caps = {}
desired_caps['platformName'] = data['platformName']
desired_caps['platformVersion'] = data['platformVersion']
desired_caps['deviceName'] = data['deviceName']
base_dir = os.path.dirname(os.path.dirname(__file__))
app_path = os.path.join(base_dir, 'app', data['appname'])
desired_caps['app'] = app_path
desired_caps['appPackage'] = data['appPackage']
desired_caps['appActivity'] = data['appActivity']
desired_caps['noReset'] = False
desired_caps['unicodeKeyboard'] = data['unicodeKeyboard']
desired_caps['resetKeyboard'] = data['resetKeyboard']
logger.info('start app...')
driver = webdriver.Remote(
'http://' + str(data['ip']) + ':' + str(data['port']) + '/wd/hub',
desired_caps)
driver.implicitly_wait(8)
return driver
def testBooking(self,data):
try:
#每次用例执行前重启APP（APP不能像web端一样，用例执行前通过地址栏跳转至固定页面，只能通过重启的方式来实现固定流程）
self.driver.launch_app()
#登录
l=LoginView(self.driver)
l.login_action('17708179510',123456)
logger.info('======test_booking=====')
time.sleep(2)
#订单业务
a = BookingView(self.driver)
self.bh = data['编号']
# 最后一个参数电话号码，是用来找到这个输入域的，因为元素定位不到，且输入域中有默认值，所有根据默认值来定位电话号码输入域，然后再把他清除掉，传入生成的随机电话
# 里面的服务名称都是乱编的，二天跑的时候，需要按照具体情况去修改新增订单选择的农机或农资的名称
#123是电话号码输入域的默认值
a.booking_action(data['编号'],data['服务类型'],data["服务名称"],data["服务数量"],'123')
# 看看新增订单的实际情况，如果新增成功，就在excel中记录"T",失败的话记录“F”
self.re = a.check_bookingStatus()
if self.re == True:
workbook = xlrd.open_workbook('../data/booking.xls')
excel =copy(workbook)
# excel.get_sheet()中的参数0表示第一个sheet表，改为参数1的话就表示在第二个sheet表中添加数据
table = excel.get_sheet(0)
table.write(int(self.bh),5,'ok')
excel.save('../data/booking.xls')
else:
workbook = xlrd.open_workbook('../data/booking.xls')
excel =copy(workbook)
table = excel.get_sheet(0)
table.write(int(self.bh),5,'ko')
excel.save('../data/booking.xls')
# 再从excel中读取实际结果和预期结果，判断是否一致
self.yuqi = data['预期结果']
self.assertEqual(self.yuqi,self.re)
#每次用例结束后，关闭APP
self.driver.close_app()
except NoSuchElementException:
file_name = "no_such_element"
b = Common(self.driver)
b.getScreenShot(file_name)
workbook = xlrd.open_workbook('../data/booking.xls')
excel =copy(workbook)
table = excel.get_sheet(0)
table.write(int(self.bh),5,'ko')
excel.save('../data/booking.xls')
self.assertEqual(self.yuqi,False)
self.driver.close_app()
raise
except ElementNotVisibleException:
file_name = "element_not_visible"
b = Common(self.driver)
b.getScreenShot(file_name)
workbook = xlrd.open_workbook('../data/booking.xls')
excel =copy(workbook)
table = excel.get_sheet(0)
table.write(int(self.bh),5,'ko')
excel.save('../data/booking.xls')
self.assertEqual(self.yuqi,False)
self.driver.close_app()
raise
def setUpClass(cls):
warnings.simplefilter("ignore", ResourceWarning)
logger.info('=====setUp====')
cls.driver = appium_desired()
def create_schema():
logger.info("Criando tabelas do banco de dados...")
create_tables()
def drop_schema():
logger.info("Dropando tabelas do banco de dados...")
drop_tables()
import time
from common.HTMLTestRunner import HTMLTestRunner
from common import send_email
from config.log import logger
from test_case_app import test_appDemand
from test_case_business import test_processingDemand
from test_case_business import test_processing_order_xq
from test_case_app import test_check
from test_case_app import test_booking
from test_case_business import test_processing_order_booking
from test_case_app import test_check
#设置测试用例、测试报告路径
test_dir='../test_case_business'
report_dir='../reports'
logger.info('start run test case...')
#加载测试用例
suite = unittest.TestSuite()
# suite.addTest(unittest.makeSuite(test_appDemand.TestAppDemand))
# suite.addTest(unittest.makeSuite(test_processingDemand.TestprocessingDemand))
suite.addTest(unittest.makeSuite(test_processing_order_xq.TestprocessingOderXq))
suite.addTest(unittest.makeSuite(test_booking.TestBooking))
# suite.addTest(unittest.makeSuite(test_processing_order_booking.TestprocessingOder))
# suite.addTest(unittest.makeSuite(test_check.TestCheck))
##设置测试报告名称
now=time.strftime('%Y-%m-%d %H_%M_%S')
report_name=report_dir+'/'+now+'report.html'
#执行测试用例生成测试报告
