コード例 #1
0
        def _exercise_domain_api(ref_id):
            driver = self.resource_api.driver
            self.assertRaises(exception.DomainNotFound, driver.get_domain,
                              ref_id)

            self.assertRaises(exception.DomainNotFound,
                              driver.get_domain_by_name,
                              resource.NULL_DOMAIN_ID)

            domain_ids = [
                x['id'] for x in driver.list_domains(driver_hints.Hints())
            ]
            self.assertNotIn(ref_id, domain_ids)

            domains = driver.list_domains_from_ids([ref_id])
            self.assertThat(domains, matchers.HasLength(0))

            self.assertRaises(exception.DomainNotFound, driver.update_domain,
                              ref_id, {})

            self.assertRaises(exception.DomainNotFound, driver.delete_domain,
                              ref_id)
コード例 #2
0
    def _test_update_event_transform(self, instance_events):
        for event in instance_events:
            # Test action
            transformer = self.transformers[NOVA_INSTANCE_DATASOURCE]
            wrapper = transformer.transform(event)

            # Test assertions
            self._validate_update_vertex_props(
                transformer, wrapper.vertex, event)

            # Validate the neighbors: only one  valid host neighbor
            neighbors = wrapper.neighbors
            self.assertThat(neighbors, matchers.HasLength(1))
            self._validate_host_neighbor(neighbors[0], event)

            event_type = event[DSProps.EVENT_TYPE]
            if event_type == 'compute.instance.delete.end':
                self.assertEqual(GraphAction.DELETE_ENTITY, wrapper.action)
            elif event_type == 'compute.instance.create.start':
                self.assertEqual(GraphAction.CREATE_ENTITY, wrapper.action)
            else:
                self.assertEqual(GraphAction.UPDATE_ENTITY, wrapper.action)
コード例 #3
0
 def test_set_and_get_queue_metadata(self):
     # Retrieve random queue
     queue_name = self.queues[data_utils.rand_int_id(
         0,
         len(self.queues) - 1)]
     # Check the Queue has no metadata
     _, body = self.get_queue_metadata(queue_name)
     self.assertThat(body, matchers.HasLength(0))
     # Create metadata
     key3 = [0, 1, 2, 3, 4]
     key2 = data_utils.rand_name('value')
     req_body1 = dict()
     req_body1[data_utils.rand_name('key3')] = key3
     req_body1[data_utils.rand_name('key2')] = key2
     req_body = dict()
     req_body[data_utils.rand_name('key1')] = req_body1
     # Set Queue Metadata
     _, body = self.set_queue_metadata(queue_name, req_body)
     self.assertEqual('', body)
     # Get Queue Metadata
     _, body = self.get_queue_metadata(queue_name)
     self.assertThat(body, matchers.Equals(req_body))
コード例 #4
0
    def test_meta(self):
        class Manager(object):
            __metaclass__ = manager.ManagerMeta

            @manager.periodic_task
            def foo(self):
                return 'foo'

            @manager.periodic_task(spacing=4)
            def bar(self):
                return 'bar'

            @manager.periodic_task(enabled=False)
            def baz(self):
                return 'baz'

        m = Manager()
        self.assertThat(m._periodic_tasks, matchers.HasLength(2))
        self.assertEqual(None, m._periodic_spacing['foo'])
        self.assertEqual(4, m._periodic_spacing['bar'])
        self.assertThat(m._periodic_spacing,
                        matchers.Not(matchers.Contains('baz')))
コード例 #5
0
    def test_load_datasources_value_with_errors(self):
        # setup
        entity_graph_opts = [
            cfg.StrOpt('datasources_values_dir',
                       default=utils.get_resources_dir() +
                       '/datasources_values/erroneous_values'),
        ]
        conf = cfg.ConfigOpts()
        conf.register_opts(entity_graph_opts, group='entity_graph')
        conf.register_opts(self.DATASOURCES_OPTS, group='datasources')
        self._load_datasources(conf)

        # action
        info_mapper = DatasourceInfoMapper(conf)

        # test assertions
        missing_values = 1
        erroneous_values = 1
        num_valid_datasources = len(info_mapper.datasources_value_confs) + \
            missing_values + erroneous_values
        self.assertThat(conf.datasources.types,
                        matchers.HasLength(num_valid_datasources))
コード例 #6
0
ファイル: test_drivers.py プロジェクト: zdj6373/ironic
 def test_drivers(self):
     self.register_fake_conductors()
     expected = sorted([
         {
             'name': self.d1,
             'hosts': [self.h1]
         },
         {
             'name': self.d2,
             'hosts': [self.h1, self.h2]
         },
     ],
                       key=lambda d: d['name'])
     data = self.get_json('/drivers')
     self.assertThat(data['drivers'], matchers.HasLength(2))
     drivers = sorted(data['drivers'], key=lambda d: d['name'])
     for i in range(len(expected)):
         d = drivers[i]
         self.assertEqual(expected[i]['name'], d['name'])
         self.assertEqual(sorted(expected[i]['hosts']), sorted(d['hosts']))
         self.validate_link(d['links'][0]['href'])
         self.validate_link(d['links'][1]['href'])
