Python utils.generate_uuid函数代码示例

    def test_filter_by_goal_name(self):
        goal1 = obj_utils.create_test_goal(
            self.context,
            id=1,
            uuid=utils.generate_uuid(),
            name='My_Goal 1')
        goal2 = obj_utils.create_test_goal(
            self.context,
            id=2,
            uuid=utils.generate_uuid(),
            name='My Goal 2')

        for id_ in range(1, 3):
            obj_utils.create_test_strategy(
                self.context, id=id_,
                uuid=utils.generate_uuid(),
                goal_id=goal1['id'])
        for id_ in range(3, 5):
            obj_utils.create_test_strategy(
                self.context, id=id_,
                uuid=utils.generate_uuid(),
                goal_id=goal2['id'])

        response = self.get_json('/strategies/?goal=%s' % goal1['name'])

        strategies = response['strategies']
        self.assertEqual(2, len(strategies))
        for strategy in strategies:
            self.assertEqual(goal1['uuid'], strategy['goal_uuid'])

    def test_filter_by_audit_template_name(self):
        audit_template_uuid = utils.generate_uuid()
        audit_template_name = 'My_Audit_Template'

        audit_template = obj_utils.create_test_audit_template(
            self.context,
            uuid=audit_template_uuid,
            name=audit_template_name)

        number_of_audits_with_audit_template_id = 5
        for id_ in range(number_of_audits_with_audit_template_id):
            obj_utils.create_test_audit(self.context, id=id_,
                                        uuid=utils.generate_uuid(),
                                        audit_template_id=audit_template.id)
        for id_ in range(6, 8):
            obj_utils.create_test_audit(self.context, id=id_,
                                        uuid=utils.generate_uuid())

        response = self.get_json('/audits/?audit_template=%s'
                                 % audit_template_name)

        audits = response['audits']
        self.assertEqual(5, len(audits))
        for audit in audits:
            self.assertEqual(audit_template_uuid,
                             audit['audit_template_uuid'])

    def test_many_with_soft_deleted_audit_uuid(self):
        action_plan_list = []
        audit1 = obj_utils.create_test_audit(self.context,
                                             id=1,
                                             uuid=utils.generate_uuid())
        audit2 = obj_utils.create_test_audit(self.context,
                                             id=2,
                                             uuid=utils.generate_uuid())

        for id_ in range(0, 2):
            action_plan = obj_utils.create_test_action_plan(
                self.context, id=id_, uuid=utils.generate_uuid(),
                audit_id=audit1.id)
            action_plan_list.append(action_plan.uuid)

        for id_ in range(2, 4):
            action_plan = obj_utils.create_test_action_plan(
                self.context, id=id_, uuid=utils.generate_uuid(),
                audit_id=audit2.id)
            action_plan_list.append(action_plan.uuid)

        self.delete('/audits/%s' % audit1.uuid)

        response = self.get_json('/action_plans')

        self.assertEqual(len(action_plan_list), len(response['action_plans']))

        for id_ in range(0, 2):
            action_plan = response['action_plans'][id_]
            self.assertIsNone(action_plan['audit_uuid'])

        for id_ in range(2, 4):
            action_plan = response['action_plans'][id_]
            self.assertEqual(audit2.uuid, action_plan['audit_uuid'])

    def test_get_goal_list_with_filters(self):
        goal1 = self._create_test_goal(
            id=1,
            uuid=w_utils.generate_uuid(),
            name="GOAL_1",
            display_name='Goal 1',
        )
        goal2 = self._create_test_goal(
            id=2,
            uuid=w_utils.generate_uuid(),
            name="GOAL_2",
            display_name='Goal 2',
        )

        res = self.dbapi.get_goal_list(self.context,
                                       filters={'display_name': 'Goal 1'})
        self.assertEqual([goal1['uuid']], [r.uuid for r in res])

        res = self.dbapi.get_goal_list(self.context,
                                       filters={'display_name': 'Goal 3'})
        self.assertEqual([], [r.uuid for r in res])

        res = self.dbapi.get_goal_list(
            self.context, filters={'name': 'GOAL_1'})
        self.assertEqual([goal1['uuid']], [r.uuid for r in res])

        res = self.dbapi.get_goal_list(
            self.context,
            filters={'display_name': 'Goal 2'})
        self.assertEqual([goal2['uuid']], [r.uuid for r in res])

    def test_execute_force_dummy(self):
        obj_utils.create_test_goal(self.context, id=50,
                                   uuid=utils.generate_uuid(),
                                   name="my_goal")

        strategy = obj_utils.create_test_strategy(self.context,
                                                  id=42,
                                                  uuid=utils.generate_uuid(),
                                                  name="dummy")

        audit_template = obj_utils.create_test_audit_template(
            self.context,
            uuid=utils.generate_uuid(),
            strategy_id=strategy.id,
            name="my_template")

        audit = obj_utils.create_test_audit(
            self.context,
            audit_template_id=audit_template.id,
            uuid=utils.generate_uuid(),
        )

        solution = self.strategy_context.execute_strategy(
            audit.uuid, self.context)

        self.assertEqual(len(solution.actions), 3)

    def test_execute_force_basic(self, mock_call):
        expected_strategy = "basic"
        mock_call.return_value = expected_strategy

        obj_utils.create_test_goal(self.context, id=50,
                                   uuid=utils.generate_uuid(),
                                   name="my_goal")

        strategy = obj_utils.create_test_strategy(self.context,
                                                  id=42,
                                                  uuid=utils.generate_uuid(),
                                                  name=expected_strategy)

        audit_template = obj_utils.create_test_audit_template(
            self.context,
            uuid=utils.generate_uuid(),
            strategy_id=strategy.id,
            name="my_template")

        audit = obj_utils.create_test_audit(
            self.context,
            audit_template_id=audit_template.id,
            uuid=utils.generate_uuid(),
        )

        solution = self.strategy_context.execute_strategy(
            audit.uuid, self.context)

        self.assertEqual(solution, expected_strategy)

    def test_get_scoring_engine_list_with_filters(self):
        scoring_engine1 = self._create_test_scoring_engine(
            id=1,
            uuid=w_utils.generate_uuid(),
            name="SE_ID_1",
            description='ScoringEngine 1',
            metainfo="a1=b1",
        )
        scoring_engine2 = self._create_test_scoring_engine(
            id=2,
            uuid=w_utils.generate_uuid(),
            name="SE_ID_2",
            description='ScoringEngine 2',
            metainfo="a2=b2",
        )

        res = self.dbapi.get_scoring_engine_list(
            self.context, filters={'description': 'ScoringEngine 1'})
        self.assertEqual([scoring_engine1['name']], [r.name for r in res])

        res = self.dbapi.get_scoring_engine_list(
            self.context, filters={'description': 'ScoringEngine 3'})
        self.assertEqual([], [r.name for r in res])

        res = self.dbapi.get_scoring_engine_list(
            self.context,
            filters={'description': 'ScoringEngine 2'})
        self.assertEqual([scoring_engine2['name']], [r.name for r in res])

    def test_get_audit_list_with_filters(self):
        audit1 = self._create_test_audit(
            id=1,
            type='ONESHOT',
            uuid=w_utils.generate_uuid(),
            deadline=None,
            state='ONGOING')
        audit2 = self._create_test_audit(
            id=2,
            type='CONTINUOUS',
            uuid=w_utils.generate_uuid(),
            deadline=None,
            state='PENDING')

        res = self.dbapi.get_audit_list(self.context,
                                        filters={'type': 'ONESHOT'})
        self.assertEqual([audit1['id']], [r.id for r in res])

        res = self.dbapi.get_audit_list(self.context,
                                        filters={'type': 'bad-type'})
        self.assertEqual([], [r.id for r in res])

        res = self.dbapi.get_audit_list(
            self.context,
            filters={'state': 'ONGOING'})
        self.assertEqual([audit1['id']], [r.id for r in res])

        res = self.dbapi.get_audit_list(
            self.context,
            filters={'state': 'PENDING'})
        self.assertEqual([audit2['id']], [r.id for r in res])

    def _data_setup(self):
        strategy1_name = "STRATEGY_ID_1"
        strategy2_name = "STRATEGY_ID_2"
        strategy3_name = "STRATEGY_ID_3"

        self.goal1 = utils.create_test_goal(
            id=1, uuid=w_utils.generate_uuid(),
            name="GOAL_ID", display_name="Goal")
        self.goal2 = utils.create_test_goal(
            id=2, uuid=w_utils.generate_uuid(),
            name="DUMMY", display_name="Dummy")

        with freezegun.freeze_time(self.FAKE_TODAY):
            self.strategy1 = utils.create_test_strategy(
                id=1, uuid=w_utils.generate_uuid(),
                name=strategy1_name, display_name="Strategy 1",
                goal_id=self.goal1.id)
        with freezegun.freeze_time(self.FAKE_OLD_DATE):
            self.strategy2 = utils.create_test_strategy(
                id=2, uuid=w_utils.generate_uuid(),
                name=strategy2_name, display_name="Strategy 2",
                goal_id=self.goal1.id)
        with freezegun.freeze_time(self.FAKE_OLDER_DATE):
            self.strategy3 = utils.create_test_strategy(
                id=3, uuid=w_utils.generate_uuid(),
                name=strategy3_name, display_name="Strategy 3",
                goal_id=self.goal2.id)

    def test_get_strategy_list_with_filters(self):
        strategy1 = self._create_test_strategy(
            id=1,
            uuid=w_utils.generate_uuid(),
            name="STRATEGY_ID_1",
            display_name='Strategy 1',
        )
        strategy2 = self._create_test_strategy(
            id=2,
            uuid=w_utils.generate_uuid(),
            name="STRATEGY_ID_2",
            display_name='Strategy 2',
        )

        res = self.dbapi.get_strategy_list(
            self.context, filters={'display_name': 'Strategy 1'})
        self.assertEqual([strategy1['uuid']], [r.uuid for r in res])

        res = self.dbapi.get_strategy_list(
            self.context, filters={'display_name': 'Strategy 3'})
        self.assertEqual([], [r.uuid for r in res])

        res = self.dbapi.get_strategy_list(
            self.context,
            filters={'goal_id': 1})
        self.assertEqual([strategy1['uuid'], strategy2['uuid']],
                         [r.uuid for r in res])

        res = self.dbapi.get_strategy_list(
            self.context,
            filters={'display_name': 'Strategy 2'})
        self.assertEqual([strategy2['uuid']], [r.uuid for r in res])

 def setUp(self):
     super(TestAuditTemplateObject, self).setUp()
     self.fake_audit_template = utils.get_test_audit_template()
     self.fake_goal1 = utils.create_test_goal(
         id=1, uuid=w_utils.generate_uuid(), name="DUMMY")
     self.fake_goal2 = utils.create_test_goal(
         id=2, uuid=w_utils.generate_uuid(), name="BALANCE_LOAD")

    def test_get_audit_list_with_filter_by_audit_template_name(self):

        audit_template = self.dbapi.create_audit_template(
            utils.get_test_audit_template(
                uuid=w_utils.generate_uuid(),
                name='My Audit Template 1',
                description='Description of my audit template 1',
                host_aggregate=5,
                goal='DUMMY',
                extra={'automatic': True})
        )

        audit = self._create_test_audit(
            type='ONESHOT',
            uuid=w_utils.generate_uuid(),
            deadline=None,
            state='ONGOING',
            audit_template_id=audit_template.id)

        res = self.dbapi.get_audit_list(
            self.context,
            filters={'audit_template_name': audit_template.name})

        for r in res:
            self.assertEqual(audit['audit_template_id'], r.audit_template_id)

    def test_get_action_list_with_filters(self):
        audit = utils.create_test_audit(uuid=w_utils.generate_uuid())
        action_plan = self._create_test_action_plan(
            id=1,
            uuid=w_utils.generate_uuid(),
            audit_id=audit.id,
            first_action_id=None,
            state='RECOMMENDED')
        action1 = self._create_test_action(
            id=1,
            action_plan_id=1,
            description='description action 1',
            uuid=w_utils.generate_uuid(),
            next=None,
            state='PENDING',
            alarm=None)
        action2 = self._create_test_action(
            id=2,
            action_plan_id=2,
            description='description action 2',
            uuid=w_utils.generate_uuid(),
            next=action1['uuid'],
            state='PENDING',
            alarm=None)
        action3 = self._create_test_action(
            id=3,
            action_plan_id=1,
            description='description action 3',
            uuid=w_utils.generate_uuid(),
            next=action2['uuid'],
            state='ONGOING',
            alarm=None)
        res = self.dbapi.get_action_list(self.context,
                                         filters={'state': 'ONGOING'})
        self.assertEqual([action3['id']], [r.id for r in res])

        res = self.dbapi.get_action_list(self.context,
                                         filters={'state': 'bad-state'})
        self.assertEqual([], [r.id for r in res])

        res = self.dbapi.get_action_list(
            self.context,
            filters={'action_plan_id': 2})
        self.assertEqual([action2['id']], [r.id for r in res])

        res = self.dbapi.get_action_list(
            self.context,
            filters={'action_plan_uuid': action_plan['uuid']})
        self.assertEqual(
            [action1['id'], action3['id']].sort(),
            [r.id for r in res].sort())

        res = self.dbapi.get_action_list(
            self.context,
            filters={'audit_uuid': audit.uuid})
        for action in res:
            self.assertEqual(action_plan['id'], action.action_plan_id)

 def test_audit_template_create_same_name(self):
     audit_template1 = utils.create_test_audit_template(
         uuid=w_utils.generate_uuid(),
         name='audit_template_name')
     self.assertEqual(audit_template1['uuid'], audit_template1.uuid)
     self.assertRaises(
         exception.AuditTemplateAlreadyExists,
         utils.create_test_audit_template,
         uuid=w_utils.generate_uuid(),
         name='audit_template_name')

 def test_filter_by_action_plan_and_audit_uuids(self):
     audit = obj_utils.create_test_audit(
         self.context, uuid=utils.generate_uuid())
     action_plan = obj_utils.create_test_action_plan(
         self.context,
         uuid=utils.generate_uuid(),
         audit_id=audit.id)
     url = '/actions?action_plan_uuid=%s&audit_uuid=%s' % (
         action_plan.uuid, audit.uuid)
     response = self.get_json(url, expect_errors=True)
     self.assertEqual(400, response.status_int)