コード例 #1
0
 def test_operator_define_operator_error_2(self, mock_error):
     op = Operator()
     op.no_failed = 0
     op.define_operator(self.hostname, 12, 'mock_xpath', ['ele1'], 'mock_err', 'mock_info', 'mock command',
                        True, ['mock_id'], 'test_name')
     self.assertEqual(op.no_failed, 1)           #attribute error
     mock_error.assert_called()
コード例 #2
0
 def test_operator_not_equal_1(self, mock_error):
     with self.assertRaises(Exception):
         op = Operator()
         op.not_equal('mock_path', [], 'mock_err', 'mock_info',
                      'mock_command', True, ['mock_id'], 'test_name',
                      'mock_xml1', 'mock_xml2')
         mock_error.assert_called()
コード例 #3
0
 def test_operator_no_diff_2(self, mock_error, mock_xpath, mock_print):
     mock_xpath.return_value = None , ['mock_post']
     op = Operator()
     op.no_diff('mock_path', ['mock_node'], 'mock_err', 'mock_info', 'mock_command', True, ['mock_id'], 'test_name', 'mock_xml1',
                'mock_xml2')
     mock_error.assert_called()
     mock_print.assert_called()
コード例 #4
0
 def test_operator_all_same_1(self, mock_error):
     with self.assertRaises(IndexError):
         op = Operator()
         op.all_same('mock_path', [], 'mock_err', 'mock_info',
                     'mock_command', True, ['mock_id'], 'test_name',
                     'mock_xml1', 'mock_xml2')
         mock_error.assert_called()
コード例 #5
0
ファイル: test_operator.py プロジェクト: vnitinv/jsnapy
 def test_operator_define_operator_error_2(self, mock_error):
     op = Operator()
     op.no_failed = 0
     op.define_operator(self.hostname, 12, 'mock_xpath', ['ele1'], 'mock_err', 'mock_info', 'mock command',
                        True, ['mock_id'], 'test_name')
     self.assertEqual(op.no_failed, 1)           #attribute error
     mock_error.assert_called()
コード例 #6
0
ファイル: test_operator.py プロジェクト: vnitinv/jsnapy
 def test_operator_no_diff_2(self, mock_error, mock_xpath, mock_print):
     mock_xpath.return_value = None , ['mock_post']
     op = Operator()
     op.no_diff('mock_path', ['mock_node'], 'mock_err', 'mock_info', 'mock_command', True, ['mock_id'], 'test_name', 'mock_xml1',
                'mock_xml2')
     mock_error.assert_called()
     mock_print.assert_called()
コード例 #7
0
 def test_operator_define_operator_error_3(self, mock_error, mock_all_same):
     mock_all_same.side_effect = etree.XPathEvalError('Xpath Mock Error')
     op = Operator()
     op.no_failed = 0
     op.define_operator(self.hostname, 'all-same', 'mock_xpath', ['ele1'], 'mock_err', 'mock_info', 'mock command',
                        True, ['mock_id'], 'test_name')
     self.assertEqual(op.no_failed, 1)       #xpathError
     mock_error.assert_called_with('\x1b[31mError in evaluating XPATH, \nComplete Message: Xpath Mock Error', extra='1.1.1.1')
コード例 #8
0
ファイル: test_operator.py プロジェクト: vnitinv/jsnapy
 def test_operator_define_operator_error_3(self, mock_error, mock_all_same):
     mock_all_same.side_effect = etree.XPathEvalError('Xpath Mock Error')
     op = Operator()
     op.no_failed = 0
     op.define_operator(self.hostname, 'all-same', 'mock_xpath', ['ele1'], 'mock_err', 'mock_info', 'mock command',
                        True, ['mock_id'], 'test_name')
     self.assertEqual(op.no_failed, 1)       #xpathError
     mock_error.assert_called_with('\x1b[31mError in evaluating XPATH, \nComplete Message: Xpath Mock Error', extra='1.1.1.1')