コード例 #7
0
    def test_update_transform(self):
        LOG.debug('Cinder Volume transformer test: transform entity event '
                  'update')

        # Test setup
        spec_list = mock_sync.simple_volume_generators(volume_num=3,
                                                       instance_num=7,
                                                       update_events=7)
        static_events = mock_sync.generate_random_events_list(spec_list)

        for event in static_events:
            # Test action
            wrapper = self.transformers[CINDER_VOLUME_DATASOURCE].transform(
                event)

            # Test assertions
            vertex = wrapper.vertex
            self._validate_volume_vertex_props(vertex, event)

            neighbors = wrapper.neighbors
            self.assertThat(neighbors, matchers.HasLength(1))
            self._validate_neighbors(neighbors, vertex.vertex_id, event)
コード例 #8
0
ファイル: test_backend_sql.py プロジェクト: madorn/keystone
    def test_list_domains_for_user(self):
        domain = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex}
        self.resource_api.create_domain(domain['id'], domain)
        user = {'name': uuid.uuid4().hex, 'password': uuid.uuid4().hex,
                'domain_id': domain['id'], 'enabled': True}

        test_domain1 = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex}
        self.resource_api.create_domain(test_domain1['id'], test_domain1)
        test_domain2 = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex}
        self.resource_api.create_domain(test_domain2['id'], test_domain2)

        user = self.identity_api.create_user(user)
        user_domains = self.assignment_api.list_domains_for_user(user['id'])
        self.assertEqual(0, len(user_domains))
        self.assignment_api.create_grant(user_id=user['id'],
                                         domain_id=test_domain1['id'],
                                         role_id=self.role_member['id'])
        self.assignment_api.create_grant(user_id=user['id'],
                                         domain_id=test_domain2['id'],
                                         role_id=self.role_member['id'])
        user_domains = self.assignment_api.list_domains_for_user(user['id'])
        self.assertThat(user_domains, matchers.HasLength(2))
コード例 #9
0
ファイル: test_backend_sql.py プロジェクト: madorn/keystone
    def test_list_domains_for_user_with_inherited_grants(self):
        """Test that inherited roles on the domain are excluded.

        Test Plan:

        - Create two domains, one user, group and role
        - Domain1 is given an inherited user role, Domain2 an inherited
          group role (for a group of which the user is a member)
        - When listing domains for user, neither domain should be returned

        """
        domain1 = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex}
        domain1 = self.resource_api.create_domain(domain1['id'], domain1)
        domain2 = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex}
        domain2 = self.resource_api.create_domain(domain2['id'], domain2)
        user = {'name': uuid.uuid4().hex, 'password': uuid.uuid4().hex,
                'domain_id': domain1['id'], 'enabled': True}
        user = self.identity_api.create_user(user)
        group = {'name': uuid.uuid4().hex, 'domain_id': domain1['id']}
        group = self.identity_api.create_group(group)
        self.identity_api.add_user_to_group(user['id'], group['id'])
        role = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex}
        self.role_api.create_role(role['id'], role)

        # Create a grant on each domain, one user grant, one group grant,
        # both inherited.
        self.assignment_api.create_grant(user_id=user['id'],
                                         domain_id=domain1['id'],
                                         role_id=role['id'],
                                         inherited_to_projects=True)
        self.assignment_api.create_grant(group_id=group['id'],
                                         domain_id=domain2['id'],
                                         role_id=role['id'],
                                         inherited_to_projects=True)

        user_domains = self.assignment_api.list_domains_for_user(user['id'])
        # No domains should be returned since both domains have only inherited
        # roles assignments.
        self.assertThat(user_domains, matchers.HasLength(0))
コード例 #10
0
 def test_multiple_lines_nochange(self):
     global_content = textwrap.dedent("""\
         foo<2;python_version=='2.7'
         foo>1;python_version!='2.7'
         """)
     project_content = textwrap.dedent("""\
         foo<2;python_version=='2.7'
         foo>1;python_version!='2.7'
         """)
     global_reqs = requirement.parse(global_content)
     project_reqs = list(requirement.to_reqs(project_content))
     actions, reqs = update._sync_requirements_file(global_reqs,
                                                    project_reqs, 'f',
                                                    False, False, False)
     self.assertEqual(
         requirement.Requirements([
             requirement.Requirement('foo', '', '<2',
                                     "python_version=='2.7'", ''),
             requirement.Requirement('foo', '', '>1',
                                     "python_version!='2.7'", '')
         ]), reqs)
     self.assertThat(actions, matchers.HasLength(0))
コード例 #11
0
ファイル: test_session.py プロジェクト: nickpfeil/Cellar
    def test_connect_retries(self):
        def _timeout_error(request, context):
            raise requests.exceptions.Timeout()

        self.stub_url('GET', text=_timeout_error)

        session = client_session.Session()
        retries = 3

        with mock.patch('time.sleep') as m:
            self.assertRaises(exceptions.RequestTimeout,
                              session.get,
                              self.TEST_URL,
                              connect_retries=retries)

            self.assertEqual(retries, m.call_count)
            # 3 retries finishing with 2.0 means 0.5, 1.0 and 2.0
            m.assert_called_with(2.0)

        # we count retries so there will be one initial request + 3 retries
        self.assertThat(self.requests_mock.request_history,
                        matchers.HasLength(retries + 1))
