Huawei_Technology
/
mindspore-mindinsight
Not watched
1
0
Fork 0
Code
Releases 11 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 488cfaefa2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '488cfaefa2'
${ noResults }
mindspore-mindinsight/tests/ut/lineagemgr/querier/test_querier.py

620 lines
23 kB
Raw Blame History 

  1. # Copyright 2020 Huawei Technologies Co., Ltd

  2. #

  3. # Licensed under the Apache License, Version 2.0 (the "License");

  4. # you may not use this file except in compliance with the License.

  5. # You may obtain a copy of the License at

  6. #

  7. # http://www.apache.org/licenses/LICENSE-2.0

  8. #

  9. # Unless required by applicable law or agreed to in writing, software

  10. # distributed under the License is distributed on an "AS IS" BASIS,

  11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  12. # See the License for the specific language governing permissions and

  13. # limitations under the License.

  14. # ============================================================================

  15. """Test the querier module."""

  16. import time

  17. 

  18. from unittest import TestCase, mock

  19. from unittest.mock import MagicMock

  20. 

  21. from google.protobuf.json_format import ParseDict

  22. 

  23. import mindinsight.datavisual.proto_files.mindinsight_lineage_pb2 as summary_pb2

  24. from mindinsight.lineagemgr.common.exceptions.exceptions import LineageParamTypeError, LineageQuerierParamException

  25. from mindinsight.lineagemgr.lineage_parser import LineageOrganizer

  26. from mindinsight.lineagemgr.querier.querier import Querier

  27. from mindinsight.lineagemgr.summary.lineage_summary_analyzer import LineageInfo

  28. 

  29. from . import event_data

  30. from ....utils.tools import assert_equal_lineages

  31. 

  32. 

  33. def create_lineage_info(train_event_dict, eval_event_dict, dataset_event_dict):

  34.     """

  35.     Create parsed lineage info tuple.

  36. 

  37.     Args:

  38.         train_event_dict (Union[dict, None]): The dict of train event.

  39.         eval_event_dict (Union[dict, None]): The dict of evaluation event.

  40.         dataset_event_dict (Union[dict, None]): The dict of dataset graph event.

  41. 

  42.     Returns:

  43.         namedtuple, parsed lineage info.

  44.     """

  45.     if train_event_dict is not None:

  46.         train_event = summary_pb2.LineageEvent()

  47.         ParseDict(train_event_dict, train_event)

  48.     else:

  49.         train_event = None

  50. 

  51.     if eval_event_dict is not None:

  52.         eval_event = summary_pb2.LineageEvent()

  53.         ParseDict(eval_event_dict, eval_event)

  54.     else:

  55.         eval_event = None

  56. 

  57.     if dataset_event_dict is not None:

  58.         dataset_event = summary_pb2.LineageEvent()

  59.         ParseDict(dataset_event_dict, dataset_event)

  60.     else:

  61.         dataset_event = None

  62. 

  63.     lineage_info = LineageInfo(

  64.         train_lineage=train_event,

  65.         eval_lineage=eval_event,

  66.         dataset_graph=dataset_event,

  67.     )

  68.     return lineage_info

  69. 

  70. 

  71. def create_filtration_result(summary_dir, train_event_dict,

  72.                              eval_event_dict, metric_dict, dataset_dict):

  73.     """

  74.     Create filteration result.

  75. 

  76.     Args:

  77.         summary_dir (str): The summary dir.

  78.         train_event_dict (dict): The dict of train event.

  79.         eval_event_dict (dict): The dict of evaluation event.

  80.         metric_dict (dict): The dict of metric.

  81.         dataset_dict (dict): The dict of dataset graph.

  82. 

  83.     Returns:

  84.         dict, the filteration result.

  85.     """

  86.     filtration_result = {

  87.         "summary_dir": summary_dir,

  88.         "model_lineage": {

  89.             "loss_function": train_event_dict['train_lineage']['hyper_parameters']['loss_function'],

  90.             "train_dataset_path": train_event_dict['train_lineage']['train_dataset']['train_dataset_path'],

  91.             "train_dataset_count": train_event_dict['train_lineage']['train_dataset']['train_dataset_size'],

  92.             "test_dataset_path": eval_event_dict['evaluation_lineage']['valid_dataset']['valid_dataset_path'],

  93.             "test_dataset_count": eval_event_dict['evaluation_lineage']['valid_dataset']['valid_dataset_size'],

  94.             "network": train_event_dict['train_lineage']['algorithm']['network'],

  95.             "optimizer": train_event_dict['train_lineage']['hyper_parameters']['optimizer'],

  96.             "learning_rate": train_event_dict['train_lineage']['hyper_parameters']['learning_rate'],

  97.             "epoch": train_event_dict['train_lineage']['hyper_parameters']['epoch'],

  98.             "batch_size": train_event_dict['train_lineage']['hyper_parameters']['batch_size'],

  99.             "device_num": train_event_dict['train_lineage']['hyper_parameters']['device_num'],

  100.             "loss": train_event_dict['train_lineage']['algorithm']['loss'],

  101.             "model_size": train_event_dict['train_lineage']['model']['size'],

  102.             "metric": metric_dict,

  103.             "dataset_mark": '2',

  104.             "user_defined": {}

  105.         },

  106.         "dataset_graph": dataset_dict,

  107.     }

  108.     return filtration_result

  109. 

  110. 

  111. def get_lineage_infos():

  112.     """

  113.     Get tuples of lineage info, simulate the function of summary analyzer.

  114. 

  115.     Returns:

  116.         list[namedtuple], tuples of lineage info.

  117.     """

  118.     train_events = [

  119.         event_data.EVENT_TRAIN_DICT_0,

  120.         event_data.EVENT_TRAIN_DICT_1,

  121.         event_data.EVENT_TRAIN_DICT_2,

  122.         event_data.EVENT_TRAIN_DICT_3,

  123.         event_data.EVENT_TRAIN_DICT_4,

  124.         event_data.EVENT_TRAIN_DICT_5,

  125.         None

  126.     ]

  127.     eval_events = [

  128.         event_data.EVENT_EVAL_DICT_0,

  129.         event_data.EVENT_EVAL_DICT_1,

  130.         event_data.EVENT_EVAL_DICT_2,

  131.         event_data.EVENT_EVAL_DICT_3,

  132.         event_data.EVENT_EVAL_DICT_4,

  133.         None,

  134.         event_data.EVENT_EVAL_DICT_5

  135.     ]

  136.     dataset_events = [

  137.         event_data.EVENT_DATASET_DICT_0

  138.     ]*7

  139. 

  140.     lineage_infos = list(

  141.         map(

  142.             lambda event: create_lineage_info(event[0], event[1], event[2]),

  143.             zip(train_events, eval_events, dataset_events)

  144.         )

  145.     )

  146. 

  147.     return lineage_infos

  148. 

  149. 

  150. LINEAGE_INFO_0 = {

  151.     'summary_dir': '/path/to/summary0',

  152.     **event_data.EVENT_TRAIN_DICT_0['train_lineage'],

  153.     'metric': event_data.METRIC_0,

  154.     'valid_dataset': event_data.EVENT_EVAL_DICT_0['evaluation_lineage']['valid_dataset'],

  155.     'dataset_graph': event_data.DATASET_DICT_0

  156. }

  157. LINEAGE_INFO_1 = {

  158.     'summary_dir': '/path/to/summary1',

  159.     **event_data.EVENT_TRAIN_DICT_1['train_lineage'],

  160.     'metric': event_data.METRIC_1,

  161.     'valid_dataset': event_data.EVENT_EVAL_DICT_1['evaluation_lineage']['valid_dataset'],

  162.     'dataset_graph': event_data.DATASET_DICT_0

  163. }

  164. LINEAGE_FILTRATION_0 = create_filtration_result(

  165.     '/path/to/summary0',

  166.     event_data.EVENT_TRAIN_DICT_0,

  167.     event_data.EVENT_EVAL_DICT_0,

  168.     event_data.METRIC_0,

  169.     event_data.DATASET_DICT_0

  170. )

  171. LINEAGE_FILTRATION_1 = create_filtration_result(

  172.     '/path/to/summary1',

  173.     event_data.EVENT_TRAIN_DICT_1,

  174.     event_data.EVENT_EVAL_DICT_1,

  175.     event_data.METRIC_1,

  176.     event_data.DATASET_DICT_0

  177. )

  178. LINEAGE_FILTRATION_2 = create_filtration_result(

  179.     '/path/to/summary2',

  180.     event_data.EVENT_TRAIN_DICT_2,

  181.     event_data.EVENT_EVAL_DICT_2,

  182.     event_data.METRIC_2,

  183.     event_data.DATASET_DICT_0

  184. )

  185. LINEAGE_FILTRATION_3 = create_filtration_result(

  186.     '/path/to/summary3',

  187.     event_data.EVENT_TRAIN_DICT_3,

  188.     event_data.EVENT_EVAL_DICT_3,

  189.     event_data.METRIC_3,

  190.     event_data.DATASET_DICT_0

  191. )

  192. LINEAGE_FILTRATION_4 = create_filtration_result(

  193.     '/path/to/summary4',

  194.     event_data.EVENT_TRAIN_DICT_4,

  195.     event_data.EVENT_EVAL_DICT_4,

  196.     event_data.METRIC_4,

  197.     event_data.DATASET_DICT_0

  198. )

  199. LINEAGE_FILTRATION_5 = {

  200.     "summary_dir": '/path/to/summary5',

  201.     "model_lineage": {

  202.         "loss_function":

  203.             event_data.EVENT_TRAIN_DICT_5['train_lineage']['hyper_parameters']['loss_function'],

  204.         "train_dataset_path": None,

  205.         "train_dataset_count":

  206.             event_data.EVENT_TRAIN_DICT_5['train_lineage']['train_dataset']['train_dataset_size'],

  207.         "test_dataset_path": None,

  208.         "test_dataset_count": None,

  209.         "network": event_data.EVENT_TRAIN_DICT_5['train_lineage']['algorithm']['network'],

  210.         "optimizer": event_data.EVENT_TRAIN_DICT_5['train_lineage']['hyper_parameters']['optimizer'],

  211.         "learning_rate":

  212.             event_data.EVENT_TRAIN_DICT_5['train_lineage']['hyper_parameters']['learning_rate'],

  213.         "epoch": event_data.EVENT_TRAIN_DICT_5['train_lineage']['hyper_parameters']['epoch'],

  214.         "batch_size": event_data.EVENT_TRAIN_DICT_5['train_lineage']['hyper_parameters']['batch_size'],

  215.         "device_num": event_data.EVENT_TRAIN_DICT_5['train_lineage']['hyper_parameters']['device_num'],

  216.         "loss": event_data.EVENT_TRAIN_DICT_5['train_lineage']['algorithm']['loss'],

  217.         "model_size": event_data.EVENT_TRAIN_DICT_5['train_lineage']['model']['size'],

  218.         "metric": {},

  219.         "dataset_mark": '2',

  220.         "user_defined": {}

  221.     },

  222.     "dataset_graph": event_data.DATASET_DICT_0

  223. }

  224. LINEAGE_FILTRATION_6 = {

  225.     "summary_dir": '/path/to/summary6',

  226.     "model_lineage": {

  227.         "loss_function": None,

  228.         "train_dataset_path": None,

  229.         "train_dataset_count": None,

  230.         "test_dataset_path":

  231.             event_data.EVENT_EVAL_DICT_5['evaluation_lineage']['valid_dataset']['valid_dataset_path'],

  232.         "test_dataset_count":

  233.             event_data.EVENT_EVAL_DICT_5['evaluation_lineage']['valid_dataset']['valid_dataset_size'],

  234.         "network": None,

  235.         "optimizer": None,

  236.         "learning_rate": None,

  237.         "epoch": None,

  238.         "batch_size": None,

  239.         "device_num": None,

  240.         "loss": None,

  241.         "model_size": None,

  242.         "metric": event_data.METRIC_5,

  243.         "dataset_mark": '2',

  244.         "user_defined": {}

  245.     },

  246.     "dataset_graph": event_data.DATASET_DICT_0

  247. }

  248. 

  249. 

  250. class TestQuerier(TestCase):

  251.     """Test the class of `Querier`."""

  252. 

  253.     @mock.patch('mindinsight.lineagemgr.lineage_parser.SummaryPathParser.get_lineage_summaries')

  254.     @mock.patch('mindinsight.lineagemgr.lineage_parser.SummaryWatcher.list_summary_directories')

  255.     @mock.patch('mindinsight.lineagemgr.lineage_parser.LineageSummaryAnalyzer.get_user_defined_info')

  256.     @mock.patch('mindinsight.lineagemgr.lineage_parser.LineageSummaryAnalyzer.get_summary_infos')

  257.     @mock.patch('mindinsight.lineagemgr.lineage_parser.FileHandler')

  258.     def setUp(self, mock_file_handler, *args):

  259.         """Initialization before test case execution."""

  260.         args[0].return_value = create_lineage_info(

  261.             event_data.EVENT_TRAIN_DICT_0,

  262.             event_data.EVENT_EVAL_DICT_0,

  263.             event_data.EVENT_DATASET_DICT_0

  264.         )

  265.         args[1].return_value = []

  266.         args[3].return_value = ['path']

  267.         mock_file_handler = MagicMock()

  268.         mock_file_handler.size = 1

  269. 

  270.         args[2].return_value = [{'relative_path': './', 'update_time': 1}]

  271.         single_summary_path = '/path/to/summary0'

  272.         lineage_objects = LineageOrganizer(summary_base_dir=single_summary_path).super_lineage_objs

  273.         self.single_querier = Querier(lineage_objects)

  274. 

  275.         lineage_infos = get_lineage_infos()

  276.         args[0].side_effect = lineage_infos

  277.         summary_base_dir = '/path/to'

  278.         relative_dirs = []

  279.         for i in range(7):

  280.             relative_dirs.append(dict(relative_path=f'./summary{i}', update_time=time.time() - i))

  281.         args[2].return_value = relative_dirs

  282.         lineage_objects = LineageOrganizer(summary_base_dir=summary_base_dir).super_lineage_objs

  283.         self.multi_querier = Querier(lineage_objects)

  284. 

  285.     def test_get_summary_lineage_success_1(self):

  286.         """Test the success of get_summary_lineage."""

  287.         expected_result = [LINEAGE_INFO_0]

  288.         result = self.single_querier.get_summary_lineage()

  289.         assert_equal_lineages(expected_result, result, self.assertListEqual)

  290. 

  291.     def test_get_summary_lineage_success_2(self):

  292.         """Test the success of get_summary_lineage."""

  293.         expected_result = [LINEAGE_INFO_0]

  294.         result = self.single_querier.get_summary_lineage()

  295.         assert_equal_lineages(expected_result, result, self.assertListEqual)

  296. 

  297.     def test_get_summary_lineage_success_3(self):

  298.         """Test the success of get_summary_lineage."""

  299.         expected_result = [

  300.             {

  301.                 'summary_dir': '/path/to/summary0',

  302.                 'model': event_data.EVENT_TRAIN_DICT_0['train_lineage']['model'],

  303.                 'algorithm': event_data.EVENT_TRAIN_DICT_0['train_lineage']['algorithm']

  304.             }

  305.         ]

  306.         result = self.single_querier.get_summary_lineage(

  307.             filter_keys=['model', 'algorithm']

  308.         )

  309.         assert_equal_lineages(expected_result, result, self.assertListEqual)

  310. 

  311.     def test_get_summary_lineage_success_4(self):

  312.         """Test the success of get_summary_lineage."""

  313.         expected_result = [

  314.             LINEAGE_INFO_0,

  315.             LINEAGE_INFO_1,

  316.             {

  317.                 'summary_dir': '/path/to/summary2',

  318.                 **event_data.EVENT_TRAIN_DICT_2['train_lineage'],

  319.                 'metric': event_data.METRIC_2,

  320.                 'valid_dataset': event_data.EVENT_EVAL_DICT_2['evaluation_lineage']['valid_dataset'],

  321.                 'dataset_graph': event_data.DATASET_DICT_0

  322.             },

  323.             {

  324.                 'summary_dir': '/path/to/summary3',

  325.                 **event_data.EVENT_TRAIN_DICT_3['train_lineage'],

  326.                 'metric': event_data.METRIC_3,

  327.                 'valid_dataset': event_data.EVENT_EVAL_DICT_3['evaluation_lineage']['valid_dataset'],

  328.                 'dataset_graph': event_data.DATASET_DICT_0

  329.             },

  330.             {

  331.                 'summary_dir': '/path/to/summary4',

  332.                 **event_data.EVENT_TRAIN_DICT_4['train_lineage'],

  333.                 'metric': event_data.METRIC_4,

  334.                 'valid_dataset': event_data.EVENT_EVAL_DICT_4['evaluation_lineage']['valid_dataset'],

  335.                 'dataset_graph': event_data.DATASET_DICT_0

  336.             },

  337.             {

  338.                 'summary_dir': '/path/to/summary5',

  339.                 **event_data.EVENT_TRAIN_DICT_5['train_lineage'],

  340.                 'metric': {},

  341.                 'valid_dataset': {},

  342.                 'dataset_graph': event_data.DATASET_DICT_0

  343.             },

  344.             {

  345.                 'summary_dir': '/path/to/summary6',

  346.                 'hyper_parameters': {},

  347.                 'algorithm': {},

  348.                 'model': {},

  349.                 'train_dataset': {},

  350.                 'metric': event_data.METRIC_5,

  351.                 'valid_dataset': event_data.EVENT_EVAL_DICT_5['evaluation_lineage']['valid_dataset'],

  352.                 'dataset_graph': event_data.DATASET_DICT_0

  353.             }

  354.         ]

  355.         result = self.multi_querier.get_summary_lineage()

  356.         assert_equal_lineages(expected_result, result, self.assertListEqual)

  357. 

  358.     def test_get_summary_lineage_success_5(self):

  359.         """Test the success of get_summary_lineage."""

  360.         expected_result = [LINEAGE_INFO_1]

  361.         result = self.multi_querier.get_summary_lineage(

  362.             summary_dir='/path/to/summary1'

  363.         )

  364.         assert_equal_lineages(expected_result, result, self.assertListEqual)

  365. 

  366.     def test_get_summary_lineage_success_6(self):

  367.         """Test the success of get_summary_lineage."""

  368.         expected_result = [

  369.             {

  370.                 'summary_dir': '/path/to/summary0',

  371.                 'hyper_parameters': event_data.EVENT_TRAIN_DICT_0['train_lineage']['hyper_parameters'],

  372.                 'train_dataset': event_data.EVENT_TRAIN_DICT_0['train_lineage']['train_dataset'],

  373.                 'metric': event_data.METRIC_0,

  374.                 'valid_dataset': event_data.EVENT_EVAL_DICT_0['evaluation_lineage']['valid_dataset']

  375.             }

  376.         ]

  377.         filter_keys = [

  378.             'metric', 'hyper_parameters', 'train_dataset', 'valid_dataset'

  379.         ]

  380.         result = self.multi_querier.get_summary_lineage(

  381.             summary_dir='/path/to/summary0', filter_keys=filter_keys

  382.         )

  383.         assert_equal_lineages(expected_result, result, self.assertListEqual)

  384. 

  385.     def test_get_summary_lineage_fail(self):

  386.         """Test the function of get_summary_lineage with exception."""

  387.         filter_keys = ['xxx']

  388.         self.assertRaises(

  389.             LineageQuerierParamException,

  390.             self.multi_querier.get_summary_lineage,

  391.             filter_keys=filter_keys

  392.         )

  393. 

  394.         self.assertRaises(

  395.             LineageQuerierParamException,

  396.             self.multi_querier.get_summary_lineage,

  397.             summary_dir='xxx'

  398.         )

  399. 

  400.     def test_filter_summary_lineage_success_1(self):

  401.         """Test the success of filter_summary_lineage."""

  402.         condition = {

  403.             'optimizer': {

  404.                 'in': [

  405.                     'ApplyMomentum0',

  406.                     'ApplyMomentum1',

  407.                     'ApplyMomentum2',

  408.                     'ApplyMomentum4'

  409.                 ]

  410.             },

  411.             'learning_rate': {

  412.                 'lt': 0.5,

  413.                 'gt': 0.2

  414.             },

  415.             'sorted_name': 'summary_dir'

  416.         }

  417.         expected_result = {

  418.             'customized': event_data.CUSTOMIZED_0,

  419.             'object': [

  420.                 LINEAGE_FILTRATION_1,

  421.                 LINEAGE_FILTRATION_2

  422.             ],

  423.             'count': 2,

  424.         }

  425.         result = self.multi_querier.filter_summary_lineage(condition=condition)

  426.         assert_equal_lineages(expected_result, result, self.assertDictEqual)

  427. 

  428.     def test_filter_summary_lineage_success_2(self):

  429.         """Test the success of filter_summary_lineage."""

  430.         condition = {

  431.             'batch_size': {

  432.                 'le': 50,

  433.                 'ge': 35

  434.             },

  435.             'model_size': {

  436.                 'lt': 400716934,

  437.                 'gt': 400716931

  438.             },

  439.             'sorted_name': 'batch_size',

  440.             'sorted_type': 'descending'

  441.         }

  442.         expected_result = {

  443.             'customized': event_data.CUSTOMIZED_0,

  444.             'object': [

  445.                 LINEAGE_FILTRATION_2,

  446.                 LINEAGE_FILTRATION_3

  447.             ],

  448.             'count': 2,

  449.         }

  450.         result = self.multi_querier.filter_summary_lineage(condition=condition)

  451.         assert_equal_lineages(expected_result, result, self.assertDictEqual)

  452. 

  453.     def test_filter_summary_lineage_success_3(self):

  454.         """Test the success of filter_summary_lineage."""

  455.         condition = {

  456.             'limit': 2,

  457.             'offset': 1

  458.         }

  459.         expected_result = {

  460.             'customized': event_data.CUSTOMIZED_0,

  461.             'object': [

  462.                 LINEAGE_FILTRATION_2,

  463.                 LINEAGE_FILTRATION_3

  464.             ],

  465.             'count': 7,

  466.         }

  467.         result = self.multi_querier.filter_summary_lineage(condition=condition)

  468.         assert_equal_lineages(expected_result, result, self.assertDictEqual)

  469. 

  470.     def test_filter_summary_lineage_success_4(self):

  471.         """Test the success of filter_summary_lineage."""

  472.         expected_result = {

  473.             'customized': event_data.CUSTOMIZED_2,

  474.             'object': [

  475.                 LINEAGE_FILTRATION_0,

  476.                 LINEAGE_FILTRATION_1,

  477.                 LINEAGE_FILTRATION_2,

  478.                 LINEAGE_FILTRATION_3,

  479.                 LINEAGE_FILTRATION_4,

  480.                 LINEAGE_FILTRATION_5,

  481.                 LINEAGE_FILTRATION_6

  482.             ],

  483.             'count': 7,

  484.         }

  485.         result = self.multi_querier.filter_summary_lineage()

  486.         assert_equal_lineages(expected_result, result, self.assertDictEqual)

  487. 

  488.     def test_filter_summary_lineage_success_5(self):

  489.         """Test the success of filter_summary_lineage."""

  490.         condition = {

  491.             'optimizer': {

  492.                 'eq': 'ApplyMomentum4'

  493.             }

  494.         }

  495.         expected_result = {

  496.             'customized': event_data.CUSTOMIZED_0,

  497.             'object': [LINEAGE_FILTRATION_4],

  498.             'count': 1,

  499.         }

  500.         result = self.multi_querier.filter_summary_lineage(condition=condition)

  501.         assert_equal_lineages(expected_result, result, self.assertDictEqual)

  502. 

  503.     def test_filter_summary_lineage_success_6(self):

  504.         """Test the success of filter_summary_lineage."""

  505.         condition = {

  506.             'sorted_name': 'metric/accuracy',

  507.             'sorted_type': 'ascending'

  508.         }

  509.         expected_result = {

  510.             'customized': event_data.CUSTOMIZED_2,

  511.             'object': [

  512.                 LINEAGE_FILTRATION_0,

  513.                 LINEAGE_FILTRATION_5,

  514.                 LINEAGE_FILTRATION_1,

  515.                 LINEAGE_FILTRATION_2,

  516.                 LINEAGE_FILTRATION_3,

  517.                 LINEAGE_FILTRATION_4,

  518.                 LINEAGE_FILTRATION_6

  519.             ],

  520.             'count': 7,

  521.         }

  522.         result = self.multi_querier.filter_summary_lineage(condition=condition)

  523.         assert_equal_lineages(expected_result, result, self.assertDictEqual)

  524. 

  525.     def test_filter_summary_lineage_success_7(self):

  526.         """Test the success of filter_summary_lineage."""

  527.         condition = {

  528.             'sorted_name': 'metric/accuracy',

  529.             'sorted_type': 'descending'

  530.         }

  531.         expected_result = {

  532.             'customized': event_data.CUSTOMIZED_2,

  533.             'object': [

  534.                 LINEAGE_FILTRATION_6,

  535.                 LINEAGE_FILTRATION_4,

  536.                 LINEAGE_FILTRATION_3,

  537.                 LINEAGE_FILTRATION_2,

  538.                 LINEAGE_FILTRATION_1,

  539.                 LINEAGE_FILTRATION_0,

  540.                 LINEAGE_FILTRATION_5

  541.             ],

  542.             'count': 7,

  543.         }

  544.         result = self.multi_querier.filter_summary_lineage(condition=condition)

  545.         assert_equal_lineages(expected_result, result, self.assertDictEqual)

  546. 

  547.     def test_filter_summary_lineage_success_8(self):

  548.         """Test the success of filter_summary_lineage."""

  549.         condition = {

  550.             'metric/accuracy': {

  551.                 'lt': 1.6000006,

  552.                 'gt': 1.4000004

  553.             }

  554.         }

  555.         expected_result = {

  556.             'customized': event_data.CUSTOMIZED_0,

  557.             'object': [LINEAGE_FILTRATION_4],

  558.             'count': 1,

  559.         }

  560.         result = self.multi_querier.filter_summary_lineage(condition=condition)

  561.         assert_equal_lineages(expected_result, result, self.assertDictEqual)

  562. 

  563.     def test_filter_summary_lineage_success_9(self):

  564.         """Test the success of filter_summary_lineage."""

  565.         condition = {

  566.             'limit': 3,

  567.             'offset': 3

  568.         }

  569.         expected_result = {

  570.             'customized': {},

  571.             'object': [],

  572.             'count': 7,

  573.         }

  574.         result = self.multi_querier.filter_summary_lineage(condition=condition)

  575.         assert_equal_lineages(expected_result, result, self.assertDictEqual)

  576. 

  577.     def test_filter_summary_lineage_fail(self):

  578.         """Test the function of filter_summary_lineage with exception."""

  579.         condition = {

  580.             'xxx': {

  581.                 'lt': 1.6000006,

  582.                 'gt': 1.4000004

  583.             }

  584.         }

  585.         self.assertRaises(

  586.             LineageQuerierParamException,

  587.             self.multi_querier.filter_summary_lineage,

  588.             condition=condition

  589.         )

  590. 

  591.         condition = {

  592.             'accuracy': {

  593.                 'xxx': 1

  594.             }

  595.         }

  596.         self.assertRaises(

  597.             LineageQuerierParamException,

  598.             self.multi_querier.filter_summary_lineage,

  599.             condition=condition

  600.         )

  601. 

  602.         condition = {

  603.             'sorted_name': 'xxx'

  604.         }

  605.         self.assertRaises(

  606.             LineageQuerierParamException,

  607.             self.multi_querier.filter_summary_lineage,

  608.             condition=condition

  609.         )

  610. 

  611.     def test_init_fail(self):

  612.         """Test the function of init with exception."""

  613.         obj_dict = 'a'

  614.         with self.assertRaises(LineageParamTypeError):

  615.             Querier(obj_dict)

  616. 

  617.         obj_dict = None

  618.         with self.assertRaises(LineageQuerierParamException):

  619.             Querier(obj_dict)