コード例 #9
0
ファイル: test_operator.py プロジェクト: vnitinv/jsnapy
    def test_operator_list_not_less_1(self, mock_xpath, mock_data, mock_print, mock_getnode, mock_printMessage):
        mock_xpath.return_value = ['mock_pre'], ['mock_post']

        mock_data.return_value = {(('mock_node_value',),):'mock_Element'}
        mock_getnode.return_value = {}, {}
        op = Operator()
        op.list_not_less('mock_path', ['no node'], 'mock_err', 'mock_info', 'mock_command', True, ['mock_id'], 'test_name', 'mock_xml1', 'mock_xml2')
        mock_printMessage.assert_called()
        mock_print.assert_called()
コード例 #10
0
    def test_operator_list_not_less_1(self, mock_xpath, mock_data, mock_print, mock_getnode, mock_printMessage):
        mock_xpath.return_value = ['mock_pre'], ['mock_post']

        mock_data.return_value = {(('mock_node_value',),):'mock_Element'}
        mock_getnode.return_value = {}, {}
        op = Operator()
        op.list_not_less('mock_path', ['no node'], 'mock_err', 'mock_info', 'mock_command', True, ['mock_id'], 'test_name', 'mock_xml1', 'mock_xml2')
        mock_printMessage.assert_called()
        mock_print.assert_called()
コード例 #11
0
 def test_operator_define_operator_error_1(self, mock_error):
     op = Operator()
     op.no_failed = 0
     op.define_operator(self.hostname, 'all-same', 'mock_xpath', ['ele1'],
                        'mock_err', 'mock_info', 'mock command', True,
                        ['mock_id'], 'test_name')
     self.assertEqual(op.no_failed, 1)
     mock_error.assert_called(
     )  #error called because the all_same requires 2 more args
コード例 #12
0
ファイル: test_notify.py プロジェクト: th3architect/jsnapy
 def test_notify_not_login(self, mock_fqdn, mock_connect, mock_ehlo, mock_starttls, mock_login, mock_log, mock_error):
     res = Operator()
     mock_fqdn.return_value = '1.1.1.1'
     mock_connect.return_value = (220, "ok")
     mock_login.side_effect = Exception('could not login')
     res.result = 'Passed'
     mfile = os.path.join(os.path.dirname(__file__), 'configs', 'mail.yml')
     mail_file = open(mfile, 'r')
     mail_file = yaml.load(mail_file)   #smtplib.SMTP#connectsocket.getfqdn, Loader=yaml.FullLoader
     passwd = mail_file['passwd']
     notf = Notification()
     notf.notify(mail_file, self.hostname, passwd, res)
     mock_log.assert_called()
     mock_error.assert_called_with('\x1b[31mERROR occurred: could not login', extra={'hostname': '10.209.12.121', 'hostame': None})
コード例 #13
0
 def test_check_4(self, mock_info, mock_error):
     comp = Comparator()
     self.db['check_from_sqlite'] = False
     oper = Operator()
     flag = comp.compare_xml(oper, self.db, 'mock_rpc_or_command', 'pre',
                             'pre')
     mock_info.assert_called()
     self.assertTrue(flag)
コード例 #14
0
 def test_notify_send_mail(self, mock_fqdn, mock_connect, mock_ehlo,
                           mock_starttls, mock_login, mock_quit, mock_log,
                           mock_error, mock_send):
     res = Operator()
     mock_send.side_effect = Exception('not able to send mail')
     mock_fqdn.return_value = '1.1.1.1'
     mock_connect.return_value = (220, "ok")
     res.result = 'Passed'
     mfile = os.path.join(os.path.dirname(__file__), 'configs', 'mail.yml')
     mail_file = open(mfile, 'r')
     mail_file = yaml.load(mail_file)  #smtplib.SMTP#connectsocket.getfqdn
     passwd = mail_file['passwd']
     notf = Notification()
     notf.notify(mail_file, self.hostname, passwd, res)
     mock_log.assert_called()
     mock_error.assert_called_with(
         '\x1b[31mERROR!!  in sending mail: not able to send mail',
         extra={
             'hostname': '10.209.12.121',
             'hostame': None
         })
     mock_quit.assert_called()