コード例 #12
0
 def test_single_global_multiple_in_project(self):
     global_content = textwrap.dedent("""\
         foo>1
         """)
     project_content = textwrap.dedent("""\
         foo<2;python_version=='2.7'
         foo>1;python_version!='2.7'
         """)
     global_reqs = requirement.parse(global_content)
     project_reqs = list(requirement.to_reqs(project_content))
     actions, reqs = update._sync_requirements_file(global_reqs,
                                                    project_reqs, 'f',
                                                    False, False, False)
     self.assertEqual(
         requirement.Requirements(
             [requirement.Requirement('foo', '', '>1', "", '')]), reqs)
     self.assertEqual(
         project.StdOut("    foo<2;python_version=='2.7'    ->   foo>1\n"),
         actions[2])
     self.assertEqual(
         project.StdOut("    foo>1;python_version!='2.7'    ->   \n"),
         actions[3])
     self.assertThat(actions, matchers.HasLength(4))
コード例 #13
0
    def test_var_binds(self):

        oid_with_alarm_objects = \
            common.GENERAL_OID + '.' + \
            common.COMPANY_OID + '.' + common.ALARM_OBJECTS_OID

        var_binds = self.snmp_sender._get_var_binds(common.alarm_data)

        self.assertThat(var_binds, matchers.HasLength(3))

        self.assertIn((oid_with_alarm_objects + '.' + common.NAME_OID,
                      OctetString(common.alarm_data.get(VProps.NAME,
                                                        sender.NA))),
                      var_binds)
        self.assertIn((oid_with_alarm_objects + '.' + common.IS_DELETED_OID,
                       OctetString(common.alarm_data.get
                                   (VProps.VITRAGE_IS_DELETED, sender.NA))),
                      var_binds)
        self.assertIn((oid_with_alarm_objects + '.' + common.SEVERITY_OID,
                       OctetString(common.alarm_data.get
                                   (VProps.VITRAGE_OPERATIONAL_SEVERITY,
                                    sender.NA))),
                      var_binds)
コード例 #14
0
    def _validate_instance_neighbor(self, wrapper, alarm_id, instance_id):

        self.assertThat(wrapper.neighbors, matchers.HasLength(1))
        vm_neighbor = wrapper.neighbors[0]

        instance_transformer = self.transformers[NOVA_INSTANCE_DATASOURCE]
        properties = {
            VProps.ID:
            instance_id,
            VProps.VITRAGE_TYPE:
            NOVA_INSTANCE_DATASOURCE,
            VProps.VITRAGE_CATEGORY:
            EntityCategory.RESOURCE,
            VProps.VITRAGE_SAMPLE_TIMESTAMP:
            wrapper.vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP],
        }
        expected_neighbor = instance_transformer. \
            create_neighbor_placeholder_vertex(**properties)

        self.assertEqual(expected_neighbor, vm_neighbor.vertex)

        # Validate neighbor edge
        self._validate_neighbor_edge(alarm_id, vm_neighbor)
コード例 #15
0
    def test_heat_stack_validity(self):
        # Setup
        processor = self._create_processor_with_graph(self.conf)
        self.assertThat(
            processor.entity_graph,
            matchers.HasLength(self._num_total_expected_vertices()))

        spec_list = mock_driver.simple_stack_generators(
            stack_num=1, instance_and_volume_num=1, snapshot_events=1)
        static_events = mock_driver.generate_random_events_list(spec_list)
        heat_stack_event = static_events[0]

        # Action
        processor.process_event(heat_stack_event)

        # Test assertions
        self.assertThat(
            processor.entity_graph,
            matchers.HasLength(self._num_total_expected_vertices() + 3))

        stack_vertices = processor.entity_graph.get_vertices(
            vertex_attr_filter={
                VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
                VProps.VITRAGE_TYPE: HEAT_STACK_DATASOURCE
            })
        self.assertThat(stack_vertices, matchers.HasLength(1))

        instance_vertices = processor.entity_graph.get_vertices(
            vertex_attr_filter={
                VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
                VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE
            })
        self.assertThat(instance_vertices,
                        matchers.HasLength(self.NUM_INSTANCES + 1))

        cinder_vertices = processor.entity_graph.get_vertices(
            vertex_attr_filter={
                VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE,
                VProps.VITRAGE_TYPE: CINDER_VOLUME_DATASOURCE
            })
        self.assertThat(cinder_vertices, matchers.HasLength(1))

        stack_neighbors = processor.entity_graph.neighbors(
            stack_vertices[0].vertex_id)
        self.assertThat(stack_neighbors, matchers.HasLength(2))
