def test_collect_all_nostore(self): (changed_keys, content) = self._call_collect_all(store=False) self.assertEqual(set(), changed_keys) self.assertThat(content, matchers.IsInstance(dict)) for collector in cfg.CONF.collectors: self.assertIn(collector, content) self.assertThat(content[collector], matchers.IsInstance(dict))
def test_collect_local_orders_multiple(self): self._setup_test_json(META_DATA, '00test.json') self._setup_test_json(META_DATA2, '99test.json') # Monkey Patch os.listdir so it _always_ returns the wrong sort unpatched_listdir = os.listdir def wrong_sort_listdir(path): ret = unpatched_listdir(path) save_locale = locale.getdefaultlocale() locale.setlocale(locale.LC_ALL, 'C') bad_sort = sorted(ret, reverse=True) locale.setlocale(locale.LC_ALL, save_locale) return bad_sort self.useFixture(fixtures.MonkeyPatch('os.listdir', wrong_sort_listdir)) local_md = self._call_collect() self.assertThat(local_md, matchers.IsInstance(list)) self.assertEqual(2, len(local_md)) self.assertThat(local_md[0], matchers.IsInstance(tuple)) self.assertEqual('00test.json', local_md[0][0]) md1 = local_md[0][1] self.assertEqual(META_DATA, md1) self.assertEqual('99test.json', local_md[1][0]) md2 = local_md[1][1] self.assertEqual(META_DATA2, md2)
def test_setup_logging_logfile(self): self.CONF.set_override('console_output_enabled', False) del logging.getLogger().handlers[:] service._setup_logging() for hndler in logging.getLogger().handlers: self.assertThat( hndler, matchers.MatchesAny( matchers.IsInstance(logging.handlers.RotatingFileHandler), matchers.IsInstance(logging.NullHandler)))
def test_setup_logging_console(self): self.CONF.set_override('logfile', None) del logging.getLogger().handlers[:] service._setup_logging() for hndler in logging.getLogger().handlers: self.assertThat( hndler, matchers.MatchesAny( matchers.IsInstance(logging.StreamHandler), matchers.IsInstance(logging.NullHandler)))
def test_collect_local_path_nonexist(self): cfg.CONF.set_override(name='path', override=['/this/doesnt/exist'], group='local') local_md = self._call_collect() self.assertThat(local_md, matchers.IsInstance(list)) self.assertEqual(0, len(local_md))
def test_setup_logging(self): del logging.getLogger().handlers[:] service._setup_logging() self.assertEqual(logging.getLogger().getEffectiveLevel(), logging.INFO) self.assertEqual( logging.getLogger('tvdbapi_client').getEffectiveLevel(), logging.WARNING) for hndler in logging.getLogger().handlers: self.assertThat( hndler, matchers.MatchesAny( matchers.IsInstance(logging.handlers.RotatingFileHandler), matchers.IsInstance(logging.StreamHandler), matchers.IsInstance(logging.NullHandler)))
def test_get_functions(self): def f(): pass def f_(): pass def f__(): pass def g(): pass context = contexts.Context() context2 = context.create_child_context() context.register_function(f) context.register_function(f_) context.register_function(g, exclusive=True) context2.register_function(f__) functions, is_exclusive = context.get_functions('f') self.assertFalse(is_exclusive) self.assertIsInstance(functions, set) self.assertThat(functions, testtools.matchers.HasLength(2)) self.assertThat( functions, matchers.AllMatch(matchers.IsInstance(specs.FunctionDefinition))) functions, is_exclusive = context2.get_functions('g') self.assertFalse(is_exclusive) functions, is_exclusive = context2.get_functions('f') self.assertFalse(is_exclusive) self.assertThat(functions, testtools.matchers.HasLength(1))
def test_main_no_command(self): fake_args = [ 'os-collect-config', '--config-file', '/dev/null', '--cfn-metadata-url', 'http://192.0.2.1:8000/v1/', '--cfn-stack-name', 'foo', '--cfn-path', 'foo.Metadata', '--cfn-access-key-id', '0123456789ABCDEF', '--cfn-secret-access-key', 'FEDCBA9876543210', ] fake_metadata = _setup_heat_local_metadata(self) fake_args.append('--heat_local-path') fake_args.append(fake_metadata) output = self.useFixture(fixtures.StringStream('stdout')) self.useFixture(fixtures.MonkeyPatch('sys.stdout', output.stream)) self._call_main(fake_args) out_struct = json.loads(output.getDetails()['stdout'].as_text()) self.assertThat(out_struct, matchers.IsInstance(dict)) self.assertIn('ec2', out_struct) self.assertIn('cfn', out_struct)
def test_single_fail(self): """ A single incoming message with a single file path. """ sut = MetadataExtractor('exiftool', ('-some', '-arg')) error = RuntimeError('boom!') sut.peer = Mock(spec=ExiftoolProtocol) sut.peer.execute.return_value = defer.fail(error) insert = { 'inserts': ['a'], 'deletes': [], 'data': { 'a': { 'path': '/path/to/file.jpg', } } } send = Mock(spec=Scheduler.send) result = sut(insert, send) self.assertEquals(send.call_count, 0) sut.peer.execute.assert_called_once_with( b'-some', b'-arg', b'-j', b'-charset', b'exiftool=UTF-8', b'-charset', b'filename=UTF-8', b'/path/to/file.jpg') failure_matcher = matchers.AfterPreprocessing( lambda f: f.value, matchers.IsInstance(MetadataExtractorError)) assert_that(result, twistedsupport.failed(failure_matcher))
def test_collect_local(self): self._setup_test_json(META_DATA) local_md = self._call_collect() self.assertThat(local_md, matchers.IsInstance(list)) self.assertEqual(1, len(local_md)) self.assertThat(local_md[0], matchers.IsInstance(tuple)) self.assertEqual(2, len(local_md[0])) self.assertEqual('test.json', local_md[0][0]) only_md = local_md[0][1] self.assertThat(only_md, matchers.IsInstance(dict)) for k in ('localstrA', 'localint9', 'localmap_xy'): self.assertIn(k, only_md) self.assertEqual(only_md[k], META_DATA[k]) self.assertEqual('', self.log.output)
def _validate_object(self, obj): for attr in BASE_EXPECTED_FIELDS: if attr.endswith('_at'): self.assertThat( obj[attr], matchers.MatchesAny(matchers.Is(None), matchers.IsInstance(str))) else: self.assertIsInstance(obj[attr], bool)
def test_collect_cfn_sub_path(self): cfg.CONF.cfn.path = ['foo.Metadata.map_ab'] cfn_collect = cfn.Collector(requests_impl=FakeRequests(self)) content = cfn_collect.collect() self.assertThat(content, matchers.IsInstance(list)) self.assertEqual('cfn', content[0][0]) content = content[0][1] self.assertIn(u'b', content) self.assertEqual(u'banana', content[u'b'])
def test_collect_all_ec2_unavailable(self): collector_kwargs_map = { 'ec2': {'requests_impl': test_ec2.FakeFailRequests}, 'cfn': {'requests_impl': test_cfn.FakeRequests(self)} } (changed_keys, content) = self._call_collect_all( store=False, collector_kwargs_map=collector_kwargs_map) self.assertEqual(set(), changed_keys) self.assertThat(content, matchers.IsInstance(dict)) self.assertNotIn('ec2', content)
def assertNotIsInstance(self, obj, cls, msg=None): """Python < v2.7 compatibility. Assert 'not isinstance(obj, cls).""" try: f = super(_BaseTestCase, self).assertNotIsInstance except AttributeError: self.assertThat(obj, matchers.Not(matchers.IsInstance(cls)), message=msg or '') else: f(obj, cls, msg=msg)
def test_collect_all_store_alt_order(self): # Ensure different than default new_list = list(reversed(cfg.CONF.collectors)) (changed_keys, paths) = self._call_collect_all( store=True, collectors=new_list) self.assertEqual(set(cfg.CONF.collectors), changed_keys) self.assertThat(paths, matchers.IsInstance(list)) expected_paths = [ os.path.join(self.cache_dir.path, '%s.json' % collector) for collector in new_list] self.assertEqual(expected_paths, paths)
def match(self, matchee): checks = [] checks.append(matchers.IsInstance(MultiCheck)) checks.append( matchers.AfterPreprocessing(operator.attrgetter('strategy'), matchers.Is(self.strategy))) checks.append( matchers.AfterPreprocessing( operator.attrgetter('subchecks'), matchers.MatchesListwise(self.subchecks))) return matchers.MatchesAll(*checks).match(matchee)
def test_collect_cfn_software_config(self): cfn_md = cfn.Collector( requests_impl=FakeRequestsSoftwareConfig(self)).collect() self.assertThat(cfn_md, matchers.IsInstance(list)) self.assertEqual('cfn', cfn_md[0][0]) cfn_config = cfn_md[0][1] self.assertThat(cfn_config, matchers.IsInstance(dict)) self.assertEqual(set(['old-style', 'deployments']), set(cfn_config.keys())) self.assertIn('deployments', cfn_config) self.assertThat(cfn_config['deployments'], matchers.IsInstance(list)) self.assertEqual(4, len(cfn_config['deployments'])) deployment = cfn_config['deployments'][0] self.assertIn('inputs', deployment) self.assertThat(deployment['inputs'], matchers.IsInstance(list)) self.assertEqual(1, len(deployment['inputs'])) self.assertEqual('dep-name1', cfn_md[1][0]) self.assertEqual('value1', cfn_md[1][1]['config1']) self.assertEqual('dep-name2', cfn_md[2][0]) self.assertEqual('value2', cfn_md[2][1]['config2'])
def test_collect_cfn(self): cfn_md = cfn.Collector(requests_impl=FakeRequests(self)).collect() self.assertThat(cfn_md, matchers.IsInstance(list)) self.assertEqual('cfn', cfn_md[0][0]) cfn_md = cfn_md[0][1] for k in ('int1', 'strfoo', 'map_ab'): self.assertIn(k, cfn_md) self.assertEqual(cfn_md[k], META_DATA[k]) self.assertEqual('', self.log.output)
def test_collect_heat(self): heat_md = heat.Collector( keystoneclient=FakeKeystoneClient(self), heatclient=FakeHeatClientSoftwareConfig(self), discover_class=FakeKeystoneDiscover).collect() self.assertThat(heat_md, matchers.IsInstance(list)) self.assertEqual(2, len(heat_md)) self.assertEqual('heat', heat_md[0][0]) self.assertEqual(SOFTWARE_CONFIG_DATA['deployments'], heat_md[0][1]['deployments']) self.assertEqual(('dep-name1', {'config1': 'value1'}), heat_md[1])
def _test_collect_all_store(self, collector_kwargs_map=None, expected_changed=None): (changed_keys, paths) = self._call_collect_all( store=True, collector_kwargs_map=collector_kwargs_map) if expected_changed is None: expected_changed = set(['heat_local', 'cfn', 'ec2', 'heat', 'local', 'request', 'zaqar']) self.assertEqual(expected_changed, changed_keys) self.assertThat(paths, matchers.IsInstance(list)) for path in paths: self.assertTrue(os.path.exists(path)) self.assertTrue(os.path.exists('%s.orig' % path))
def test_collect_heat(self, mock_url_for, mock___init__): mock___init__.return_value = None mock_url_for.return_value = cfg.CONF.heat.auth_url heat_md = heat.Collector( keystoneclient=FakeKeystoneClient(self), heatclient=FakeHeatClientSoftwareConfig(self)).collect() self.assertThat(heat_md, matchers.IsInstance(list)) self.assertEqual(2, len(heat_md)) self.assertEqual('heat', heat_md[0][0]) self.assertEqual(SOFTWARE_CONFIG_DATA['deployments'], heat_md[0][1]['deployments']) self.assertEqual(('dep-name1', {'config1': 'value1'}), heat_md[1])
def test_collect_heat_local_twice(self): with tempfile.NamedTemporaryFile() as md: md.write(json.dumps(META_DATA).encode('utf-8')) md.flush() local_md = self._call_collect(md.name, md.name) self.assertThat(local_md, matchers.IsInstance(dict)) for k in ('localstrA', 'localint9', 'localmap_xy'): self.assertIn(k, local_md) self.assertEqual(local_md[k], META_DATA[k]) self.assertEqual('', self.log.output)
def test_collect_zaqar(self, mock_url_for, mock___init__): mock___init__.return_value = None mock_url_for.return_value = cfg.CONF.zaqar.auth_url zaqar_md = zaqar.Collector( keystoneclient=FakeKeystoneClient(self, cfg.CONF.zaqar), zaqarclient=FakeZaqarClient(self)).collect() self.assertThat(zaqar_md, matchers.IsInstance(list)) self.assertEqual('zaqar', zaqar_md[0][0]) zaqar_md = zaqar_md[0][1] for k in ('int1', 'strfoo', 'map_ab'): self.assertIn(k, zaqar_md) self.assertEqual(zaqar_md[k], test_heat.META_DATA[k])
def test_collect_request(self): req_collect = request.Collector(requests_impl=FakeRequests) self.assertIsNone(req_collect.last_modified) req_md = req_collect.collect() self.assertIsNotNone(req_collect.last_modified) self.assertThat(req_md, matchers.IsInstance(list)) self.assertEqual('request', req_md[0][0]) req_md = req_md[0][1] for k in ('int1', 'strfoo', 'map_ab'): self.assertIn(k, req_md) self.assertEqual(req_md[k], META_DATA[k]) self.assertEqual('', self.log.output)
def test_empty_account(self): """ this is an account with no containers and no objects """ # setup expectation with SwiftClientStub() as swift_stub: swift_stub.with_account('123223') # interact conn = swiftclient.client.Connection() account_info = conn.get_account() self.assertThat(account_info, matchers.Not(matchers.Is(None))) self.assertThat(len(account_info), matchers.Is(2)) self.assertThat(account_info, matchers.IsInstance(tuple)) self.assertThat(account_info[0], matchers.IsInstance(dict)) self.assertThat( account_info[0], matchers.KeysEqual('content-length', 'accept-ranges', 'x-timestamp', 'x-trans-id', 'date', 'x-account-bytes-used', 'x-account-container-count', 'content-type', 'x-account-object-count')) self.assertThat(account_info[1], matchers.IsInstance(list)) self.assertThat(len(account_info[1]), matchers.Is(0))
def test_collect_gcore(self): gcore_md = gcore.Collector(client=self.client).collect() self.assertThat(gcore_md, matchers.IsInstance(list)) self.assertEqual('gcore', gcore_md[0][0]) gcore_md = gcore_md[0][1] for k in ('int1', 'strfoo', 'map_ab'): self.assertIn(k, gcore_md) self.assertEqual(gcore_md[k], META_DATA[k]) # level setting for urllib3.connectionpool. self.assertTrue(self.log.output == '' or self.log.output == 'Starting new HTTP connection (1): 192.0.2.1\n')
def test_collect_zaqar_deployments(self, mock_url_for, mock___init__): mock___init__.return_value = None mock_url_for.return_value = cfg.CONF.zaqar.auth_url zaqar_md = zaqar.Collector( keystoneclient=FakeKeystoneClient(self, cfg.CONF.zaqar), zaqarclient=FakeZaqarClientSoftwareConfig(self), discover_class=test_heat.FakeKeystoneDiscover).collect() self.assertThat(zaqar_md, matchers.IsInstance(list)) self.assertEqual('zaqar', zaqar_md[0][0]) self.assertEqual(2, len(zaqar_md)) self.assertEqual('zaqar', zaqar_md[0][0]) self.assertEqual(test_heat.SOFTWARE_CONFIG_DATA['deployments'], zaqar_md[0][1]['deployments']) self.assertEqual(('dep-name1', {'config1': 'value1'}), zaqar_md[1])
def test_collect_heat(self, mock_url_for, mock___init__): mock___init__.return_value = None mock_url_for.return_value = cfg.CONF.heat.auth_url heat_md = heat.Collector(keystoneclient=FakeKeystoneClient(self), heatclient=FakeHeatClient(self)).collect() self.assertThat(heat_md, matchers.IsInstance(list)) self.assertEqual('heat', heat_md[0][0]) heat_md = heat_md[0][1] for k in ('int1', 'strfoo', 'map_ab'): self.assertIn(k, heat_md) self.assertEqual(heat_md[k], META_DATA[k]) # FIXME(yanyanhu): Temporary hack to deal with possible log # level setting for urllib3.connectionpool. self.assertTrue(self.log.output == '' or self.log.output == 'Starting new HTTP connection (1): 127.0.0.1\n')
def test_collect_heat(self): heat_md = heat.Collector( keystoneclient=FakeKeystoneClient(self), heatclient=FakeHeatClient(self), discover_class=FakeKeystoneDiscover).collect() self.assertThat(heat_md, matchers.IsInstance(list)) self.assertEqual('heat', heat_md[0][0]) heat_md = heat_md[0][1] for k in ('int1', 'strfoo', 'map_ab'): self.assertIn(k, heat_md) self.assertEqual(heat_md[k], META_DATA[k]) # FIXME(yanyanhu): Temporary hack to deal with possible log # level setting for urllib3.connectionpool. self.assertTrue(self.log.output == '' or self.log.output == 'Starting new HTTP connection (1): 192.0.2.1\n')
def test_collect_zaqar_websocket_recv(self, mock_url_for, mock___init__, mock_transport): mock___init__.return_value = None mock_url_for.return_value = cfg.CONF.zaqar.auth_url ws = FakeZaqarWebsocketClient({}, messages={}, testcase=self) mock_transport.return_value = ws conf = config_fixture.Config() self.useFixture(conf) conf.config(group='zaqar', use_websockets=True) zaqar_md = zaqar.Collector(keystoneclient=FakeKeystoneClientWebsocket( self, cfg.CONF.zaqar), ).collect() self.assertThat(zaqar_md, matchers.IsInstance(list)) self.assertEqual('zaqar', zaqar_md[0][0]) zaqar_md = zaqar_md[0][1] for k in ('int1', 'strfoo', 'map_ab'): self.assertIn(k, zaqar_md) self.assertEqual(zaqar_md[k], test_heat.META_DATA[k])