Partie1Contexte
Les applications Internet fournissent des services et interagissent avec les opérations des utilisateurs. Le trafic généré par leurs actions contient de nombreuses valeurs exploitables, telles que l'analyse des performances, la comparaison des données, l'analyse du comportement, etc. Le trafic des utilisateurs est comme le pétrole dans le monde réel, et nous pouvons en extraire de nombreuses utilisations évolutives.
Cette série développe la conception d'applications pour le trafic des testeurs du point de vue des tests logiciels, formant une plate-forme de gestion du trafic qui intègre l'enregistrement du trafic, la lecture du trafic, la comparaison en temps réel, l'édition des cas d'utilisation du trafic et la gestion des utilisateurs pour améliorer l'efficacité du travail de test et fournir plusieurs -facettes Vérifier la qualité des produits logiciels.
Conception d'architecture partie 2
Diagramme de flux de données de la fonction d'enregistrement du trafic
Effet de mise en œuvre de la partie 3
Enregistrez les journaux de création de tâches, d'agent et de surveillance :
Générez des cas d'utilisation basés sur le trafic :
Conception fonctionnelle partie 4
Les principales fonctions du module d'enregistrement du trafic sont :
-
Liste d'informations sur les tâches
-
Créer une tâche d'enregistrement
-
Modifier les informations sur la tâche
-
effectuer des tâches
-
Visualisez les journaux de trafic en temps réel
-
Afficher les informations détaillées
-
Personnalisez les cas d'utilisation du trafic et stockez-les
-
Liste de cas d'utilisation
-
Détails du cas d'utilisation, modifier
Toutes les listes et données détaillées du système sont indissociables des quatre interfaces "ajouter, supprimer, modifier et vérifier". Les suppressions du système sont actuellement des suppressions logiques et l'affichage est contrôlé en définissant des valeurs d'état pour préparer la récupération ultérieure des données. et les problèmes.
L'une des fonctionnalités les plus spéciales est la fonction d'affichage du journal de trafic en temps réel. En raison de la nature asynchrone de l'interface http, il est difficile d'assurer le temps réel et la sérialisation des données du journal. La double garantie adoptée ici est donc principalement une connexion longue websocket et complétée par une interface http. Bénéficiant également de l'open source du projet mitmproxy, j'ai combiné l'API du système et réalisé un deuxième développement personnalisé de sa méthode d'interface pour m'adapter aux besoins en données de ce système et maintenir l'exactitude des données.
Partie 5 Problèmes et solutions
1. Comment isoler les différentes exigences de configuration du multitâche ?
Solution : Avant le premier démarrage du système, le DockerFile encapsulé doit être exécuté pour créer l'image de base dont nous avons besoin. Le système utilise le service Docker pour créer un conteneur Docker basé sur les informations de configuration de la tâche (hôte, agent, etc.). En fait, l'image Docker à l'heure actuelle a encapsulé les outils et la configuration de base requis pour l'exécution du conteneur. Chaque conteneur est créé et monté sur son propre port indépendant pour obtenir une isolation.
2Comment obtenir des journaux de trafic en temps réel ?
Solution : Mitmproxy dans le conteneur dispose de plusieurs méthodes de démarrage, chacune avec des scénarios d'utilisation différents. Parmi eux, le proxy démarré en mode mitmweb aura un service socket. Grâce au développement personnalisé de cette interface, il peut prendre en charge nos connexions inter-domaines. Et analyser les informations du message, puis grâce au rendu frontal, vous pouvez obtenir la fonction d'affichage du journal en temps réel.
3. Que dois-je faire si l'interface reste bloquée à cause d'un trop grand nombre de journaux ?
Solution : Il est préférable de limiter la taille du contenu du journal en fonction du scénario d'utilisation réel. Dans le même temps, le frontal utilise une liste virtuelle, qui ne restitue que la zone visible et une petite quantité de données DOM qui seront visibles. , et calcule la hauteur du conteneur en fonction de la longueur des données. Vous pouvez écrire vos propres composants pour créer et détruire Dom. Ce système utilise le composant virtualizedtableforantd4 qui combine réagir-virtualisé et antd pour obtenir la stabilité et l'optimisation des performances du module d'affichage du journal.
4. Comment gérer une grande quantité de données lors de la génération de cas d'utilisation pour le trafic ?
Solution : Pour enregistrer des cas d'utilisation avec une grande quantité de données, lors de la génération du cas d'utilisation, un fichier de vidage pouvant être utilisé pour la lecture sera généré et enregistré en demandant une valeur transmise à l'interface de vidage personnalisée en fonction de l'ID de trafic vérifié. Dans le même temps, afin de faciliter l'affichage frontal et l'édition ultérieure, le trafic doit être stocké dans le tableau des cas d'utilisation. Lorsque la quantité de données dépasse la limite, l'arrière-plan supprime certaines valeurs de champ redondantes et les découpe dans la base de données pour garantir la stabilité du système.
5Comment gérer le trafic https ?
Solution : le trafic https doit être analysé et obtenu en installant le certificat intermédiaire de mitmproxy. Il y a un point à noter ici : les appareils mobiles Android après la version 6.0 ne peuvent pas analyser https via de faux certificats. Le moyen simple consiste à obtenir le certificat du serveur et à utiliser openssl pour générer un certificat pem. Configurez le certificat pem pour le projet dans le système. Lorsque le proxy du projet démarre, utilisez ce certificat pour analyser la requête https du nom de domaine spécifié. Cela résoudra les données https demandées par toutes les sources.
Implémentation du code de base de la partie 6
La partie centrale de ce module fonctionnel concerne le script de gestion des conteneurs pour la préparation des données, la gestion de la configuration et la gestion des conteneurs.
Conception de composants de table virtuelle frontale
import React, { useRef, useEffect, useMemo } from 'react';
import { Table } from 'antd';
import { useVT } from 'virtualizedtableforantd4';
const MyRow = React.forwardRef((props, ref) => {
const { children, ...rest } = props;
return <tr {...rest} ref={ref}>{children}</tr>;
});
function CustomRowsHooks(props) {
const columns = useRef(props.columns);
const [VT, setVT] = useVT(() => ({ scroll: { y: 600 }, debug: true }));
useMemo(() => setVT({ body: { row: MyRow } }), [setVT]);
return (
<Table
{...props}
components={VT}
scroll={
{ y: 600 }}
dataSource={props.dataSource}
columns={columns.current}
/>
);
}
export default CustomRowsHooks;
Script principal du serveur
Le code complet du script est le suivant :
#-*-coding:utf-8-*-
__author__="orion-c"
def buildContainer(taskInfo, mountPort, wsMountPort, projectDir):
for i in range(5):
if len(os.listdir(projectDir)) > 0:
break
time.sleep(1)
if sys.platform.startswith('win'):
projectDir = "/taskFile/"+projectDir.split('taskFile\\')[1]
formatHost = {}
try:
if taskInfo:
if taskInfo['hosts']:
hosts = taskInfo['hosts'].split('\n')
for host in hosts:
host = ' '.join(host.split())
host = host.split(' ')
if len(host) == 2:
formatHost[host[1]] = host[0]
try:
container = docker_client.containers.get(str(mountPort))
if container.status == 'exited':
container.remove()
logger.info('移除容器成功：{}'.format(str(mountPort)))
except:
logger.info('can build')
docker_client.containers.run(
name=mountPort,
image='myproxy:0.0.13',
command='/bin/bash -c "sh /root/script/start_sync.sh"',
volumes={
projectDir: {'bind': '/root/script', 'mode': 'rw'}
},
ports={'8080': mountPort, '8081': wsMountPort},
extra_hosts=formatHost,
stderr=True,
detach=True
)
logger.info('任务 {} 创建容器 {} 成功，ws端口 {}'.format(taskInfo['id'], mountPort, wsMountPort))
return str(mountPort)
except Exception as e:
logger.error(e)
logger.error('创建容器：{} 失败'.format(mountPort))
logger.error('请检查你的docker服务')
def copyDumpFile(projectDir, content):
dumpFilePath = content['suiteInfo']['dumpFile']
dumpFilePath = '../../' + dumpFilePath if os.path.isfile('../../' + dumpFilePath) else dumpFilePath
replayDumpFile = projectDir + '/replayDumpFile'
shutil.copyfile(dumpFilePath, replayDumpFile)
def makeSyncReplayShell(projectDir, mountPort, content):
shellPath = '../../templte/start_sync.sh' if os.path.isfile('../../templte/start_sync.sh') else 'templte/start_sync.sh'
with open(shellPath, 'r', encoding='utf-8') as shellFile:
shellTemplte = shellFile.read()
cmd = "mitmdump -nC /root/script/replayDumpFile -s /root/script/getReplayResponse.py --ssl-insecure --set ssl_version_client=all --set ssl_version_server=all"
if content['proxySetting']:
cmd = cmd + " --set http2=false --set mode=upstream:{proxySetting}".format(proxySetting=content['proxySetting'])
if content['cerPem'] and content['domain']:
cmd = cmd + " --certs {domain}=/root/script/cer.pem".format(domain= content['domain'])
shellConfig = shellTemplte.format(cmd= cmd)
with open(projectDir + '/start_sync.sh', 'w', encoding='utf-8') as file:
file.write(shellConfig)
def makePem(content,projectDir):
if content['cerPem'] and content['domain']:
with open(projectDir + '/cer.pem', 'w', encoding='utf-8') as file:
file.write(content['cerPem'])
def makeMiddlareScript(content,projectDir):
responsePath = '../../templte/getReplayResponse.py' if os.path.isfile('../../templte/getReplayResponse.py') else 'templte/getReplayResponse.py'
with open(responsePath, 'r', encoding='utf-8') as middlareFile:
middlareTemplte = middlareFile.read()
middlareConfig = middlareTemplte.format(appHost= app.config['HOST'],taskId=content['id'])
with open(projectDir + '/getReplayResponse.py', 'w', encoding='utf-8') as file:
file.write(middlareConfig)
def makeConfig(projectDir, mountPort, content):
copyDumpFile(projectDir,content)
makeSyncReplayShell(projectDir, mountPort,content)
makePem(content, projectDir)
makeMiddlareScript(content, projectDir)
@manager.option('-i','--taskId',dest='taskId',default='')
def runScript(taskId):
now = datetime.now().strftime('%Y-%m-%d_%H_%M_%S')
taskRootPath = encrypt_name(now)
content = getTaskInfo(taskId)
for i in range(2):
if i == 0:
proxyMountPort = freeport.get()
else:
wsMountPort = freeport.get()
projectDir = createProjectDir(taskRootPath)
makeConfig(projectDir, proxyMountPort, content)
setTaskStatus(taskId, 2, taskRootPath)
containName = buildContainer(content, proxyMountPort, wsMountPort, projectDir)
if containName:
setTaskStatus(taskId, 3, taskRootPath, containName, wsMountPort)
else:
setTaskStatus(taskId, 6)
Ce système adopte une architecture de séparation front-end et back-end. En raison de la complexité de l'architecture du système, cet article analyse et explique uniquement la conception et la mise en œuvre du module d'enregistrement du trafic. D'autres modules seront abordés séparément dans les articles suivants.
Enfin : le didacticiel vidéo complet sur les tests de logiciels ci-dessous a été compilé et mis en ligne. Les amis qui en ont besoin peuvent l'obtenir eux-mêmes [garanti 100 % gratuit]
Document d'entretien sur les tests logiciels
"Nous devons étudier pour trouver un emploi bien rémunéré. Les questions d'entretien suivantes proviennent des derniers documents d'entretien de sociétés Internet de premier plan telles que Alibaba, Tencent, Byte, etc., et certains patrons de Byte ont donné des réponses faisant autorité. Après avoir terminé cela Je crois que tout le monde peut trouver un emploi satisfaisant sur la base des informations recueillies lors de l'entretien.