コード例 #16
0
    def test_show_webhook(self):
        webhooks = self.vitrage_client.webhook.list()
        self.assertThat(
            webhooks, matchers.HasLength(self.pre_test_webhook_count),
            'Amount of webhooks should be '
            'the same as before the test')

        created_webhook = self.vitrage_client.webhook.add(
            url="https://www.test.com",
            regex_filter=REGEX_PROPS,
            headers=HEADERS_PROPS)

        show_webhook = self.vitrage_client.webhook.show(created_webhook['id'])

        self.assertIsNotNone(show_webhook, 'webhook not listed')
        self.assertEqual(created_webhook[HEADERS], show_webhook[HEADERS],
                         'headers mismatch')
        self.assertEqual(created_webhook[REGEX_FILTER],
                         show_webhook[REGEX_FILTER], 'regex mismatch')
        self.assertEqual(created_webhook[URL], show_webhook[URL],
                         'URL mismatch')

        self.vitrage_client.webhook.delete(created_webhook['id'])
コード例 #17
0
    def _add_entities_with_different_timestamps(self, consistency_interval,
                                                create_func,
                                                category,
                                                datasource_name,
                                                resource_type):
        # add resources to the graph:
        # - updated_resource
        # - outdated_resource with an old timestamp
        # - deleted_resource with an old timestamp and is_deleted==true

        future_timestamp = str(datetime.datetime_delta(
            2 * consistency_interval))
        past_timestamp = str(datetime.datetime_delta(
            -2 * consistency_interval + 1))

        updated_resource = create_func(
            v_id=resource_type + '1234', v_type=resource_type,
            ds_name=datasource_name, timestamp=future_timestamp)
        outdated_resource = create_func(
            v_id=resource_type + '5678', v_type=resource_type,
            ds_name=datasource_name, timestamp=past_timestamp)
        deleted_resource = create_func(
            v_id=resource_type + '9999', v_type=resource_type,
            ds_name=datasource_name, timestamp=past_timestamp, is_deleted=True)

        self.graph.add_vertex(updated_resource)
        self.graph.add_vertex(outdated_resource)
        self.graph.add_vertex(deleted_resource)

        # get the list of vertices
        resource_vertices = self.processor.entity_graph.get_vertices({
            VProps.VITRAGE_CATEGORY: category,
            VProps.VITRAGE_TYPE: resource_type
        })

        self.assertThat(resource_vertices, matchers.HasLength(3),
                        'Wrong number of vertices of type %s', resource_type)
コード例 #18
0
ファイル: test_backend_sql.py プロジェクト: madorn/keystone
    def test_list_domains_for_user_with_grants(self):
        # Create two groups each with a role on a different domain, and
        # make user1 a member of both groups.  Both these new domains
        # should now be included, along with any direct user grants.
        domain = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex}
        self.resource_api.create_domain(domain['id'], domain)
        user = {'name': uuid.uuid4().hex, 'password': uuid.uuid4().hex,
                'domain_id': domain['id'], 'enabled': True}
        user = self.identity_api.create_user(user)
        group1 = {'name': uuid.uuid4().hex, 'domain_id': domain['id']}
        group1 = self.identity_api.create_group(group1)
        group2 = {'name': uuid.uuid4().hex, 'domain_id': domain['id']}
        group2 = self.identity_api.create_group(group2)

        test_domain1 = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex}
        self.resource_api.create_domain(test_domain1['id'], test_domain1)
        test_domain2 = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex}
        self.resource_api.create_domain(test_domain2['id'], test_domain2)
        test_domain3 = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex}
        self.resource_api.create_domain(test_domain3['id'], test_domain3)

        self.identity_api.add_user_to_group(user['id'], group1['id'])
        self.identity_api.add_user_to_group(user['id'], group2['id'])

        # Create 3 grants, one user grant, the other two as group grants
        self.assignment_api.create_grant(user_id=user['id'],
                                         domain_id=test_domain1['id'],
                                         role_id=self.role_member['id'])
        self.assignment_api.create_grant(group_id=group1['id'],
                                         domain_id=test_domain2['id'],
                                         role_id=self.role_admin['id'])
        self.assignment_api.create_grant(group_id=group2['id'],
                                         domain_id=test_domain3['id'],
                                         role_id=self.role_admin['id'])
        user_domains = self.assignment_api.list_domains_for_user(user['id'])
        self.assertThat(user_domains, matchers.HasLength(3))
コード例 #19
0
ファイル: test_consistency.py プロジェクト: ropodaing/vitrage
    def _periodic_process_setup_stage(self, consistency_interval):
        self._create_processor_with_graph(self.conf, processor=self.processor)
        current_time = utcnow()

        # set all vertices to be have timestamp that consistency won't get
        self._update_timestamp(
            self.processor.entity_graph.get_vertices(),
            current_time + timedelta(seconds=1.5 * consistency_interval))

        # check number of instances in graph
        instance_vertices = self.processor.entity_graph.get_vertices({
            VProps.VITRAGE_CATEGORY:
            EntityCategory.RESOURCE,
            VProps.VITRAGE_TYPE:
            NOVA_INSTANCE_DATASOURCE
        })
        self.assertThat(instance_vertices,
                        matchers.HasLength(self.NUM_INSTANCES))

        # set current timestamp of part of the instances
        self._update_timestamp(instance_vertices[0:3], current_time)

        # set part of the instances as deleted
        for i in range(3, 6):
            instance_vertices[i][VProps.VITRAGE_IS_DELETED] = True
            self.processor.entity_graph.update_vertex(instance_vertices[i])

        # set part of the instances as deleted
        for i in range(6, 9):
            instance_vertices[i][VProps.VITRAGE_IS_DELETED] = True
            instance_vertices[i][VProps.VITRAGE_SAMPLE_TIMESTAMP] = str(
                current_time + timedelta(seconds=2 * consistency_interval + 1))
            self.processor.entity_graph.update_vertex(instance_vertices[i])

        self._add_static_resources(consistency_interval)
        self._add_cinder_volume_resources(consistency_interval)