コード例 #15
0
ファイル: check.py プロジェクト: vrodriguez-git/jsnapy
    def generate_test_files(self,
                            main_file,
                            device,
                            check,
                            diff,
                            db,
                            snap_del,
                            pre=None,
                            action=None,
                            post=None):
        """
        generate names of snap files from hostname and out files given by user,
        tests are performed on values stored in these snap files, in which test is
        to be performed
        :param main_file: main config file, to extract test files user wants to run
        :param device: device name
        :param check: variable to check if --check option is given or not
        :param diff: variable to check if --diff option is given or not
        :param db: database object
        :param snap_del: if --snapcheck operator is used without any test file name
                        it will create temprory file and then will delete it at the end
        :param pre: file name of pre snapshot
        :param post: file name of post snapshot
        :param action: given by module version, either snap, snapcheck or check
        :return: object of operator.Operator containing test details
        """
        op = Operator()
        op.device = device
        tests_files = []
        self.log_detail['hostname'] = device
        # pre_user and post_user are the names of the snapshot files
        # that the user wants to keep and store the snapfiles
        # with these names
        pre_user = pre
        post_user = post
        # get the test files from config.yml
        if main_file.get('tests') is None:
            self.logger_check.error(
                colorama.Fore.RED +
                "\nERROR!! No test file found, Please mention test files !!",
                extra=self.log_detail)
        else:
            # extract test files, first search in path given in jsnapy.cfg
            for tfile in main_file.get('tests'):
                if not os.path.isfile(tfile):
                    tfile = os.path.join(
                        expanduser(get_path('DEFAULT', 'test_file_path')),
                        tfile)
                if os.path.isfile(tfile):
                    test_file = open(tfile, 'r')
                    tests_files.append(
                        yaml.load(test_file, Loader=yaml.FullLoader))
                else:
                    self.logger_check.error(
                        colorama.Fore.RED +
                        "ERROR!! File %s not found for testing" % tfile,
                        extra=self.log_detail)

            # check what all test cases need to be included, if nothing given
            # then include all test cases ####
            for tests in tests_files:
                tests_included = []
                if 'tests_include' in tests:
                    tests_included = tests.get('tests_include')
                else:
                    for t in tests:
                        tests_included.append(t)
                message = self._print_testmssg("Device: " + device, "*")
                self.logger_check.info(colorama.Fore.BLUE + message,
                                       extra=self.log_detail)
                for val in tests_included:
                    self.logger_check.info("Tests Included: %s " % (val),
                                           extra=self.log_detail)

                    # This is Where we are going to print the description mentioned by the user for the testcase
                    # Enumerate generate a tuple of index and corresponding element in the list
                    # index[0] is index and index[1] is the dictionary in which it will search.

                    description_index = [
                        index[0] for index in enumerate(tests[val])
                        if 'description' in index[1]
                    ]
                    if len(description_index) > 0:
                        description_index = description_index[0]
                        description = tests[val][description_index][
                            'description']
                        if description is not None:
                            self.logger_check.info("Description: %s " %
                                                   (description),
                                                   extra=self.log_detail)
                    try:
                        if any('command' in d for d in tests[val]):
                            index = next((i for i, x in enumerate(tests[val])
                                          if 'command' in x), 0)
                            command = tests[val][index].get('command').split(
                                '|')[0].strip()
                            reply_format = tests[val][0].get('format', 'xml')
                            message = self._print_testmssg(
                                "Command: " + command, "*")

                            self.logger_check.info(colorama.Fore.BLUE +
                                                   message,
                                                   extra=self.log_detail)

                            name = '_'.join(command.split())
                            teston = command

                            # this is necessary for the pre and post to be the same that user specified
                            # In a case when there are multiple rpc's with kwargs and a rpc with no kwargs
                            pre = pre_user
                            post = post_user
                        else:
                            index = next((i for i, x in enumerate(tests[val])
                                          if 'rpc' in x), 0)
                            index_kwargs = next(
                                (i for i, x in enumerate(tests[val])
                                 if 'kwargs' in x or 'args' in x), 1)
                            rpc = tests[val][index]['rpc']
                            reply_format = tests[val][index].get(
                                'format', 'xml')
                            self.logger_check.info(colorama.Fore.BLUE +
                                                   (25) * "*" + "RPC is " +
                                                   rpc + (25) * '*',
                                                   extra=self.log_detail)
                            name = rpc
                            teston = rpc
                            # this is necessary for the pre and post to be the same that user specified
                            # In a case when there are multiple rpc's with kwargs and a rpc with no kwargs
                            pre = pre_user
                            post = post_user

                            # here the user specified name is being used and the hash value generated for
                            # kwargs part is appended to the name

                            if 'kwargs' in tests[val][index_kwargs] and tests[
                                    val][index_kwargs].get('kwargs') is None:
                                del tests[val][index_kwargs]['kwargs']

                            if 'args' in tests[val][index_kwargs] and tests[
                                    val][index_kwargs].get('args') is None:
                                del tests[val][index_kwargs]['args']

                            if 'kwargs' in tests[val][
                                    index_kwargs] or 'args' in tests[val][
                                        index_kwargs]:
                                if tests[val][index_kwargs].get('kwargs'):
                                    data = tests[val][index_kwargs].get(
                                        'kwargs')
                                elif tests[val][index_kwargs].get('args'):
                                    data = tests[val][index_kwargs].get('args')
                                hash_kwargs = hashlib.md5(
                                    json.dumps(data, sort_keys=True).encode(
                                        'utf-8')).digest()
                                hash_kwargs = base64.urlsafe_b64encode(
                                    hash_kwargs).strip()
                                if action == 'check' and pre_user is not None and post_user is not None:
                                    pre = pre_user + '_' + hash_kwargs.decode(
                                        'utf-8')
                                    post = post_user + '_' + hash_kwargs.decode(
                                        'utf-8')
                                elif action == 'snapcheck' and pre_user is not None and post_user is None:
                                    pre = pre_user + '_' + hash_kwargs.decode(
                                        'utf-8')
                                elif diff is True and pre_user is not None and post_user is not None:
                                    pre = pre_user + '_' + hash_kwargs.decode(
                                        'utf-8')
                                    post = post_user + '_' + hash_kwargs.decode(
                                        'utf-8')
                    except KeyError:
                        self.logger_check.error(
                            colorama.Fore.RED +
                            "ERROR occurred, test keys 'command' or 'rpc' not defined properly",
                            extra=self.log_detail)
                    except Exception as ex:
                        self.logger_check.error(colorama.Fore.RED +
                                                "ERROR Occurred: %s" % str(ex),
                                                extra=self.log_detail)
                    else:
                        # extract snap files, if check from sqlite is true t
                        if db.get('check_from_sqlite') is True and (
                                check is True or diff is True
                                or action in ["check", "diff"]):
                            a = SqliteExtractXml(db.get('db_name'))
                            # while checking from database, preference is given
                            # to id and then snap name
                            if (db['first_snap_id']
                                    is not None) and (db['second_snap_id']
                                                      is not None):
                                snapfile1, data_format1 = a.get_xml_using_snap_id(
                                    str(device), name, db['first_snap_id'])
                                snapfile2, data_format2 = a.get_xml_using_snap_id(
                                    str(device), name, db['second_snap_id'])
                            else:
                                snapfile1, data_format1 = a.get_xml_using_snapname(
                                    str(device), name, pre)
                                snapfile2, data_format2 = a.get_xml_using_snapname(
                                    str(device), name, post)
                            if reply_format != data_format1 or reply_format != data_format2:
                                self.logger_check.error(
                                    colorama.Fore.RED +
                                    "ERROR!! Data stored in database is not in %s format."
                                    % reply_format,
                                    extra=self.log_detail)
                                pass
                                # sys.exit(1)
                        ###### taking snapshot for --snapcheck operation ####
                        elif db.get('check_from_sqlite') is True:
                            a = SqliteExtractXml(db.get('db_name'))
                            snapfile1, data_format1 = a.get_xml_using_snapname(
                                str(device), name, pre)
                            if reply_format != data_format1:
                                self.logger_check.error(
                                    colorama.Fore.RED +
                                    "ERROR!! Data stored in database is not in %s format."
                                    % reply_format,
                                    extra=self.log_detail)
                                pass
                                # sys.exit(1)
                        else:
                            snapfile1 = self.generate_snap_file(
                                device, pre, name, reply_format)

                        # if check is true then call function to compare two
                        # snapshots ####
                        if (check is True or action
                                == "check") and reply_format == 'xml':
                            if db.get('check_from_sqlite') is False:
                                snapfile2 = self.generate_snap_file(
                                    device, post, name, reply_format)
                            self.compare_reply(op, tests[val], val, teston,
                                               check, db, snapfile1, snapfile2,
                                               action)

                        # if --diff is true then call compare_diff to compare
                        # two snapshots word by word ####
                        elif (diff is True):
                            if db.get('check_from_sqlite') is False:
                                snapfile2 = self.generate_snap_file(
                                    device, post, name, reply_format)
                            self.compare_diff(snapfile1, snapfile2,
                                              db.get('check_from_sqlite'))

                        # else call --snapcheck test operation, it works only
                        # for xml reply format   ####
                        elif (reply_format == 'xml'):
                            self.compare_reply(op, tests[val], val, teston,
                                               check, db, snapfile1, action)
                            ######## bug here ############
                            # multiple testcases for single command and same device, its deleting that file
                            ####################
                            """
                            if snap_del is True:
                                snapfile1 = snapfile1 if os.path.isfile(snapfile1) else self.generate_snap_file(device, pre, name, reply_format)
                                os.remove(snapfile1)
                                """
                        else:
                            # give error message if snapshot in text format is
                            # used with operations other than --diff  ####
                            self.logger_check.error(
                                colorama.Fore.RED +
                                "ERROR!! for checking snapshots in text format use '--diff' option ",
                                extra=self.log_detail)

            # print final result, if operation is --diff then message gets
            # printed compare_diff function only ####
            if (diff is not True):
                op.final_result(self.log_detail)

        return op
