add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
#!/usr/bin/env python3
|
|
|
|
#
|
|
|
|
# (C) 2017 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
|
|
|
|
# All rights reserved.
|
|
|
|
#
|
|
|
|
# Author: Neels Hofmeyr <nhofmeyr@sysmocom.de>
|
|
|
|
#
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
|
|
# it under the terms of the GNU General Public License as published by
|
|
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
|
|
# (at your option) any later version.
|
|
|
|
#
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
# GNU General Public License for more details.
|
|
|
|
#
|
|
|
|
# You should have received a copy of the GNU General Public License
|
|
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
'''
|
2017-12-19 12:46:57 +00:00
|
|
|
Common code for VTY and CTRL interface interaction and transcript verification.
|
2017-10-18 01:20:04 +00:00
|
|
|
This implements all of application interaction, piping and verification.
|
2017-12-19 12:46:57 +00:00
|
|
|
vty.py and ctrl.py plug VTY and CTRL interface specific bits.
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
'''
|
|
|
|
|
2019-12-06 14:51:46 +00:00
|
|
|
# Our setup.py currently wants everything to be parsable by both py2 and py3.
|
|
|
|
# IMHO that is not a good idea, but until that changes, let's just keep this
|
|
|
|
# py2 legacy shim in here so we can syntax-check this py3 module with py2.
|
|
|
|
from __future__ import print_function
|
|
|
|
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
import argparse
|
|
|
|
import sys
|
|
|
|
import os
|
|
|
|
import subprocess
|
|
|
|
import time
|
|
|
|
import traceback
|
|
|
|
import socket
|
|
|
|
import shlex
|
2017-11-29 17:21:18 +00:00
|
|
|
import re
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
|
|
|
|
|
|
|
|
class Interact:
|
|
|
|
|
|
|
|
class StepBase:
|
|
|
|
command = None
|
|
|
|
result = None
|
|
|
|
leading_blanks = None
|
|
|
|
|
|
|
|
def __init__(self):
|
|
|
|
self.result = []
|
|
|
|
|
|
|
|
def verify_interact_state(self, interact_instance):
|
|
|
|
# for example to verify that the last VTY prompt received shows the
|
|
|
|
# right node.
|
|
|
|
pass
|
|
|
|
|
|
|
|
def command_str(self, interact_instance=None):
|
|
|
|
return self.command
|
|
|
|
|
|
|
|
def __str__(self):
|
|
|
|
return '%s\n%s' % (self.command_str(), '\n'.join(self.result))
|
|
|
|
|
|
|
|
@staticmethod
|
|
|
|
def is_next_step(line, interact_instance):
|
|
|
|
assert not "implemented by InteractVty.VtyStep and InteractCtrl.CtrlStep"
|
|
|
|
|
|
|
|
socket = None
|
|
|
|
|
|
|
|
def __init__(self, step_class, port, host, verbose=False, update=False):
|
|
|
|
'''
|
|
|
|
host is the hostname to connect to.
|
|
|
|
port is the CTRL port to connect on.
|
|
|
|
'''
|
|
|
|
self.Step = step_class
|
|
|
|
self.port = port
|
|
|
|
self.host = host
|
|
|
|
self.verbose = verbose
|
|
|
|
self.update = update
|
|
|
|
|
2017-10-18 00:09:08 +00:00
|
|
|
if not port:
|
|
|
|
raise Exception("You need to provide port number to connect to")
|
|
|
|
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
def connect(self):
|
|
|
|
assert self.socket is None
|
|
|
|
retries = 30
|
|
|
|
took = 0
|
|
|
|
while True:
|
|
|
|
took += 1
|
|
|
|
try:
|
|
|
|
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
|
|
self.socket.setblocking(1)
|
|
|
|
self.socket.connect((self.host, int(self.port)))
|
|
|
|
except IOError:
|
|
|
|
retries -= 1
|
|
|
|
if retries <= 0:
|
|
|
|
raise
|
|
|
|
time.sleep(.1)
|
|
|
|
continue
|
|
|
|
break
|
|
|
|
|
|
|
|
def close(self):
|
|
|
|
if self.socket is None:
|
|
|
|
return
|
|
|
|
self.socket.close()
|
|
|
|
self.socket = None
|
|
|
|
|
|
|
|
def command(self, command):
|
|
|
|
assert not "implemented separately by InteractVty and InteractCtrl"
|
|
|
|
|
|
|
|
def verify_transcript_file(self, transcript_file):
|
|
|
|
with open(transcript_file, 'r') as f:
|
|
|
|
content = f.read()
|
|
|
|
|
|
|
|
try:
|
|
|
|
result = self.verify_transcript(content)
|
|
|
|
except:
|
|
|
|
print('Error while verifying transcript file %r' % transcript_file, file=sys.stderr)
|
|
|
|
sys.stderr.flush()
|
|
|
|
raise
|
|
|
|
|
|
|
|
if not self.update:
|
|
|
|
return
|
|
|
|
content = '\n'.join(result)
|
|
|
|
with open(transcript_file, 'w') as f:
|
|
|
|
f.write(content)
|
|
|
|
|
|
|
|
def verify_transcript(self, transcript):
|
|
|
|
''''
|
|
|
|
transcript is a "screenshot" of a session, a multi-line string
|
|
|
|
including commands and expected results.
|
|
|
|
Feed commands to self.command() and verify the expected results.
|
|
|
|
'''
|
|
|
|
|
|
|
|
# parse steps
|
|
|
|
steps = []
|
|
|
|
step = None
|
|
|
|
blank_lines = 0
|
|
|
|
for line in transcript.splitlines():
|
|
|
|
if not line:
|
|
|
|
blank_lines += 1
|
|
|
|
continue
|
|
|
|
next_step_started = self.Step.is_next_step(line, self)
|
|
|
|
if next_step_started:
|
|
|
|
if step:
|
|
|
|
steps.append(step)
|
|
|
|
step = next_step_started
|
|
|
|
step.leading_blanks = blank_lines
|
|
|
|
blank_lines = 0
|
|
|
|
elif step:
|
|
|
|
# we only count blank lines directly preceding the start of a
|
|
|
|
# next step. Insert blank lines in the middle of a response
|
|
|
|
# back into the response:
|
|
|
|
if blank_lines:
|
|
|
|
step.result.extend([''] * blank_lines)
|
|
|
|
blank_lines = 0
|
|
|
|
step.result.append(line)
|
|
|
|
if step:
|
|
|
|
steps.append(step)
|
|
|
|
step = None
|
|
|
|
|
|
|
|
actual_result = []
|
|
|
|
|
|
|
|
# run steps
|
|
|
|
step_nr = 0
|
|
|
|
for step in steps:
|
|
|
|
step_nr += 1
|
|
|
|
try:
|
|
|
|
if self.verbose:
|
|
|
|
if step.leading_blanks:
|
|
|
|
print('\n' * step.leading_blanks, end='')
|
|
|
|
print(step.command_str())
|
|
|
|
sys.stdout.flush()
|
|
|
|
|
|
|
|
step.verify_interact_state(self)
|
|
|
|
|
|
|
|
res = self.command(step.command)
|
2018-09-10 13:49:54 +00:00
|
|
|
# trailing empty lines in the command output cannot be preserved because we allow
|
|
|
|
# arbitrary newlines between commands. Do not even track these.
|
|
|
|
while res and not res[-1]:
|
|
|
|
res = res[:-1]
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
|
|
|
|
if self.verbose:
|
|
|
|
sys.stderr.flush()
|
|
|
|
sys.stdout.flush()
|
|
|
|
print('\n'.join(res))
|
|
|
|
sys.stdout.flush()
|
|
|
|
|
|
|
|
if step.leading_blanks:
|
|
|
|
actual_result.extend([''] * step.leading_blanks)
|
|
|
|
actual_result.append(step.command_str(self))
|
|
|
|
|
|
|
|
match_result = self.match_lines(step.result, res)
|
|
|
|
|
|
|
|
if self.update:
|
|
|
|
if match_result is True:
|
|
|
|
# preserve any wildcards
|
|
|
|
actual_result.extend(step.result)
|
|
|
|
else:
|
|
|
|
# mismatch, take exactly what came in
|
|
|
|
actual_result.extend(res)
|
|
|
|
continue
|
|
|
|
if match_result is not True:
|
|
|
|
raise Exception('Result mismatch:\n%s\n\nExpected:\n[\n%s\n]\n\nGot:\n[\n%s\n%s\n]'
|
|
|
|
% (match_result, step, step.command_str(), '\n'.join(res)))
|
|
|
|
except:
|
|
|
|
print('Error during transcript step %d:\n[\n%s\n]' % (step_nr, step),
|
|
|
|
file=sys.stderr)
|
|
|
|
sys.stderr.flush()
|
|
|
|
raise
|
|
|
|
|
|
|
|
# final line ending
|
|
|
|
actual_result.append('')
|
|
|
|
return actual_result
|
|
|
|
|
|
|
|
@staticmethod
|
|
|
|
def match_lines(expect, got):
|
|
|
|
'''
|
|
|
|
Match two lists of strings, allowing certain wildcards:
|
|
|
|
- In 'expect', if a line is exactly '...', it matches any number of
|
|
|
|
arbitrary lines in 'got'; the implementation is trivial and skips
|
|
|
|
lines to the first occurence in 'got' that continues after '...'.
|
2017-11-29 17:21:18 +00:00
|
|
|
- If an 'expect' line is '... !regex', it matches any number of
|
|
|
|
lines like '...', but the given regex must not match any of those
|
|
|
|
lines.
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
|
|
|
|
Return 'True' on match, or a string describing the mismatch.
|
|
|
|
'''
|
|
|
|
def match_line(expect_line, got_line):
|
|
|
|
return expect_line == got_line
|
|
|
|
|
2017-11-29 17:21:18 +00:00
|
|
|
ANY = '...'
|
|
|
|
ANY_EXCEPT = '... !'
|
|
|
|
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
e = 0
|
|
|
|
g = 0
|
|
|
|
while e < len(expect):
|
2017-11-29 17:21:18 +00:00
|
|
|
if expect[e] == ANY or expect[e].startswith(ANY_EXCEPT):
|
|
|
|
wildcard = expect[e]
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
e += 1
|
2017-11-29 17:21:18 +00:00
|
|
|
g_end = g
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
|
|
|
|
if e >= len(expect):
|
|
|
|
# anything left in 'got' is accepted.
|
2017-11-29 17:21:18 +00:00
|
|
|
g_end = len(got)
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
|
|
|
|
# look for the next occurence of the expected line in 'got'
|
2017-11-29 17:21:18 +00:00
|
|
|
while g_end < len(got) and not match_line(expect[e], got[g_end]):
|
|
|
|
g_end += 1
|
|
|
|
|
|
|
|
if wildcard == ANY:
|
|
|
|
# no restrictions on lines
|
|
|
|
g = g_end
|
|
|
|
|
|
|
|
elif wildcard.startswith(ANY_EXCEPT):
|
|
|
|
except_re = re.compile(wildcard[len(ANY_EXCEPT):])
|
|
|
|
while g < g_end:
|
|
|
|
if except_re.search(got[g]):
|
|
|
|
return ('Got forbidden line for wildcard %r:'
|
|
|
|
' did not expect %r in line %d of response'
|
|
|
|
% (wildcard, got[g], g))
|
|
|
|
g += 1
|
|
|
|
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
continue
|
|
|
|
|
|
|
|
if g >= len(got):
|
|
|
|
return 'Cannot find line %r' % expect[e]
|
|
|
|
|
|
|
|
if not match_line(expect[e], got[g]):
|
|
|
|
return 'Mismatch:\nExpect:\n%r\nGot:\n%r' % (expect[e], got[g])
|
|
|
|
|
|
|
|
e += 1
|
|
|
|
g += 1
|
|
|
|
|
|
|
|
if g < len(got):
|
|
|
|
return 'Did not expect line %r' % got[g]
|
|
|
|
return True
|
|
|
|
|
2017-10-18 00:45:10 +00:00
|
|
|
def feed_commands(self, output, command_strs):
|
|
|
|
for command_str in command_strs:
|
|
|
|
for command in command_str.splitlines():
|
|
|
|
res = self.command(command)
|
|
|
|
output.write('\n'.join(res))
|
|
|
|
output.write('\n')
|
|
|
|
|
2017-10-18 01:20:04 +00:00
|
|
|
def end_process(proc, quiet=False):
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
if not proc:
|
|
|
|
return
|
|
|
|
|
|
|
|
rc = proc.poll()
|
|
|
|
if rc is not None:
|
2017-10-18 01:20:04 +00:00
|
|
|
if not quiet:
|
|
|
|
print('Process has already terminated with', rc)
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
proc.wait()
|
|
|
|
return
|
|
|
|
|
|
|
|
proc.terminate()
|
|
|
|
time_to_wait_for_term = 5
|
|
|
|
wait_step = 0.001
|
|
|
|
waited_time = 0
|
|
|
|
while True:
|
|
|
|
# poll returns None if proc is still running
|
|
|
|
if proc.poll() is not None:
|
|
|
|
break
|
|
|
|
waited_time += wait_step
|
|
|
|
# make wait_step approach 1.0
|
|
|
|
wait_step = (1. + 5. * wait_step) / 6.
|
|
|
|
if waited_time >= time_to_wait_for_term:
|
|
|
|
break
|
|
|
|
time.sleep(wait_step)
|
|
|
|
|
|
|
|
if proc.poll() is None:
|
|
|
|
# termination seems to be slower than that, let's just kill
|
|
|
|
proc.kill()
|
2017-10-18 01:20:04 +00:00
|
|
|
if not quiet:
|
|
|
|
print("Killed child process")
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
elif waited_time > .002:
|
2017-10-18 01:20:04 +00:00
|
|
|
if not quiet:
|
|
|
|
print("Terminating took %.3fs" % waited_time)
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
proc.wait()
|
|
|
|
|
|
|
|
class Application:
|
|
|
|
proc = None
|
|
|
|
_devnull = None
|
|
|
|
|
|
|
|
@staticmethod
|
|
|
|
def devnull():
|
|
|
|
if Application._devnull is None:
|
|
|
|
Application._devnull = open(os.devnull, 'w')
|
|
|
|
return Application._devnull
|
|
|
|
|
2017-10-18 00:45:10 +00:00
|
|
|
def __init__(self, run_app_str, purge_output=True, quiet=False):
|
|
|
|
self.command_tuple = shlex.split(run_app_str)
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
self.purge_output = purge_output
|
2017-10-18 00:45:10 +00:00
|
|
|
self.quiet = quiet
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
|
|
|
|
def run(self):
|
|
|
|
out_err = None
|
|
|
|
if self.purge_output:
|
|
|
|
out_err = Application.devnull()
|
|
|
|
|
2017-10-18 00:45:10 +00:00
|
|
|
if not self.quiet:
|
|
|
|
print('Launching: cd %r; %s' % (os.getcwd(), ' '.join(self.command_tuple)))
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
self.proc = subprocess.Popen(self.command_tuple, stdout=out_err, stderr=out_err)
|
|
|
|
|
|
|
|
def stop(self):
|
2017-10-18 01:20:04 +00:00
|
|
|
end_process(self.proc, self.quiet)
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
|
2017-10-18 00:45:10 +00:00
|
|
|
def verify_application(run_app_str, interact, transcript_file, verbose):
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
passed = None
|
|
|
|
application = None
|
|
|
|
|
|
|
|
sys.stdout.flush()
|
|
|
|
sys.stderr.flush()
|
|
|
|
|
2017-10-18 00:45:10 +00:00
|
|
|
if run_app_str:
|
|
|
|
application = Application(run_app_str, purge_output=not verbose)
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
application.run()
|
|
|
|
|
|
|
|
try:
|
|
|
|
interact.connect()
|
|
|
|
interact.verify_transcript_file(transcript_file)
|
|
|
|
passed = True
|
|
|
|
except:
|
|
|
|
traceback.print_exc()
|
|
|
|
passed = False
|
|
|
|
interact.close()
|
|
|
|
|
|
|
|
if application:
|
|
|
|
application.stop()
|
|
|
|
|
|
|
|
sys.stdout.flush()
|
|
|
|
sys.stderr.flush()
|
|
|
|
|
|
|
|
return passed
|
|
|
|
|
2017-12-19 12:46:57 +00:00
|
|
|
def common_parser(doc=None):
|
|
|
|
parser = argparse.ArgumentParser(description=doc,
|
|
|
|
formatter_class=argparse.RawDescriptionHelpFormatter)
|
2017-10-18 00:45:10 +00:00
|
|
|
parser.add_argument('-r', '--run', dest='run_app_str',
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
help='command to run to launch application to test,'
|
|
|
|
' including command line arguments. If omitted, no'
|
|
|
|
' application is launched.')
|
|
|
|
parser.add_argument('-p', '--port', dest='port',
|
2017-10-18 01:53:06 +00:00
|
|
|
help="Port to reach the application at.")
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
parser.add_argument('-H', '--host', dest='host', default='localhost',
|
2017-10-18 01:53:06 +00:00
|
|
|
help="Host to reach the application at.")
|
2017-10-18 01:20:04 +00:00
|
|
|
return parser
|
|
|
|
|
|
|
|
def parser_add_verify_args(parser):
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
parser.add_argument('-u', '--update', dest='update', action='store_true',
|
|
|
|
help='Do not verify, but OVERWRITE transcripts based on'
|
2017-10-18 01:53:06 +00:00
|
|
|
' the application\'s current behavior. OVERWRITES TRANSCRIPT'
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
' FILES.')
|
|
|
|
parser.add_argument('-v', '--verbose', action='store_true',
|
|
|
|
help='Print commands and application output')
|
2017-10-18 01:20:04 +00:00
|
|
|
parser.add_argument('transcript_files', nargs='*', help='transcript file(s) to verify')
|
|
|
|
return parser
|
|
|
|
|
|
|
|
def parser_add_run_args(parser):
|
2017-10-18 00:45:10 +00:00
|
|
|
parser.add_argument('-O', '--output', dest='output_path',
|
2017-10-18 01:20:04 +00:00
|
|
|
help="Write command results to a file instead of stdout."
|
|
|
|
"('-O -' writes to stdout and is the default)")
|
2017-10-18 00:45:10 +00:00
|
|
|
parser.add_argument('-c', '--command', dest='cmd_str',
|
2017-10-18 01:20:04 +00:00
|
|
|
help="Run this command (before reading input files, if any)."
|
|
|
|
" multiple commands may be separated by ';'")
|
|
|
|
parser.add_argument('cmd_files', nargs='*', help='file(s) with plain commands to run')
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
return parser
|
|
|
|
|
2017-10-18 01:20:04 +00:00
|
|
|
def main_run_commands(run_app_str, output_path, cmd_str, cmd_files, interact):
|
2017-10-18 00:45:10 +00:00
|
|
|
to_stdout = False
|
2017-10-18 01:20:04 +00:00
|
|
|
if not output_path or output_path == '-':
|
2017-10-18 00:45:10 +00:00
|
|
|
to_stdout = True
|
|
|
|
output = sys.stdout
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
else:
|
2017-10-18 00:45:10 +00:00
|
|
|
output = open(output_path, 'w')
|
|
|
|
|
|
|
|
application = None
|
|
|
|
|
|
|
|
if run_app_str:
|
|
|
|
application = Application(run_app_str, quiet=to_stdout)
|
|
|
|
application.run()
|
|
|
|
|
|
|
|
try:
|
|
|
|
interact.connect()
|
|
|
|
|
|
|
|
if cmd_str:
|
|
|
|
interact.feed_commands(output, cmd_str.split(';'))
|
|
|
|
|
|
|
|
for f_path in (cmd_files or []):
|
|
|
|
with open(f_path, 'r') as f:
|
2019-10-31 04:32:31 +00:00
|
|
|
interact.feed_commands(output, f.read().splitlines())
|
2017-10-18 00:45:10 +00:00
|
|
|
|
|
|
|
if not (cmd_str or cmd_files):
|
|
|
|
while True:
|
|
|
|
line = sys.stdin.readline()
|
|
|
|
if not line:
|
|
|
|
break;
|
|
|
|
interact.feed_commands(output, line.split(';'))
|
|
|
|
except:
|
|
|
|
traceback.print_exc()
|
|
|
|
finally:
|
|
|
|
if not to_stdout:
|
|
|
|
try:
|
|
|
|
output.close()
|
|
|
|
except:
|
|
|
|
traceback.print_exc()
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
|
2017-10-18 00:45:10 +00:00
|
|
|
try:
|
|
|
|
interact.close()
|
|
|
|
except:
|
|
|
|
traceback.print_exc()
|
|
|
|
|
|
|
|
if application:
|
|
|
|
try:
|
|
|
|
application.stop()
|
|
|
|
except:
|
|
|
|
traceback.print_exc()
|
|
|
|
|
2017-10-18 01:20:04 +00:00
|
|
|
def main_verify_transcripts(run_app_str, transcript_files, interact, verbose):
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
results = []
|
|
|
|
for t in transcript_files:
|
2017-10-18 00:45:10 +00:00
|
|
|
passed = verify_application(run_app_str=run_app_str,
|
add osmo_verify_transcript_{vty,ctrl}.py for easier vty and ctrl testing
While adding VTY and CTRL tests to new programs like OsmoHLR, I wanted to have
a simple way to translate a VTY interaction transcript to a VTY python test. It
is fairly trivial to simply read in a transcript, extract both the commands to
send as well as the expected results, and to verify these without having to
write one line of application-specific code. From there it was just a little
step to allow the same for CTRL interaction.
With osmo_verify_transcript_vty.py and osmo_verify_transcript_ctrl.py, it is
possible to have a simple text file of a telnet VTY or CTRL interface
interaction and run it against a given application. With the --update option,
the scripts run the given command and rewrite the transcript file to whatever
the application currently produces as response. Backed by version control, it
is super easy to tweak commands, --update the test results and verify that only
the desired bits changed. A '...' wildcard can skip any number of lines in the
expected result and is usually preserved during --update.
This python3 implementation is independent from the previous obscvty
implementations.
Take the opportunity to clarify/fix a few aspects: for example, it is now
possible to verify the hints that the interactive VTY displays when the user
enters '?' in various places, and to evaluate the prompt character '>'/'#'.
Unitl now, code is duplicated/scattered across various vty_test_runner.py
scripts in different git repositories. Now, a VTY or CTRL transcript is enough
to put a complete test in place.
The simplest invocation is directly from the Makefile, feeding an application
commandline, the proper port number to contact it and e.g. a VTY prompt name.
This new code is also usable as python modules, to be able to build more
complex tests that require specialized intermediate actions, possibly
coordinating launch of applications or data manipulation.
The first repository to employ this is osmo-hlr.git. See change-ids
I42b3b70a0439a8f2e4964d7cc31e593c1f0d7537 for VTY and
Iff93abe370b8f3ecf42082d1d0eaa1fbeca5b122 for CTRL.
Change-Id: Id47331009910e651372b9c9c76e12f2e8964cc2c
2017-10-15 01:01:09 +00:00
|
|
|
interact=interact,
|
|
|
|
transcript_file=t,
|
|
|
|
verbose=verbose)
|
|
|
|
results.append((passed, t))
|
|
|
|
|
|
|
|
print('\nRESULTS:')
|
|
|
|
all_passed = True
|
|
|
|
for passed, t in results:
|
|
|
|
print('%s: %s' % ('pass' if passed else 'FAIL', t))
|
|
|
|
all_passed = all_passed and passed
|
|
|
|
print()
|
|
|
|
|
|
|
|
if not all_passed:
|
|
|
|
sys.exit(1)
|
|
|
|
|
|
|
|
# vim: tabstop=4 shiftwidth=4 expandtab nocin ai
|