コード例 #20
0
    def test_list_credentials_filtered_by_type_and_user_id(self):
        """Call ``GET  /credentials?user_id={user_id}&type={type}``."""
        user1_id = uuid.uuid4().hex
        user2_id = uuid.uuid4().hex

        # Creating credentials for two different users
        credential_user1_ec2 = unit.new_credential_ref(user_id=user1_id,
                                                       type=CRED_TYPE_EC2)
        credential_user1_cert = unit.new_credential_ref(user_id=user1_id)
        credential_user2_cert = unit.new_credential_ref(user_id=user2_id)

        self.credential_api.create_credential(credential_user1_ec2['id'],
                                              credential_user1_ec2)
        self.credential_api.create_credential(credential_user1_cert['id'],
                                              credential_user1_cert)
        self.credential_api.create_credential(credential_user2_cert['id'],
                                              credential_user2_cert)

        r = self.get('/credentials?user_id=%s&type=ec2' % user1_id)
        self.assertValidCredentialListResponse(r, ref=credential_user1_ec2)
        self.assertThat(r.result['credentials'], matchers.HasLength(1))
        cred = r.result['credentials'][0]
        self.assertEqual(CRED_TYPE_EC2, cred['type'])
        self.assertEqual(user1_id, cred['user_id'])
コード例 #21
0
    def test_zabbix_alarm_transform(self):
        LOG.debug('Zabbix alarm transformer test: transform entity event')

        # Test setup
        spec_list = mock_sync.simple_zabbix_alarm_generators(host_num=4,
                                                             events_num=10)
        zabbix_alarms = mock_sync.generate_sequential_events_list(spec_list)

        for alarm in zabbix_alarms:
            # Test action
            self.enrich_event(alarm, format_timestamp=False)
            wrapper = ZabbixTransformer(self.transformers, self.conf)\
                .transform(alarm)
            self._validate_vertex(wrapper.vertex, alarm)

            neighbors = wrapper.neighbors
            self.assertThat(neighbors, matchers.HasLength(1))
            neighbor = neighbors[0]

            # Right now we are support only host as a resource
            if neighbor.vertex[VProps.VITRAGE_TYPE] == NOVA_HOST_DATASOURCE:
                self._validate_host_neighbor(neighbors[0], alarm)

            self._validate_action(alarm, wrapper)
コード例 #22
0
    def _check_opt_names(self, opt_list, expected_opt_names):
        opt_names = [o.name for (g, l) in opt_list for o in l]
        self.assertThat(opt_names, matchers.HasLength(len(expected_opt_names)))

        for opt in opt_names:
            self.assertIn(opt, expected_opt_names)
コード例 #23
0
    def test_get_all_functionality(self):

        # Step 1 - Services with status OK should not be returned
        # Test setup scenario
        zabbix_driver = MockZabbixDriver(self.conf)

        alarm_data1 = self._extract_alarm_data()
        alarm_data2 = self._extract_alarm_data(z_resource_name='compute-2')
        alarm_data3 = self._extract_alarm_data(z_resource_name='compute-2',
                                               triggerid='2')

        zabbix_driver.set_alarm_datas([alarm_data1, alarm_data2, alarm_data3])

        # Test action
        alarms = zabbix_driver._get_all_alarms()

        # Test assertions
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, IsEmpty())

        # Step 2 - one raised alarm
        # Test setup
        alarm_data1 = self._extract_alarm_data(value='1')

        zabbix_driver.set_alarm_datas([alarm_data1, alarm_data2, alarm_data3])

        # Test action
        alarms = zabbix_driver._get_all_alarms()

        # Test assertions
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, matchers.HasLength(1))
        self._assert_contains(alarm_data1, alarms)

        # Step 3 - two raised alarms
        # Test setup
        alarm_data1 = self._extract_alarm_data(value='1', priority='4')
        alarm_data2 = self._extract_alarm_data(z_resource_name='compute-2',
                                               value='1')

        zabbix_driver.set_alarm_datas([alarm_data1, alarm_data2, alarm_data3])

        expected_alarm1 = alarm_data1
        expected_alarm2 = copy.copy(alarm_data2)
        expected_alarm2[ZProps.RESOURCE_NAME] = 'host2'

        # Test action
        alarms = zabbix_driver._get_all_alarms()

        # Test assertions
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, matchers.HasLength(2))
        self._assert_contains(expected_alarm1, alarms)
        self._assert_contains(expected_alarm2, alarms)

        # Step 4 - Check inactive alarms. Get all function should return
        # inactive alarm (alarm that its status has changed to OK)
        # Test setup
        alarm_data1 = self._extract_alarm_data()
        alarm_data2 = self._extract_alarm_data(z_resource_name='compute-2')

        zabbix_driver.set_alarm_datas([alarm_data1, alarm_data2, alarm_data3])

        expected_alarm1 = alarm_data1
        expected_alarm2 = copy.copy(alarm_data2)
        expected_alarm2[ZProps.RESOURCE_NAME] = 'host2'

        # Test action
        alarms = zabbix_driver._get_all_alarms()

        # Test assertions
        # The alarms of alarm_data1/2 should be returned although their
        # status is OK, because they were not OK earlier
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, matchers.HasLength(2))
        self._assert_contains(expected_alarm1, alarms)
        self._assert_contains(expected_alarm2, alarms)

        # Step 4 - get all when all alarms are inactivated and their status
        # was not changed

        # Test action
        alarms = zabbix_driver._get_all_alarms()

        # Test assertions
        self.assertIsNotNone(alarms, 'alarms is None')
        self.assertThat(alarms, IsEmpty())