コード例 #16
0
    def get_test(self, config_data, hostname, snap_file, post_snap, action):
        """
        Analyse testfile and return object of operator.Operator containing test details
        called by connect() function and other functions of Jsnapy module functions
        :param config_data: data of main config file
        :param hostname: hostname
        :param snap_file: pre snapshot file name
        :param post_snap: post snapshot file name
        :param action: action to be taken (check, snapcheck, snap)
        :return: object of testop.Operator containing test details
        """
        res = Operator()

        res = self.compare_tests(hostname, config_data, snap_file, post_snap,
                                 action)

        result_status = res.result

        mail_condition = 'all'
        if result_status == 'Passed':
            mail_condition = 'pass'
        elif result_status == 'Failed':
            mail_condition = 'fail'

        mail_pref = config_data.get("mail")

        #we don't want to send mail when diff operation is run
        if mail_pref is not None and self.args.diff is False:
            mail_file_path = None
            if type(mail_pref) is str:
                mail_file_path = mail_pref
            elif type(mail_pref) is dict:
                if mail_condition in mail_pref:
                    mail_file_path = mail_pref.get(mail_condition)
            else:
                self.logger.error(
                    colorama.Fore.RED +
                    "ERROR!! Type of mail preferences should be either dictionary or string",
                    extra=self.log_detail)

            if mail_file_path is not None and mail_file_path != '':
                mfile = os.path.join(expanduser(get_path('DEFAULT', 'test_file_path')), mail_file_path)\
                        if os.path.isfile(mail_file_path) is False else mail_file_path
                if os.path.isfile(mfile):
                    mail_file = open(mfile, 'r')
                    mail_file = yaml.load(mail_file)
                    if "passwd" not in mail_file:
                        passwd = getpass.getpass(
                            "Please enter ur email password ")
                    else:
                        passwd = mail_file['passwd']

                    send_mail = Notification()
                    send_mail.notify(mail_file, hostname, passwd, res)
                else:
                    self.logger.error(
                        colorama.Fore.RED +
                        "ERROR!! Path of file containing mail content is not correct",
                        extra=self.log_detail)
        # else:
        #     res = self.compare_tests(
        #         hostname,
        #         config_data,
        #         snap_file,
        #         post_snap,
        #         action)

        self.q.put(res)
        return res
