def getLinesBetweenMatchingLines(srcfile, dstfile, start, end, no_of_search=1):
lines = open(srcfile, 'r').readlines()
#print_info ("lines:%s"% lines)
i = 0
iteration = 0
resultantList = []
if no_of_search == 0:
print_error("no of searches should be a non-zero number")
return False
while (i < len(lines)):
#print lines[i]
printable_only = filter(lambda x: x in string.printable, lines[i])
if printable_only == start:
resultantList.append(lines[i])
i += 1
while (i < len(lines)):
printable_only = filter(lambda x: x in string.printable,
lines[i])
if printable_only == end:
resultantList.append(lines[i])
iteration += 1
break
else:
resultantList.append(lines[i])
i += 1
if no_of_search == 'EOF' or no_of_search == 'eof' or iteration < no_of_search:
i += 1
elif no_of_search == iteration:
break
if len(resultantList) == 0: print "no match found in the file"
open(dstfile, 'w+').writelines(resultantList)
def compare_xml_using_xpath(response, list_of_xpath, list_of_expected_api_responses):
"""
Will get each xpath in list of xpath and get the value of
that xpath in xml response
Compares the value with the expected_api_response
If all values matches returns True else False
"""
status = True
if len(list_of_xpath) != len(list_of_expected_api_responses):
print_error("The number of xpath given is different"
"from the number of expected response"
"Please check the value"
"\nlist_of_xpath: {}"
"\nlist_of_expected_response: {}".format(
list_of_xpath, list_of_expected_api_responses))
status = False
if status:
for index, xpath_pattern in enumerate(list_of_xpath):
xpath = xpath_pattern.strip("xpath=")
value = getValuebyTagFromStringWithXpath(response, xpath, None)
if value != list_of_expected_api_responses[index]:
status = False
print_error("For the given {0} the expected response value is"
" {1} but the actual response"
" value is {2}".format(xpath_pattern,
list_of_expected_api_responses[index], value))
return status
def move_to_position(fd, offset, **kwargs):
"""
Sets the file's current position
:Arguments:
fd - file descriptor got from open_file
offset - number of bytes to be moved
:Optional:
whence -
0 - move offset positions from beginning of file
1 - move offset positions from current position of file
2 - move offset positions from end of file
:Return:
current position after movement
"""
curpos = -1
try:
if "whence" in kwargs:
curpos = fd.seek(offset, kwargs["whence"])
else:
curpos = fd.seek(offset)
except ValueError:
print_error("file is already closed...")
except Exception as e:
print_error("found exception {} while moving to position on {}".format(
str(e), fd))
return curpos
def getAbsPath(relative_path, start_directory="."):
"""This function is used to manipulate the path according to the
relative path that is specified
:Arguments:
1. @param relative_path: The relative path of directory or file
2. @param start_directory: The actual dir path where the file must be
:Returns:
1. @return: Returns the abspath with the relative path specified
"""
value = False
if relative_path and start_directory:
relative_path = relative_path.strip()
try:
#print relative_path
os.chdir(start_directory)
path = os.path.abspath(relative_path)
value = path
except Exception, err:
print_error("{0} file does not exist in provided path".format(
relative_path))
print(err)
def verifyNodesValueMatch(datafile,
pnode,
cnode,
cvalue,
rnode,
rvalue,
bnode,
bvalue,
dnode=None,
dvalue=None):
"""
Searches XML file for the parent node. Finds the 1st child node and checks its value
if value is a match, then search for second child and check if its value matches
datafile = xml file searched
pnode = parent node
cnode = child node
cvalue = child node value
rnode = reference node
rvalue = refernce node value
"""
try:
tree = ElementTree.parse(datafile)
root = tree.getroot()
except Exception, e:
print_error("unexpected error %s" % str(e))
return False
def get_tree_from_file(filepath):
""" Get the tree from the xml file"""
if file_Utils.fileExists(filepath):
tree = ElementTree.parse(filepath)
else:
print_error("xml file does not exist in provided path {0}".format(filepath))
tree = False
return tree
def close(self):
'''Calls the telnetlib close and terminates the telnet session'''
try:
self.tnet.close()
print_debug("TELNET CONNECTION CLOSING...")
except Exception:
print_error("Error occured while closing telnet session")
return False
def getRoot(filename):
""" Get the Root of the xml file"""
try:
tree = ElementTree.parse(filename)
root = tree.getroot()
except ElementTree.ParseError, msg:
print_error("The xml file: {0} is {1}".format(filename, msg))
print_info("DONE 1")
sys.exit(0)
def log_result(oper, result):
"""the methods in file_actions class use this to log the result of
its operation
"""
resmsg = "completed successfully" if result else "failed"
msg = "file {} operation {}".format(oper, resmsg)
if result:
print_info(msg)
else:
print_error(msg)
def delFolder(path):
""" check if folder exists and delete it with its content"""
status = False
if dirExists(path):
try:
shutil.rmtree(path)
status = True
except OSError:
print_error("Cannot remove folder {}".format(path))
return status
def get_absolute_path_from_start_directory(relative_path, start_directory, extension=".json"):
"""
DEPRECATED IN 2.9
Keyword developer must be aware that relative path can be relative to
1. testcase file
2. data file (if path is given in tag= value)
start_directory must be an absolute path
"""
print_error("This function is deprecated in 2.9, use check_extension_get_absolute_path or getAbspath instead")
return check_extension_get_absolute_path(relative_path, start_directory, extension)
def get_absolute_path_of_directory(relative_path_of_dir, start_directory):
"""
DEPRECATED IN 2.9
When provided with a start directory and a relative path of a directory, this function
returns the absolute path. Else returns the relative path
Keyword developer must be aware that relative path can be relative to
1. testcase file
2. data file (if path is given in tag= value)
start_directory must be an absolute path
"""
print_error("This function is deprecated in 2.9, use check_extension_get_absolute_path or getAbspath instead")
return getAbsPath(relative_path_of_dir, start_directory)
def get_file_mode(fd):
"""
Returns access mode with which file was opened.
:Arguments:
fd - file descriptor got from open_file
:Return:
mode
"""
mode = ""
try:
mode = fd.mode
except ValueError:
print_error("file is already closed...")
except Exception as e:
print_error("found exception {} while getting file mode of {}".format(
str(e), fd))
return mode
def createDir(path, dirname):
"""Creates a new directory with name = dirname under the provided path, ignores if directory with same name already exists
Arguments:
1. path = (string) full path of an existing directory where a new directory need to be created
2. dirname = (string) name of the new directory to be created
"""
if dirExists(path):
dirpath = path + os.sep + dirname
if dirExists(dirpath):
return dirpath
try:
os.makedirs(dirpath)
except Exception,e:
print_error(str(e))
#print_info("A new '%s' directory created : '%s'" % (dirname, dirpath))
return dirpath
def isatty(fd):
"""
Returns True if the file is connected to a tty(-like) device, else False.
:Arguments:
fd - file descriptor got from open_file
:Return:
True/False - description above
"""
status = False
try:
status = fd.isatty()
except ValueError:
print_error("file is already closed...")
except Exception as e:
print_error("found exception {} while checking atty of {}".format(
str(e), fd))
return status
def is_softspace_required(fd):
"""
Returns false if space explicitly required with print, true otherwise.
:Arguments:
fd - file descriptor got from open_file
:Return:
True/False - description above
"""
status = False
try:
status = fd.softspace
except ValueError:
print_error("file is already closed...")
except Exception as e:
print_error("found exception {} while getting file mode of {}".format(
str(e), fd))
return status
def get_current_position(fd):
"""
Returns the file's current position
:Arguments:
fd - file descriptor got from open_file
:Return:
current position of the file, -1 if error occurred
"""
curpos = -1
try:
curpos = fd.tell()
except ValueError:
print_error("file is already closed...")
except Exception as e:
print_error("found exception {} while getting current position on {}".
format(str(e), fd))
return curpos
def is_file_closed(fd):
"""
Returns true if file is closed, false otherwise.
:Arguments:
fd - file descriptor got from open_file
:Return:
True/False - description above
"""
status = False
try:
status = fd.closed
except ValueError:
print_error("file is already closed...")
except Exception as e:
print_error("found exception {} while getting file mode of {}".format(
str(e), fd))
return status
def get_file_name(fd):
"""
Returns name of the file.
:Arguments:
fd - file descriptor got from open_file
:Return:
name of the file, empty string if there was an exception
"""
fname = ""
try:
fname = fd.name
except ValueError:
print_error("file is already closed...")
except Exception as e:
print_error("found exception {} while getting file name of {}".format(
str(e), fd))
return fname
def flush(fd):
"""
Flush the internal buffer, like stdio's fflush. This may be a no-op on some
file-like objects.
:Arguments:
fd - file descriptor got from open_file
:Return:
True/False - based on the success/failure of the operation
"""
status = False
try:
status = fd.flush()
except ValueError:
print_error("file is already closed...")
except Exception as e:
print_error("found exception {} while flushing {}".format(str(e), fd))
return status
def remove(nfile):
"""
removes the file from the filesystem
:Arguments:
nfile - filepath to be removed
:Return:
True/False - based on the success/failure of the operation
"""
status = False
try:
os.remove(nfile)
print_info(nfile + " removed from filesystem")
status = True
except Exception as e:
print_error("removing file {} raised exception {}".format(
nfile, str(e)))
return status
def fileno(fd):
"""
Returns the integer file descriptor that is used by the underlying
implementation to request I/O operations from the operating system.
:Arguments:
fd - file descriptor got from open_file
:Return:
integer file descriptor
"""
ifd = -1
try:
ifd = fd.fileno()
except ValueError:
print_error("file is already closed...")
except Exception as e:
print_error("found exception {} while getting integer file descriptor "
"of {}".format(str(e), fd))
return ifd
def get_next_line(fd):
"""
Returns the next line from the file each time it is being called.
:Arguments:
fd - file descriptor got from open_file
:Return:
next line
"""
try:
line = fd.next()
except ValueError:
print_error("file is already closed...")
line = False
except Exception as e:
print_error("found exception {} while getting line of {}".format(
str(e), fd))
line = False
return line
def copyfileobj(fsrc, fdst):
"""
Copy the contents of the file-like object fsrc to the file-like object
fdst.
:Arguments:
fsrc - file descriptor of the file to be copied
fdst - file descriptor of the file on which to be copied
:Return:
True/False - based on the success/failure of the operation
"""
status = False
try:
shutil.copyfileobj(fsrc, fdst)
status = True
except Exception as e:
print_error("copying file {} to file {} raised exception {}".format(
fsrc, fdst, str(e)))
return status
def write(fd, string):
"""
Writes a string to the file.
:Arguments:
fd - file descriptor got from open_file
str - string to write
:Return:
True/False - based on the success/failure of the operation
"""
status = False
try:
fd.write(string)
print_info("written to file " + fd.name)
status = True
except ValueError:
print_error("file is already closed...")
except Exception as e:
print_error("found exception {} while writing {}".format(str(e), fd))
return status
def copyfile(src, dst):
"""
Copy the contents (no metadata) of the file named src to a file named dst.
dst must be the complete target file name.
:Arguments:
src - file to be copied
dst - file on which to be copied
:Return:
True/False - based on the success/failure of the operation
"""
status = False
try:
shutil.copyfile(src, dst)
print_info("src {} copied to dst {} successfully".format(src, dst))
status = True
except Exception as e:
print_error("copying file {} to file {} raised exception {}".format(
src, dst, str(e)))
return status
def copymode(src, dst):
"""
Copy the permission bits from src to dst. The file contents, owner, and
group are unaffected. src and dst are path names given as strings.
:Arguments:
src - mode of the file to be copied
dst - file on which mode has to be copied
:Return:
True/False - based on the success/failure of the operation
"""
status = False
try:
shutil.copymode(src, dst)
print_info("mode of src {} copied to dst {} successfully".
format(src, dst))
status = True
except Exception as e:
print_error("copying file mode from {} to file {} raised exception {}".
format(src, dst, str(e)))
return status
def writelines(fd, seq):
"""
Writes a sequence of strings to the file. The sequence can be any
iterable object producing strings, typically a list of strings.
:Arguments:
fd - file descriptor got from open_file
sequence - sequence of lines to be written
:Return:
True/False - based on the success/failure of the operation
"""
status = False
try:
fd.writelines(seq)
print_info("written seq to the file " + fd.name)
status = True
except ValueError:
print_error("file is already closed...")
except Exception as e:
print_error("found exception {} while writing {}".format(str(e), fd))
return status
def readline(fd, **kwargs):
"""
Reads one entire line from the file. A trailing newline character is kept
in the string.
:Arguments:
fd - file descriptor got from open_file
:Return:
the line read
"""
try:
line = fd.readline(**kwargs)
print_info("read a line from file " + fd.name)
except ValueError:
print_error("file is already closed...")
line = False
except Exception as e:
print_error("found exception {} while reading line in {}".format(
str(e), fd))
line = False
return line
def close(fd):
"""
Close the file. A closed file cannot be read or written any more.
:Arguments:
fd - file descriptor got from open_file
:Return:
True/False - based on the success/failure of the operation
"""
try:
name = fd.name
status = fd.close()
print_info("file {} closed successfully".format(name))
except ValueError:
print_warning("file is already closed...")
status = True
except Exception as e:
print_error("found exception {} while closing {}".format(str(e), fd))
status = False
return status