コード例 #24
0
    def test_get_changes_and_get_all(self):

        # Step 1 - get changes
        # Step setup
        zabbix_driver = MockZabbixDriver(self.conf)

        alarm_data1 = self._extract_alarm_data(priority='2', value='1')
        alarm_data2 = self._extract_alarm_data(z_resource_name='compute-2',
                                               priority='2')
        alarm_data3 = self._extract_alarm_data(z_resource_name='compute-2',
                                               triggerid='2')
        zabbix_driver.set_alarm_datas([alarm_data1, alarm_data2, alarm_data3])

        # Step action
        alarms = zabbix_driver._get_changed_alarms()

        # Step assertions
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, matchers.HasLength(1))
        self._assert_contains(alarm_data1, alarms)

        # Step 2 - get changes when no change occurred (returns nothing)
        # Step action
        alarms = zabbix_driver._get_changed_alarms()

        # Step assertions
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, IsEmpty())

        # Step 3 - get all
        # Step action
        alarms = zabbix_driver._get_all_alarms()

        # Step assertions
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, matchers.HasLength(1))
        self._assert_contains(alarm_data1, alarms)

        # Step 4 - get all for second time
        # (when no change has occurred it returns the same)
        # Step action
        alarms = zabbix_driver._get_all_alarms()

        # Step assertions
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, matchers.HasLength(1))
        self._assert_contains(alarm_data1, alarms)

        # Step 5 - calling get changes right after get all (returns nothing)
        # Step setup
        alarm_data1 = self._extract_alarm_data(priority='4', value='1')
        alarm_data2 = self._extract_alarm_data(z_resource_name='compute-2',
                                               priority='1',
                                               value='1')

        zabbix_driver.set_alarm_datas([alarm_data1, alarm_data2, alarm_data3])

        expected_alarm1 = alarm_data1
        expected_alarm2 = copy.copy(alarm_data2)
        expected_alarm2[ZProps.RESOURCE_NAME] = 'host2'

        # Step action
        get_all_alarms = zabbix_driver._get_all_alarms()
        changed_alarms = zabbix_driver._get_changed_alarms()

        # Step assertions
        self.assertIsNotNone(get_all_alarms, 'No alarms returned')
        self.assertThat(get_all_alarms, matchers.HasLength(2))
        self._assert_contains(expected_alarm1, get_all_alarms)
        self._assert_contains(expected_alarm2, get_all_alarms)

        self.assertIsNotNone(changed_alarms, 'No alarms returned')
        self.assertThat(changed_alarms, IsEmpty())

        # Step 6 - get changes
        # Step setup
        alarm_data2 = self._extract_alarm_data(z_resource_name='compute-2',
                                               priority='4',
                                               value='1')
        alarm_data3 = self._extract_alarm_data(z_resource_name='compute-2',
                                               triggerid='2',
                                               priority='4',
                                               value='1')

        zabbix_driver.set_alarm_datas([alarm_data1, alarm_data2, alarm_data3])

        expected_alarm1 = copy.copy(alarm_data2)
        expected_alarm1[ZProps.RESOURCE_NAME] = 'host2'
        expected_alarm2 = copy.copy(expected_alarm1)
        expected_alarm2[ZProps.TRIGGER_ID] = '2'

        # Step action
        alarms = zabbix_driver._get_changed_alarms()

        # Step assertions
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, matchers.HasLength(2))
        self._assert_contains(expected_alarm1, alarms)
        self._assert_contains(expected_alarm2, alarms)