コード例 #17
0
ファイル: test_operator.py プロジェクト: vnitinv/jsnapy
 def test_operator_in_range_1(self, mock_error):
     with self.assertRaises(Exception):
         op = Operator()
         op.in_range('mock_path', [], 'mock_err', 'mock_info', 'mock_command', True, ['mock_id'], 'test_name', 'mock_xml1',
                     'mock_xml2')
         mock_error.assert_called()
コード例 #18
0
ファイル: test_operator.py プロジェクト: vnitinv/jsnapy
 def test_operator_all_same_1(self, mock_error):
     with self.assertRaises(IndexError):
         op = Operator()
         op.all_same('mock_path', [], 'mock_err', 'mock_info', 'mock_command', True, ['mock_id'],'test_name', 'mock_xml1',
                       'mock_xml2')
         mock_error.assert_called()
コード例 #19
0
ファイル: test_operator.py プロジェクト: vnitinv/jsnapy
 def test_operator_define_operator_error_1(self,mock_error):
     op = Operator()
     op.no_failed = 0
     op.define_operator(self.hostname,'all-same','mock_xpath',['ele1'],'mock_err','mock_info','mock command',True,['mock_id'], 'test_name')
     self.assertEqual(op.no_failed,1)
     mock_error.assert_called()                  #error called because the all_same requires 2 more args