コード例 #25
0
    def test_get_changes_functionality(self):

        # Step 1 - get changes when all alarms are OK
        # Test setup
        zabbix_driver = MockZabbixDriver(self.conf)

        alarm_data1 = self._extract_alarm_data(priority='2')
        alarm_data2 = self._extract_alarm_data(z_resource_name='compute-2',
                                               priority='2')
        alarm_data3 = self._extract_alarm_data(z_resource_name='compute-2',
                                               description='Uptime',
                                               priority='3')

        zabbix_driver.set_alarm_datas([alarm_data1, alarm_data2, alarm_data3])

        # Test action
        alarms = zabbix_driver._get_changed_alarms()

        # Test assertions
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, IsEmpty())

        # Step 2 - get changes when alarm is raised
        # Test setup
        alarm_data1 = self._extract_alarm_data(priority='2', value='1')

        zabbix_driver.set_alarm_datas([alarm_data1, alarm_data2, alarm_data3])

        # Test action
        alarms = zabbix_driver._get_changed_alarms()

        # Test assertions
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, matchers.HasLength(1))
        self._assert_contains(alarm_data1, alarms)

        # Step 3 - get changes when the priority of inactive alarm is changed
        # Test setup
        alarm_data2 = self._extract_alarm_data(z_resource_name='compute-2',
                                               priority='3')
        zabbix_driver.set_alarm_datas([alarm_data1, alarm_data2, alarm_data3])

        # Test action
        alarms = zabbix_driver._get_changed_alarms()

        # Test assertions
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, IsEmpty())

        # Step 4 - get changes when:
        # 1. alarm1 - priority of active alarm is changed (should be returned)
        # 2. alarm2 - raised alarm (should be returned)
        # 3. alarm3 - priority of inactive alarm is changed (should not
        #             be returned)
        # Test setup
        alarm_data1 = self._extract_alarm_data(priority='4', value='1')
        alarm_data2 = self._extract_alarm_data(z_resource_name='compute-2',
                                               priority='1',
                                               value='1')
        alarm_data3 = self._extract_alarm_data(z_resource_name='compute-2',
                                               triggerid='22222',
                                               priority='1')

        zabbix_driver.set_alarm_datas([alarm_data1, alarm_data2, alarm_data3])

        expected_alarm1 = alarm_data1
        expected_alarm2 = copy.copy(alarm_data2)
        expected_alarm2[ZProps.RESOURCE_NAME] = 'host2'

        # Test action
        alarms = zabbix_driver._get_changed_alarms()

        # Test assertions
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, matchers.HasLength(2))
        self._assert_contains(expected_alarm1, alarms)
        self._assert_contains(expected_alarm2, alarms)

        # Step 5 - get changes when all active alarms are changed to inactive
        # Test setup
        alarm_data1 = self._extract_alarm_data(priority='4')
        alarm_data2 = self._extract_alarm_data(z_resource_name='compute-2',
                                               priority='1')

        zabbix_driver.set_alarm_datas([alarm_data1, alarm_data2, alarm_data3])

        expected_alarm1 = alarm_data1
        expected_alarm2 = copy.copy(alarm_data2)
        expected_alarm2[ZProps.RESOURCE_NAME] = 'host2'

        # Test action
        alarms = zabbix_driver._get_changed_alarms()

        # Test assertions
        self.assertIsNotNone(alarms, 'No alarms returned')
        self.assertThat(alarms, matchers.HasLength(2))
        self._assert_contains(expected_alarm1, alarms)
        self._assert_contains(expected_alarm2, alarms)

        # Step 6 - get changes when no change occurred
        # Action
        alarms = zabbix_driver._get_changed_alarms()

        # Test assertions
        self.assertIsNotNone(alarms, 'alarms is None')
        self.assertThat(alarms, IsEmpty())
コード例 #26
0
 def test_cms_hash_token_sha256(self):
     """Can also hash with sha256."""
     token = self.examples.SIGNED_TOKEN_SCOPED
     token_id = cms.cms_hash_token(token, mode='sha256')
     # sha256 hash is 64 chars.
     self.assertThat(token_id, matchers.HasLength(64))
コード例 #27
0
 def test_no_log_warn(self):
     self.assertThat(list(checks.no_log_warn('LOG.warning("bl")')),
                     IsEmpty())
     self.assertThat(list(checks.no_log_warn('LOG.warn("foo")')),
                     matchers.HasLength(1))
コード例 #28
0
    def _test_collectd_alarm(self, resource_type, resource_name, host_name):
        # Setup
        processor = self._create_processor_with_graph(self.conf)
        self.assertThat(
            processor.entity_graph,
            matchers.HasLength(self._num_total_expected_vertices()))

        time1 = time.time()
        severity1 = 'WARNING'
        link_down_message = 'link state of "qvo818dd156-be" is "DOWN"'
        collectd_event = self._create_collectd_event(time1, resource_type,
                                                     resource_name, host_name,
                                                     severity1,
                                                     link_down_message)

        # Action
        processor.process_event(collectd_event)

        # Test assertions
        self.assertThat(
            processor.entity_graph,
            matchers.HasLength(self._num_total_expected_vertices() + 1))

        collectd_vertices = processor.entity_graph.get_vertices(
            vertex_attr_filter={
                VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
                VProps.VITRAGE_TYPE: COLLECTD_DATASOURCE
            })

        self.assertThat(collectd_vertices, matchers.HasLength(1))
        collectd_vertex1 = collectd_vertices[0]
        self._assert_collectd_vertex_equals(collectd_vertex1, time1,
                                            resource_type, resource_name,
                                            severity1)

        collectd_neighbors = processor.entity_graph.neighbors(
            collectd_vertices[0].vertex_id)

        self._assert_collectd_neighbor_equals(collectd_neighbors,
                                              resource_type, resource_name)

        # Action 2 - update the existing alarm
        time2 = time.time()
        severity2 = 'ERROR'
        collectd_event = self._create_collectd_event(time2, resource_type,
                                                     resource_name, host_name,
                                                     severity2,
                                                     link_down_message)

        processor.process_event(collectd_event)

        # Test assertions - the collectd alarm vertex should be the same
        self.assertThat(
            processor.entity_graph,
            matchers.HasLength(self._num_total_expected_vertices() + 1))

        collectd_vertices = processor.entity_graph.get_vertices(
            vertex_attr_filter={
                VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
                VProps.VITRAGE_TYPE: COLLECTD_DATASOURCE
            })

        self.assertThat(collectd_vertices, matchers.HasLength(1))
        collectd_vertex2 = collectd_vertices[0]
        self.assertEqual(collectd_vertex1[VProps.VITRAGE_ID],
                         collectd_vertex2[VProps.VITRAGE_ID])

        # Action 3 - clear the alarm
        time3 = time.time()
        severity3 = 'OK'
        link_up_message = 'link state of "qvo818dd156-be" is "UP"'
        collectd_event = self._create_collectd_event(time3, resource_type,
                                                     resource_name, host_name,
                                                     severity3,
                                                     link_up_message)

        processor.process_event(collectd_event)

        # Test assertions - the collectd alarm vertex should be removed
        collectd_vertices = processor.entity_graph.get_vertices(
            vertex_attr_filter={
                VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
                VProps.VITRAGE_TYPE: COLLECTD_DATASOURCE
            })

        self._assert_no_vertex(collectd_vertices)
コード例 #29
0
 def test_drivers_no_active_conductor(self):
     data = self.get_json('/drivers')
     self.assertThat(data['drivers'], matchers.HasLength(0))
     self.assertEqual([], data['drivers'])
コード例 #30
0
    def _validate_policygroup(self, topology, pg_name=None, vport_num=1):
        if topology.normal_port is not None or self.is_dhcp_agent_present():
            expected_pgs = 2  # Expecting software + hardware
        else:
            expected_pgs = 1  # Expecting only hardware

        if not Topology.has_unified_pg_for_all_support():
            if self.is_dhcp_agent_present():
                expected_pgs += 1  # Extra PG for dhcp agent

                # Repeated check in case of agent
                for attempt in range(Topology.nbr_retries_for_test_robustness):
                    if len(topology.get_vsd_policygroups(
                            True)) == expected_pgs:
                        break
                    else:
                        LOG.error("Unexpected amount of PGs found, "
                                  "expected {} found {} "
                                  "(attempt {})".format(
                                      expected_pgs,
                                      len(topology.vsd_policygroups),
                                      attempt + 1))
                        time.sleep(1)

        self.assertThat(topology.get_vsd_policygroups(True),
                        matchers.HasLength(expected_pgs),
                        message="Unexpected amount of PGs found")
        for pg in topology.vsd_policygroups:
            if pg['type'] == 'HARDWARE':
                vsd_policygroup = pg
                break
        else:
            self.fail("Could not find HARDWARE policy group.")
        self.assertThat(vsd_policygroup['type'], matchers.Equals('HARDWARE'))
        if Topology.has_unified_pg_for_all_support():
            if pg_name:
                self.assertEqual(pg_name, vsd_policygroup['name'])
                self.assertEqual(pg_name, vsd_policygroup['description'])
                self.assertEqual(
                    "hw:" + (ExternalId(
                        constants.NUAGE_PLCY_GRP_ALLOW_ALL).at_cms_id()),
                    vsd_policygroup['externalID'])
            else:
                self.assertEqual(topology.security_group['id'] + "_HARDWARE",
                                 vsd_policygroup['name'])
                self.assertEqual(topology.security_group['name'],
                                 vsd_policygroup['description'])
                self.assertEqual(
                    "hw:" +
                    (ExternalId(topology.security_group['id']).at_cms_id()),
                    vsd_policygroup['externalID'])

            vsd_pg_vports = self.vsd_client.get_vport(constants.POLICYGROUP,
                                                      vsd_policygroup['ID'])
            self.assertThat(vsd_pg_vports,
                            matchers.HasLength(vport_num),
                            message="Expected to find exactly {} "
                            "vport in PG".format(vport_num))
            for vsd_pg_vport in vsd_pg_vports:
                if vsd_pg_vport['ID'] == topology.vsd_baremetal_vport['ID']:
                    break
            else:
                self.fail("Vport should be part of HARDWARE PG")
        else:
            if pg_name:
                self.assertThat(vsd_policygroup['name'],
                                matchers.Contains(pg_name))

            vsd_pg_vports = self.vsd_client.get_vport(constants.POLICYGROUP,
                                                      vsd_policygroup['ID'])
            self.assertThat(vsd_pg_vports,
                            matchers.HasLength(1),
                            message="Expected to find exactly 1 vport in PG")
            self.assertThat(vsd_pg_vports[0]['ID'],
                            matchers.Equals(
                                topology.vsd_baremetal_vport['ID']),
                            message="Vport should be part of HARDWARE PG")