コード例 #20
0
ファイル: check.py プロジェクト: hopisaurus/jsnapy
    def generate_test_files(self,
                            main_file,
                            device,
                            check,
                            diff,
                            db,
                            snap_del,
                            pre=None,
                            action=None,
                            post=None):
        """
        generate names of snap files from hostname and out files given by user,
        tests are performed on values stored in these snap files, in which test is
        to be performed
        :param main_file: main config file, to extract test files user wants to run
        :param device: device name
        :param check: variable to check if --check option is given or not
        :param diff: variable to check if --diff option is given or not
        :param db: database object
        :param snap_del: if --snapcheck operator is used without any test file name
                        it will create temprory file and then will delete it at the end
        :param pre: file name of pre snapshot
        :param post: file name of post snapshot
        :param action: given by module version, either snap, snapcheck or check
        :return: object of operator.Operator containing test details
        """
        op = Operator()
        op.device = device
        tests_files = []
        self.log_detail['hostname'] = device
        # get the test files from config.yml
        if main_file.get('tests') is None:
            self.logger_check.error(
                colorama.Fore.RED +
                "\nERROR!! No test file found, Please mention test files !!",
                extra=self.log_detail)
        else:
            # extract test files, first search in path given in jsnapy.cfg
            for tfile in main_file.get('tests'):
                if not os.path.isfile(tfile):
                    tfile = os.path.join(get_path('DEFAULT', 'test_file_path'),
                                         tfile)
                if os.path.isfile(tfile):
                    test_file = open(tfile, 'r')
                    tests_files.append(yaml.load(test_file))
                else:
                    self.logger_check.error(
                        colorama.Fore.RED +
                        "ERROR!! File %s not found for testing" % tfile,
                        extra=self.log_detail)

            # check what all test cases need to be included, if nothing given
            # then include all test cases ####
            for tests in tests_files:
                tests_included = []
                if 'tests_include' in tests:
                    tests_included = tests.get('tests_include')
                else:
                    for t in tests:
                        tests_included.append(t)
                message = self._print_testmssg("Device: " + device, "*")
                self.logger_check.info(colorama.Fore.BLUE + message,
                                       extra=self.log_detail)
                for val in tests_included:
                    self.logger_check.info("Tests Included: %s " % (val),
                                           extra=self.log_detail)
                    try:
                        if 'command' in list(tests[val][0].keys()):
                            command = tests[val][0].get('command').split(
                                '|')[0].strip()
                            reply_format = tests[val][0].get('format', 'xml')
                            message = self._print_testmssg(
                                "Command: " + command, "*")

                            self.logger_check.info(colorama.Fore.BLUE +
                                                   message,
                                                   extra=self.log_detail)

                            name = '_'.join(command.split())
                            teston = command
                        else:
                            rpc = tests[val][0]['rpc']
                            reply_format = tests[val][0].get('format', 'xml')
                            self.logger_check.info(colorama.Fore.BLUE +
                                                   (25) * "*" + "RPC is " +
                                                   rpc + (25) * '*',
                                                   extra=self.log_detail)
                            name = rpc
                            teston = rpc
                    except KeyError:
                        self.logger_check.error(
                            colorama.Fore.RED +
                            "ERROR occurred, test keys 'command' or 'rpc' not defined properly",
                            extra=self.log_detail)
                    except Exception as ex:
                        self.logger_check.error(colorama.Fore.RED +
                                                "ERROR Occurred: %s" % str(ex),
                                                extra=self.log_detail)
                    else:
                        # extract snap files, if check from sqlite is true t
                        if db.get('check_from_sqlite') is True and (
                                check is True or diff is True
                                or action in ["check", "diff"]):
                            a = SqliteExtractXml(db.get('db_name'))
                            # while checking from database, preference is given
                            # to id and then snap name
                            if (db['first_snap_id']
                                    is not None) and (db['second_snap_id']
                                                      is not None):
                                snapfile1, data_format1 = a.get_xml_using_snap_id(
                                    str(device), name, db['first_snap_id'])
                                snapfile2, data_format2 = a.get_xml_using_snap_id(
                                    str(device), name, db['second_snap_id'])
                            else:
                                snapfile1, data_format1 = a.get_xml_using_snapname(
                                    str(device), name, pre)
                                snapfile2, data_format2 = a.get_xml_using_snapname(
                                    str(device), name, post)
                            if reply_format != data_format1 or reply_format != data_format2:
                                self.logger_check.error(
                                    colorama.Fore.RED +
                                    "ERROR!! Data stored in database is not in %s format."
                                    % reply_format,
                                    extra=self.log_detail)
                                pass
                                # sys.exit(1)
                        ###### taking snapshot for --snapcheck operation ####
                        elif db.get('check_from_sqlite') is True:
                            a = SqliteExtractXml(db.get('db_name'))
                            snapfile1, data_format1 = a.get_xml_using_snapname(
                                str(device), name, pre)
                            if reply_format != data_format1:
                                self.logger_check.error(
                                    colorama.Fore.RED +
                                    "ERROR!! Data stored in database is not in %s format."
                                    % reply_format,
                                    extra=self.log_detail)
                                pass
                                # sys.exit(1)
                        else:
                            snapfile1 = self.generate_snap_file(
                                device, pre, name, reply_format)

                        # if check is true then call function to compare two
                        # snapshots ####
                        if (check is True or
                                action is "check") and reply_format == 'xml':
                            if db.get('check_from_sqlite') is False:
                                snapfile2 = self.generate_snap_file(
                                    device, post, name, reply_format)
                            self.compare_reply(op, tests[val], val, teston,
                                               check, db, snapfile1, snapfile2,
                                               action)

                        # if --diff is true then call compare_diff to compare
                        # two snapshots word by word ####
                        elif (diff is True):
                            if db.get('check_from_sqlite') is False:
                                snapfile2 = self.generate_snap_file(
                                    device, post, name, reply_format)
                            self.compare_diff(snapfile1, snapfile2,
                                              db.get('check_from_sqlite'))

                        # else call --snapcheck test operation, it works only
                        # for xml reply format   ####
                        elif (reply_format == 'xml'):
                            self.compare_reply(op, tests[val], val, teston,
                                               check, db, snapfile1, action)
                            ######## bug here ############
                            # multiple testcases for single command and same device, its deleting that file
                            ####################
                            """
                            if snap_del is True:
                                snapfile1 = snapfile1 if os.path.isfile(snapfile1) else self.generate_snap_file(device, pre, name, reply_format)
                                os.remove(snapfile1)
                                """
                        else:
                            # give error message if snapshot in text format is
                            # used with operations other than --diff  ####
                            self.logger_check.error(
                                colorama.Fore.RED +
                                "ERROR!! for checking snapshots in text format use '--diff' option ",
                                extra=self.log_detail)

            # print final result, if operation is --diff then message gets
            # printed compare_diff function only ####
            if (diff is not True):
                op.final_result(self.log_detail)

        return op