RedHatTraining/pyramid.git

Michael Merickel

2018-10-15 0c29cf2df41600d3906d521c72991c7686018b71

commit \| author \| age
407b33	1	import os.path
6da017	2	import unittest
CM	3	from pyramid.testing import cleanUp
407b33	4
MM	5	# we use this folder
	6	here = os.path.dirname(os.path.abspath(__file__))
6da017	7
0c29cf	8
9ee830	9	class TestAssetsConfiguratorMixin(unittest.TestCase):
CM	10	def _makeOne(self, arg, *kw):
	11	from pyramid.config import Configurator
0c29cf	12
9ee830	13	config = Configurator(arg, *kw)
CM	14	return config
	15
	16	def test_override_asset_samename(self):
	17	from pyramid.exceptions import ConfigurationError
0c29cf	18
9ee830	19	config = self._makeOne()
407b33	20	self.assertRaises(ConfigurationError, config.override_asset, 'a', 'a')
9ee830	21
CM	22	def test_override_asset_directory_with_file(self):
	23	from pyramid.exceptions import ConfigurationError
0c29cf	24
9ee830	25	config = self._makeOne()
0c29cf	26	self.assertRaises(
MM	27	ConfigurationError,
	28	config.override_asset,
	29	'a:foo/',
	30	'tests.test_config.pkgs.asset:foo.pt',
	31	)
9ee830	32
CM	33	def test_override_asset_file_with_directory(self):
	34	from pyramid.exceptions import ConfigurationError
0c29cf	35
9ee830	36	config = self._makeOne()
0c29cf	37	self.assertRaises(
MM	38	ConfigurationError,
	39	config.override_asset,
	40	'a:foo.pt',
	41	'tests.test_config.pkgs.asset:templates/',
	42	)
9ee830	43
CM	44	def test_override_asset_file_with_package(self):
	45	from pyramid.exceptions import ConfigurationError
0c29cf	46
9ee830	47	config = self._makeOne()
0c29cf	48	self.assertRaises(
MM	49	ConfigurationError,
	50	config.override_asset,
	51	'a:foo.pt',
	52	'tests.test_config.pkgs.asset',
	53	)
9ee830	54
CM	55	def test_override_asset_file_with_file(self):
407b33	56	from pyramid.config.assets import PackageAssetSource
0c29cf	57
9ee830	58	config = self._makeOne(autocommit=True)
CM	59	override = DummyUnderOverride()
	60	config.override_asset(
dd3cc8	61	'tests.test_config.pkgs.asset:templates/foo.pt',
MM	62	'tests.test_config.pkgs.asset.subpackage:templates/bar.pt',
0c29cf	63	_override=override,
MM	64	)
dd3cc8	65	from tests.test_config.pkgs import asset
MM	66	from tests.test_config.pkgs.asset import subpackage
0c29cf	67
9ee830	68	self.assertEqual(override.package, asset)
CM	69	self.assertEqual(override.path, 'templates/foo.pt')
407b33	70	source = override.source
MM	71	self.assertTrue(isinstance(source, PackageAssetSource))
	72	self.assertEqual(source.package, subpackage)
	73	self.assertEqual(source.prefix, 'templates/bar.pt')
9ee830	74
5ace65	75	resource_name = ''
0c29cf	76	expected = os.path.join(
MM	77	here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
	78	)
	79	self.assertEqual(override.source.get_filename(resource_name), expected)
5ace65	80
9ee830	81	def test_override_asset_package_with_package(self):
407b33	82	from pyramid.config.assets import PackageAssetSource
0c29cf	83
9ee830	84	config = self._makeOne(autocommit=True)
CM	85	override = DummyUnderOverride()
	86	config.override_asset(
dd3cc8	87	'tests.test_config.pkgs.asset',
MM	88	'tests.test_config.pkgs.asset.subpackage',
0c29cf	89	_override=override,
MM	90	)
dd3cc8	91	from tests.test_config.pkgs import asset
MM	92	from tests.test_config.pkgs.asset import subpackage
0c29cf	93
9ee830	94	self.assertEqual(override.package, asset)
CM	95	self.assertEqual(override.path, '')
407b33	96	source = override.source
MM	97	self.assertTrue(isinstance(source, PackageAssetSource))
	98	self.assertEqual(source.package, subpackage)
	99	self.assertEqual(source.prefix, '')
5ace65	100
MA	101	resource_name = 'templates/bar.pt'
0c29cf	102	expected = os.path.join(
MM	103	here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
	104	)
	105	self.assertEqual(override.source.get_filename(resource_name), expected)
9ee830	106
CM	107	def test_override_asset_directory_with_directory(self):
407b33	108	from pyramid.config.assets import PackageAssetSource
0c29cf	109
9ee830	110	config = self._makeOne(autocommit=True)
CM	111	override = DummyUnderOverride()
	112	config.override_asset(
dd3cc8	113	'tests.test_config.pkgs.asset:templates/',
MM	114	'tests.test_config.pkgs.asset.subpackage:templates/',
0c29cf	115	_override=override,
MM	116	)
dd3cc8	117	from tests.test_config.pkgs import asset
MM	118	from tests.test_config.pkgs.asset import subpackage
0c29cf	119
9ee830	120	self.assertEqual(override.package, asset)
CM	121	self.assertEqual(override.path, 'templates/')
407b33	122	source = override.source
MM	123	self.assertTrue(isinstance(source, PackageAssetSource))
	124	self.assertEqual(source.package, subpackage)
	125	self.assertEqual(source.prefix, 'templates/')
9ee830	126
5ace65	127	resource_name = 'bar.pt'
0c29cf	128	expected = os.path.join(
MM	129	here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
	130	)
	131	self.assertEqual(override.source.get_filename(resource_name), expected)
5ace65	132
9ee830	133	def test_override_asset_directory_with_package(self):
407b33	134	from pyramid.config.assets import PackageAssetSource
0c29cf	135
9ee830	136	config = self._makeOne(autocommit=True)
CM	137	override = DummyUnderOverride()
	138	config.override_asset(
dd3cc8	139	'tests.test_config.pkgs.asset:templates/',
MM	140	'tests.test_config.pkgs.asset.subpackage',
0c29cf	141	_override=override,
MM	142	)
dd3cc8	143	from tests.test_config.pkgs import asset
MM	144	from tests.test_config.pkgs.asset import subpackage
0c29cf	145
9ee830	146	self.assertEqual(override.package, asset)
CM	147	self.assertEqual(override.path, 'templates/')
407b33	148	source = override.source
MM	149	self.assertTrue(isinstance(source, PackageAssetSource))
	150	self.assertEqual(source.package, subpackage)
	151	self.assertEqual(source.prefix, '')
9ee830	152
5ace65	153	resource_name = 'templates/bar.pt'
0c29cf	154	expected = os.path.join(
MM	155	here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
	156	)
	157	self.assertEqual(override.source.get_filename(resource_name), expected)
5ace65	158
9ee830	159	def test_override_asset_package_with_directory(self):
407b33	160	from pyramid.config.assets import PackageAssetSource
0c29cf	161
9ee830	162	config = self._makeOne(autocommit=True)
CM	163	override = DummyUnderOverride()
	164	config.override_asset(
dd3cc8	165	'tests.test_config.pkgs.asset',
MM	166	'tests.test_config.pkgs.asset.subpackage:templates/',
0c29cf	167	_override=override,
MM	168	)
dd3cc8	169	from tests.test_config.pkgs import asset
MM	170	from tests.test_config.pkgs.asset import subpackage
0c29cf	171
9ee830	172	self.assertEqual(override.package, asset)
CM	173	self.assertEqual(override.path, '')
407b33	174	source = override.source
MM	175	self.assertTrue(isinstance(source, PackageAssetSource))
	176	self.assertEqual(source.package, subpackage)
	177	self.assertEqual(source.prefix, 'templates/')
5ace65	178
MA	179	resource_name = 'bar.pt'
0c29cf	180	expected = os.path.join(
MM	181	here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
	182	)
	183	self.assertEqual(override.source.get_filename(resource_name), expected)
407b33	184
MM	185	def test_override_asset_directory_with_absfile(self):
	186	from pyramid.exceptions import ConfigurationError
0c29cf	187
407b33	188	config = self._makeOne()
0c29cf	189	self.assertRaises(
MM	190	ConfigurationError,
	191	config.override_asset,
	192	'a:foo/',
	193	os.path.join(here, 'pkgs', 'asset', 'foo.pt'),
	194	)
407b33	195
MM	196	def test_override_asset_file_with_absdirectory(self):
	197	from pyramid.exceptions import ConfigurationError
0c29cf	198
407b33	199	config = self._makeOne()
0c29cf	200	abspath = os.path.join(
MM	201	here, 'pkgs', 'asset', 'subpackage', 'templates'
	202	)
	203	self.assertRaises(
	204	ConfigurationError, config.override_asset, 'a:foo.pt', abspath
	205	)
407b33	206
MM	207	def test_override_asset_file_with_missing_abspath(self):
	208	from pyramid.exceptions import ConfigurationError
0c29cf	209
407b33	210	config = self._makeOne()
0c29cf	211	self.assertRaises(
MM	212	ConfigurationError,
	213	config.override_asset,
	214	'a:foo.pt',
	215	os.path.join(here, 'wont_exist'),
	216	)
407b33	217
MM	218	def test_override_asset_file_with_absfile(self):
	219	from pyramid.config.assets import FSAssetSource
0c29cf	220
407b33	221	config = self._makeOne(autocommit=True)
MM	222	override = DummyUnderOverride()
0c29cf	223	abspath = os.path.join(
MM	224	here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
	225	)
407b33	226	config.override_asset(
dd3cc8	227	'tests.test_config.pkgs.asset:templates/foo.pt',
407b33	228	abspath,
0c29cf	229	_override=override,
MM	230	)
dd3cc8	231	from tests.test_config.pkgs import asset
0c29cf	232
407b33	233	self.assertEqual(override.package, asset)
MM	234	self.assertEqual(override.path, 'templates/foo.pt')
	235	source = override.source
	236	self.assertTrue(isinstance(source, FSAssetSource))
	237	self.assertEqual(source.prefix, abspath)
	238
5ace65	239	resource_name = ''
0c29cf	240	expected = os.path.join(
MM	241	here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
	242	)
	243	self.assertEqual(override.source.get_filename(resource_name), expected)
5ace65	244
407b33	245	def test_override_asset_directory_with_absdirectory(self):
MM	246	from pyramid.config.assets import FSAssetSource
0c29cf	247
407b33	248	config = self._makeOne(autocommit=True)
MM	249	override = DummyUnderOverride()
0c29cf	250	abspath = os.path.join(
MM	251	here, 'pkgs', 'asset', 'subpackage', 'templates'
	252	)
407b33	253	config.override_asset(
dd3cc8	254	'tests.test_config.pkgs.asset:templates/',
407b33	255	abspath,
0c29cf	256	_override=override,
MM	257	)
dd3cc8	258	from tests.test_config.pkgs import asset
0c29cf	259
407b33	260	self.assertEqual(override.package, asset)
MM	261	self.assertEqual(override.path, 'templates/')
	262	source = override.source
	263	self.assertTrue(isinstance(source, FSAssetSource))
	264	self.assertEqual(source.prefix, abspath)
	265
5ace65	266	resource_name = 'bar.pt'
0c29cf	267	expected = os.path.join(
MM	268	here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
	269	)
	270	self.assertEqual(override.source.get_filename(resource_name), expected)
5ace65	271
407b33	272	def test_override_asset_package_with_absdirectory(self):
MM	273	from pyramid.config.assets import FSAssetSource
0c29cf	274
407b33	275	config = self._makeOne(autocommit=True)
MM	276	override = DummyUnderOverride()
0c29cf	277	abspath = os.path.join(
MM	278	here, 'pkgs', 'asset', 'subpackage', 'templates'
	279	)
407b33	280	config.override_asset(
0c29cf	281	'tests.test_config.pkgs.asset', abspath, _override=override
MM	282	)
dd3cc8	283	from tests.test_config.pkgs import asset
0c29cf	284
407b33	285	self.assertEqual(override.package, asset)
MM	286	self.assertEqual(override.path, '')
	287	source = override.source
	288	self.assertTrue(isinstance(source, FSAssetSource))
	289	self.assertEqual(source.prefix, abspath)
9ee830	290
5ace65	291	resource_name = 'bar.pt'
0c29cf	292	expected = os.path.join(
MM	293	here, 'pkgs', 'asset', 'subpackage', 'templates', 'bar.pt'
	294	)
	295	self.assertEqual(override.source.get_filename(resource_name), expected)
5ace65	296
2deac8	297	def test__override_not_yet_registered(self):
CM	298	from pyramid.interfaces import IPackageOverrides
0c29cf	299
2deac8	300	package = DummyPackage('package')
407b33	301	source = DummyAssetSource()
2deac8	302	config = self._makeOne()
0c29cf	303	config._override(
MM	304	package, 'path', source, PackageOverrides=DummyPackageOverrides
	305	)
	306	overrides = config.registry.queryUtility(
	307	IPackageOverrides, name='package'
	308	)
407b33	309	self.assertEqual(overrides.inserted, [('path', source)])
2deac8	310	self.assertEqual(overrides.package, package)
CM	311
	312	def test__override_already_registered(self):
	313	from pyramid.interfaces import IPackageOverrides
0c29cf	314
2deac8	315	package = DummyPackage('package')
407b33	316	source = DummyAssetSource()
2deac8	317	overrides = DummyPackageOverrides(package)
CM	318	config = self._makeOne()
0c29cf	319	config.registry.registerUtility(
MM	320	overrides, IPackageOverrides, name='package'
	321	)
	322	config._override(
	323	package, 'path', source, PackageOverrides=DummyPackageOverrides
	324	)
407b33	325	self.assertEqual(overrides.inserted, [('path', source)])
2deac8	326	self.assertEqual(overrides.package, package)
CM	327
	328
6da017	329	class TestOverrideProvider(unittest.TestCase):
CM	330	def setUp(self):
	331	cleanUp()
	332
	333	def tearDown(self):
	334	cleanUp()
	335
	336	def _getTargetClass(self):
	337	from pyramid.config.assets import OverrideProvider
0c29cf	338
6da017	339	return OverrideProvider
CM	340
	341	def _makeOne(self, module):
	342	klass = self._getTargetClass()
	343	return klass(module)
	344
dd3cc8	345	def _registerOverrides(self, overrides, name='tests.test_config'):
6da017	346	from pyramid.interfaces import IPackageOverrides
CM	347	from pyramid.threadlocal import get_current_registry
0c29cf	348
6da017	349	reg = get_current_registry()
CM	350	reg.registerUtility(overrides, IPackageOverrides, name=name)
	351
	352	def test_get_resource_filename_no_overrides(self):
	353	resource_name = 'test_assets.py'
dd3cc8	354	import tests.test_config
0c29cf	355
dd3cc8	356	provider = self._makeOne(tests.test_config)
6da017	357	expected = os.path.join(here, resource_name)
CM	358	result = provider.get_resource_filename(None, resource_name)
	359	self.assertEqual(result, expected)
	360
	361	def test_get_resource_stream_no_overrides(self):
	362	resource_name = 'test_assets.py'
dd3cc8	363	import tests.test_config
0c29cf	364
dd3cc8	365	provider = self._makeOne(tests.test_config)
a83e10	366	with provider.get_resource_stream(None, resource_name) as result:
e6d802	367	_assertBody(result.read(), os.path.join(here, resource_name))
6da017	368
CM	369	def test_get_resource_string_no_overrides(self):
	370	resource_name = 'test_assets.py'
dd3cc8	371	import tests.test_config
0c29cf	372
dd3cc8	373	provider = self._makeOne(tests.test_config)
6da017	374	result = provider.get_resource_string(None, resource_name)
e6d802	375	_assertBody(result, os.path.join(here, resource_name))
6da017	376
CM	377	def test_has_resource_no_overrides(self):
	378	resource_name = 'test_assets.py'
dd3cc8	379	import tests.test_config
0c29cf	380
dd3cc8	381	provider = self._makeOne(tests.test_config)
6da017	382	result = provider.has_resource(resource_name)
CM	383	self.assertEqual(result, True)
	384
	385	def test_resource_isdir_no_overrides(self):
	386	file_resource_name = 'test_assets.py'
1aeae3	387	directory_resource_name = 'files'
dd3cc8	388	import tests.test_config
0c29cf	389
dd3cc8	390	provider = self._makeOne(tests.test_config)
6da017	391	result = provider.resource_isdir(file_resource_name)
CM	392	self.assertEqual(result, False)
	393	result = provider.resource_isdir(directory_resource_name)
	394	self.assertEqual(result, True)
	395
	396	def test_resource_listdir_no_overrides(self):
1aeae3	397	resource_name = 'files'
dd3cc8	398	import tests.test_config
0c29cf	399
dd3cc8	400	provider = self._makeOne(tests.test_config)
6da017	401	result = provider.resource_listdir(resource_name)
CM	402	self.assertTrue(result)
	403
	404	def test_get_resource_filename_override_returns_None(self):
	405	overrides = DummyOverrides(None)
	406	self._registerOverrides(overrides)
	407	resource_name = 'test_assets.py'
dd3cc8	408	import tests.test_config
0c29cf	409
dd3cc8	410	provider = self._makeOne(tests.test_config)
6da017	411	expected = os.path.join(here, resource_name)
CM	412	result = provider.get_resource_filename(None, resource_name)
	413	self.assertEqual(result, expected)
0c29cf	414
6da017	415	def test_get_resource_stream_override_returns_None(self):
CM	416	overrides = DummyOverrides(None)
	417	self._registerOverrides(overrides)
	418	resource_name = 'test_assets.py'
dd3cc8	419	import tests.test_config
0c29cf	420
dd3cc8	421	provider = self._makeOne(tests.test_config)
a83e10	422	with provider.get_resource_stream(None, resource_name) as result:
e6d802	423	_assertBody(result.read(), os.path.join(here, resource_name))
6da017	424
CM	425	def test_get_resource_string_override_returns_None(self):
	426	overrides = DummyOverrides(None)
	427	self._registerOverrides(overrides)
	428	resource_name = 'test_assets.py'
dd3cc8	429	import tests.test_config
0c29cf	430
dd3cc8	431	provider = self._makeOne(tests.test_config)
6da017	432	result = provider.get_resource_string(None, resource_name)
956b99	433	_assertBody(result, os.path.join(here, resource_name))
6da017	434
CM	435	def test_has_resource_override_returns_None(self):
	436	overrides = DummyOverrides(None)
	437	self._registerOverrides(overrides)
	438	resource_name = 'test_assets.py'
dd3cc8	439	import tests.test_config
0c29cf	440
dd3cc8	441	provider = self._makeOne(tests.test_config)
6da017	442	result = provider.has_resource(resource_name)
CM	443	self.assertEqual(result, True)
	444
	445	def test_resource_isdir_override_returns_None(self):
	446	overrides = DummyOverrides(None)
	447	self._registerOverrides(overrides)
1aeae3	448	resource_name = 'files'
dd3cc8	449	import tests.test_config
0c29cf	450
dd3cc8	451	provider = self._makeOne(tests.test_config)
6da017	452	result = provider.resource_isdir(resource_name)
CM	453	self.assertEqual(result, True)
	454
	455	def test_resource_listdir_override_returns_None(self):
	456	overrides = DummyOverrides(None)
	457	self._registerOverrides(overrides)
1aeae3	458	resource_name = 'files'
dd3cc8	459	import tests.test_config
0c29cf	460
dd3cc8	461	provider = self._makeOne(tests.test_config)
6da017	462	result = provider.resource_listdir(resource_name)
CM	463	self.assertTrue(result)
	464
	465	def test_get_resource_filename_override_returns_value(self):
	466	overrides = DummyOverrides('value')
dd3cc8	467	import tests.test_config
0c29cf	468
6da017	469	self._registerOverrides(overrides)
dd3cc8	470	provider = self._makeOne(tests.test_config)
6da017	471	result = provider.get_resource_filename(None, 'test_assets.py')
CM	472	self.assertEqual(result, 'value')
	473
	474	def test_get_resource_stream_override_returns_value(self):
9d7eea	475	from io import BytesIO
0c29cf	476
9d7eea	477	overrides = DummyOverrides(BytesIO(b'value'))
dd3cc8	478	import tests.test_config
0c29cf	479
6da017	480	self._registerOverrides(overrides)
dd3cc8	481	provider = self._makeOne(tests.test_config)
2029b2	482	with provider.get_resource_stream(None, 'test_assets.py') as stream:
9d7eea	483	self.assertEqual(stream.getvalue(), b'value')
6da017	484
CM	485	def test_get_resource_string_override_returns_value(self):
	486	overrides = DummyOverrides('value')
dd3cc8	487	import tests.test_config
0c29cf	488
6da017	489	self._registerOverrides(overrides)
dd3cc8	490	provider = self._makeOne(tests.test_config)
6da017	491	result = provider.get_resource_string(None, 'test_assets.py')
CM	492	self.assertEqual(result, 'value')
	493
	494	def test_has_resource_override_returns_True(self):
	495	overrides = DummyOverrides(True)
dd3cc8	496	import tests.test_config
0c29cf	497
6da017	498	self._registerOverrides(overrides)
dd3cc8	499	provider = self._makeOne(tests.test_config)
6da017	500	result = provider.has_resource('test_assets.py')
CM	501	self.assertEqual(result, True)
	502
	503	def test_resource_isdir_override_returns_False(self):
	504	overrides = DummyOverrides(False)
dd3cc8	505	import tests.test_config
0c29cf	506
6da017	507	self._registerOverrides(overrides)
dd3cc8	508	provider = self._makeOne(tests.test_config)
1aeae3	509	result = provider.resource_isdir('files')
6da017	510	self.assertEqual(result, False)
CM	511
	512	def test_resource_listdir_override_returns_values(self):
	513	overrides = DummyOverrides(['a'])
dd3cc8	514	import tests.test_config
0c29cf	515
6da017	516	self._registerOverrides(overrides)
dd3cc8	517	provider = self._makeOne(tests.test_config)
1aeae3	518	result = provider.resource_listdir('files')
6da017	519	self.assertEqual(result, ['a'])
CM	520
0c29cf	521
6da017	522	class TestPackageOverrides(unittest.TestCase):
CM	523	def _getTargetClass(self):
	524	from pyramid.config.assets import PackageOverrides
0c29cf	525
6da017	526	return PackageOverrides
CM	527
bea48e	528	def _makeOne(self, package=None, pkg_resources=None):
TS	529	if package is None:
	530	package = DummyPackage('package')
6da017	531	klass = self._getTargetClass()
CM	532	if pkg_resources is None:
	533	pkg_resources = DummyPkgResources()
	534	return klass(package, pkg_resources=pkg_resources)
	535
bea48e	536	def test_class_conforms_to_IPackageOverrides(self):
TS	537	from zope.interface.verify import verifyClass
	538	from pyramid.interfaces import IPackageOverrides
0c29cf	539
bea48e	540	verifyClass(IPackageOverrides, self._getTargetClass())
TS	541
	542	def test_instance_conforms_to_IPackageOverrides(self):
	543	from zope.interface.verify import verifyObject
	544	from pyramid.interfaces import IPackageOverrides
0c29cf	545
bea48e	546	verifyObject(IPackageOverrides, self._makeOne())
TS	547
	548	def test_class_conforms_to_IPEP302Loader(self):
	549	from zope.interface.verify import verifyClass
	550	from pyramid.interfaces import IPEP302Loader
0c29cf	551
bea48e	552	verifyClass(IPEP302Loader, self._getTargetClass())
TS	553
	554	def test_instance_conforms_to_IPEP302Loader(self):
	555	from zope.interface.verify import verifyObject
	556	from pyramid.interfaces import IPEP302Loader
0c29cf	557
bea48e	558	verifyObject(IPEP302Loader, self._makeOne())
TS	559
6da017	560	def test_ctor_package_already_has_loader_of_different_type(self):
CM	561	package = DummyPackage('package')
bea48e	562	loader = package.__loader__ = DummyLoader()
TS	563	po = self._makeOne(package)
	564	self.assertTrue(package.__loader__ is po)
	565	self.assertTrue(po.real_loader is loader)
6da017	566
CM	567	def test_ctor_package_already_has_loader_of_same_type(self):
	568	package = DummyPackage('package')
	569	package.__loader__ = self._makeOne(package)
	570	po = self._makeOne(package)
	571	self.assertEqual(package.__loader__, po)
	572
	573	def test_ctor_sets_loader(self):
	574	package = DummyPackage('package')
	575	po = self._makeOne(package)
	576	self.assertEqual(package.__loader__, po)
	577
	578	def test_ctor_registers_loader_type(self):
	579	from pyramid.config.assets import OverrideProvider
0c29cf	580
6da017	581	dummy_pkg_resources = DummyPkgResources()
CM	582	package = DummyPackage('package')
	583	po = self._makeOne(package, dummy_pkg_resources)
0c29cf	584	self.assertEqual(
MM	585	dummy_pkg_resources.registered, [(po.__class__, OverrideProvider)]
	586	)
6da017	587
CM	588	def test_ctor_sets_local_state(self):
	589	package = DummyPackage('package')
	590	po = self._makeOne(package)
	591	self.assertEqual(po.overrides, [])
	592	self.assertEqual(po.overridden_package_name, 'package')
	593
	594	def test_insert_directory(self):
	595	from pyramid.config.assets import DirectoryOverride
0c29cf	596
6da017	597	package = DummyPackage('package')
CM	598	po = self._makeOne(package)
407b33	599	po.overrides = [None]
MM	600	po.insert('foo/', DummyAssetSource())
6da017	601	self.assertEqual(len(po.overrides), 2)
CM	602	override = po.overrides[0]
	603	self.assertEqual(override.__class__, DirectoryOverride)
	604
	605	def test_insert_file(self):
	606	from pyramid.config.assets import FileOverride
0c29cf	607
6da017	608	package = DummyPackage('package')
CM	609	po = self._makeOne(package)
407b33	610	po.overrides = [None]
MM	611	po.insert('foo.pt', DummyAssetSource())
6da017	612	self.assertEqual(len(po.overrides), 2)
CM	613	override = po.overrides[0]
	614	self.assertEqual(override.__class__, FileOverride)
	615
	616	def test_insert_emptystring(self):
	617	# XXX is this a valid case for a directory?
	618	from pyramid.config.assets import DirectoryOverride
0c29cf	619
6da017	620	package = DummyPackage('package')
CM	621	po = self._makeOne(package)
407b33	622	po.overrides = [None]
MM	623	source = DummyAssetSource()
	624	po.insert('', source)
6da017	625	self.assertEqual(len(po.overrides), 2)
CM	626	override = po.overrides[0]
	627	self.assertEqual(override.__class__, DirectoryOverride)
	628
407b33	629	def test_filtered_sources(self):
0c29cf	630	overrides = [DummyOverride(None), DummyOverride('foo')]
6da017	631	package = DummyPackage('package')
CM	632	po = self._makeOne(package)
407b33	633	po.overrides = overrides
MM	634	self.assertEqual(list(po.filtered_sources('whatever')), ['foo'])
6da017	635
CM	636	def test_get_filename(self):
407b33	637	source = DummyAssetSource(filename='foo.pt')
0c29cf	638	overrides = [DummyOverride(None), DummyOverride((source, ''))]
6da017	639	package = DummyPackage('package')
CM	640	po = self._makeOne(package)
407b33	641	po.overrides = overrides
MM	642	result = po.get_filename('whatever')
	643	self.assertEqual(result, 'foo.pt')
	644	self.assertEqual(source.resource_name, '')
6da017	645
CM	646	def test_get_filename_file_doesnt_exist(self):
407b33	647	source = DummyAssetSource(filename=None)
0c29cf	648	overrides = [
MM	649	DummyOverride(None),
	650	DummyOverride((source, 'wont_exist')),
	651	]
6da017	652	package = DummyPackage('package')
CM	653	po = self._makeOne(package)
407b33	654	po.overrides = overrides
6da017	655	self.assertEqual(po.get_filename('whatever'), None)
407b33	656	self.assertEqual(source.resource_name, 'wont_exist')
MM	657
d3a27e	658	def test_get_stream(self):
407b33	659	source = DummyAssetSource(stream='a stream?')
MM	660	overrides = [DummyOverride(None), DummyOverride((source, 'foo.pt'))]
d3a27e	661	package = DummyPackage('package')
CM	662	po = self._makeOne(package)
407b33	663	po.overrides = overrides
MM	664	self.assertEqual(po.get_stream('whatever'), 'a stream?')
	665	self.assertEqual(source.resource_name, 'foo.pt')
0c29cf	666
6da017	667	def test_get_stream_file_doesnt_exist(self):
407b33	668	source = DummyAssetSource(stream=None)
0c29cf	669	overrides = [
MM	670	DummyOverride(None),
	671	DummyOverride((source, 'wont_exist')),
	672	]
6da017	673	package = DummyPackage('package')
CM	674	po = self._makeOne(package)
407b33	675	po.overrides = overrides
6da017	676	self.assertEqual(po.get_stream('whatever'), None)
407b33	677	self.assertEqual(source.resource_name, 'wont_exist')
6da017	678
CM	679	def test_get_string(self):
407b33	680	source = DummyAssetSource(string='a string')
MM	681	overrides = [DummyOverride(None), DummyOverride((source, 'foo.pt'))]
6da017	682	package = DummyPackage('package')
CM	683	po = self._makeOne(package)
407b33	684	po.overrides = overrides
MM	685	self.assertEqual(po.get_string('whatever'), 'a string')
	686	self.assertEqual(source.resource_name, 'foo.pt')
0c29cf	687
6da017	688	def test_get_string_file_doesnt_exist(self):
407b33	689	source = DummyAssetSource(string=None)
0c29cf	690	overrides = [
MM	691	DummyOverride(None),
	692	DummyOverride((source, 'wont_exist')),
	693	]
6da017	694	package = DummyPackage('package')
CM	695	po = self._makeOne(package)
407b33	696	po.overrides = overrides
6da017	697	self.assertEqual(po.get_string('whatever'), None)
407b33	698	self.assertEqual(source.resource_name, 'wont_exist')
6da017	699
CM	700	def test_has_resource(self):
407b33	701	source = DummyAssetSource(exists=True)
MM	702	overrides = [DummyOverride(None), DummyOverride((source, 'foo.pt'))]
6da017	703	package = DummyPackage('package')
CM	704	po = self._makeOne(package)
407b33	705	po.overrides = overrides
6da017	706	self.assertEqual(po.has_resource('whatever'), True)
407b33	707	self.assertEqual(source.resource_name, 'foo.pt')
6da017	708
CM	709	def test_has_resource_file_doesnt_exist(self):
407b33	710	source = DummyAssetSource(exists=None)
0c29cf	711	overrides = [
MM	712	DummyOverride(None),
	713	DummyOverride((source, 'wont_exist')),
	714	]
6da017	715	package = DummyPackage('package')
CM	716	po = self._makeOne(package)
407b33	717	po.overrides = overrides
6da017	718	self.assertEqual(po.has_resource('whatever'), None)
407b33	719	self.assertEqual(source.resource_name, 'wont_exist')
6da017	720
CM	721	def test_isdir_false(self):
407b33	722	source = DummyAssetSource(isdir=False)
MM	723	overrides = [DummyOverride(None), DummyOverride((source, 'foo.pt'))]
6da017	724	package = DummyPackage('package')
CM	725	po = self._makeOne(package)
407b33	726	po.overrides = overrides
6da017	727	self.assertEqual(po.isdir('whatever'), False)
407b33	728	self.assertEqual(source.resource_name, 'foo.pt')
MM	729
6da017	730	def test_isdir_true(self):
407b33	731	source = DummyAssetSource(isdir=True)
MM	732	overrides = [DummyOverride(None), DummyOverride((source, 'foo.pt'))]
6da017	733	package = DummyPackage('package')
CM	734	po = self._makeOne(package)
407b33	735	po.overrides = overrides
6da017	736	self.assertEqual(po.isdir('whatever'), True)
407b33	737	self.assertEqual(source.resource_name, 'foo.pt')
6da017	738
CM	739	def test_isdir_doesnt_exist(self):
407b33	740	source = DummyAssetSource(isdir=None)
0c29cf	741	overrides = [
MM	742	DummyOverride(None),
	743	DummyOverride((source, 'wont_exist')),
	744	]
6da017	745	package = DummyPackage('package')
CM	746	po = self._makeOne(package)
407b33	747	po.overrides = overrides
6da017	748	self.assertEqual(po.isdir('whatever'), None)
407b33	749	self.assertEqual(source.resource_name, 'wont_exist')
6da017	750
CM	751	def test_listdir(self):
407b33	752	source = DummyAssetSource(listdir=True)
MM	753	overrides = [DummyOverride(None), DummyOverride((source, 'foo.pt'))]
6da017	754	package = DummyPackage('package')
CM	755	po = self._makeOne(package)
407b33	756	po.overrides = overrides
MM	757	self.assertEqual(po.listdir('whatever'), True)
	758	self.assertEqual(source.resource_name, 'foo.pt')
6da017	759
CM	760	def test_listdir_doesnt_exist(self):
407b33	761	source = DummyAssetSource(listdir=None)
0c29cf	762	overrides = [
MM	763	DummyOverride(None),
	764	DummyOverride((source, 'wont_exist')),
	765	]
6da017	766	package = DummyPackage('package')
CM	767	po = self._makeOne(package)
407b33	768	po.overrides = overrides
6da017	769	self.assertEqual(po.listdir('whatever'), None)
407b33	770	self.assertEqual(source.resource_name, 'wont_exist')
6da017	771
bea48e	772	# PEP 302 __loader__ extensions: use the "real" __loader__, if present.
TS	773	def test_get_data_pkg_has_no___loader__(self):
	774	package = DummyPackage('package')
	775	po = self._makeOne(package)
	776	self.assertRaises(NotImplementedError, po.get_data, 'whatever')
	777
	778	def test_get_data_pkg_has___loader__(self):
	779	package = DummyPackage('package')
0c29cf	780	loader = package.__loader__ = DummyLoader()
bea48e	781	po = self._makeOne(package)
TS	782	self.assertEqual(po.get_data('whatever'), b'DEADBEEF')
	783	self.assertEqual(loader._got_data, 'whatever')
	784
	785	def test_is_package_pkg_has_no___loader__(self):
	786	package = DummyPackage('package')
	787	po = self._makeOne(package)
	788	self.assertRaises(NotImplementedError, po.is_package, 'whatever')
	789
	790	def test_is_package_pkg_has___loader__(self):
	791	package = DummyPackage('package')
0c29cf	792	loader = package.__loader__ = DummyLoader()
bea48e	793	po = self._makeOne(package)
TS	794	self.assertTrue(po.is_package('whatever'))
	795	self.assertEqual(loader._is_package, 'whatever')
	796
	797	def test_get_code_pkg_has_no___loader__(self):
	798	package = DummyPackage('package')
	799	po = self._makeOne(package)
	800	self.assertRaises(NotImplementedError, po.get_code, 'whatever')
	801
	802	def test_get_code_pkg_has___loader__(self):
	803	package = DummyPackage('package')
0c29cf	804	loader = package.__loader__ = DummyLoader()
bea48e	805	po = self._makeOne(package)
TS	806	self.assertEqual(po.get_code('whatever'), b'DEADBEEF')
	807	self.assertEqual(loader._got_code, 'whatever')
	808
	809	def test_get_source_pkg_has_no___loader__(self):
	810	package = DummyPackage('package')
	811	po = self._makeOne(package)
	812	self.assertRaises(NotImplementedError, po.get_source, 'whatever')
	813
	814	def test_get_source_pkg_has___loader__(self):
	815	package = DummyPackage('package')
407b33	816	loader = package.__loader__ = DummyLoader()
bea48e	817	po = self._makeOne(package)
TS	818	self.assertEqual(po.get_source('whatever'), 'def foo():\n pass')
	819	self.assertEqual(loader._got_source, 'whatever')
407b33	820
MM	821
0c29cf	822	class AssetSourceIntegrationTests(object):
407b33	823	def test_get_filename(self):
MM	824	source = self._makeOne('')
0c29cf	825	self.assertEqual(
MM	826	source.get_filename('test_assets.py'),
	827	os.path.join(here, 'test_assets.py'),
	828	)
407b33	829
MM	830	def test_get_filename_with_prefix(self):
	831	source = self._makeOne('test_assets.py')
0c29cf	832	self.assertEqual(
MM	833	source.get_filename(''), os.path.join(here, 'test_assets.py')
	834	)
407b33	835
MM	836	def test_get_filename_file_doesnt_exist(self):
	837	source = self._makeOne('')
	838	self.assertEqual(source.get_filename('wont_exist'), None)
	839
	840	def test_get_stream(self):
	841	source = self._makeOne('')
	842	with source.get_stream('test_assets.py') as stream:
	843	_assertBody(stream.read(), os.path.join(here, 'test_assets.py'))
	844
	845	def test_get_stream_with_prefix(self):
	846	source = self._makeOne('test_assets.py')
	847	with source.get_stream('') as stream:
	848	_assertBody(stream.read(), os.path.join(here, 'test_assets.py'))
	849
	850	def test_get_stream_file_doesnt_exist(self):
	851	source = self._makeOne('')
	852	self.assertEqual(source.get_stream('wont_exist'), None)
	853
	854	def test_get_string(self):
	855	source = self._makeOne('')
0c29cf	856	_assertBody(
MM	857	source.get_string('test_assets.py'),
	858	os.path.join(here, 'test_assets.py'),
	859	)
407b33	860
MM	861	def test_get_string_with_prefix(self):
	862	source = self._makeOne('test_assets.py')
0c29cf	863	_assertBody(
MM	864	source.get_string(''), os.path.join(here, 'test_assets.py')
	865	)
407b33	866
MM	867	def test_get_string_file_doesnt_exist(self):
	868	source = self._makeOne('')
	869	self.assertEqual(source.get_string('wont_exist'), None)
	870
	871	def test_exists(self):
	872	source = self._makeOne('')
	873	self.assertEqual(source.exists('test_assets.py'), True)
	874
	875	def test_exists_with_prefix(self):
	876	source = self._makeOne('test_assets.py')
	877	self.assertEqual(source.exists(''), True)
	878
	879	def test_exists_file_doesnt_exist(self):
	880	source = self._makeOne('')
	881	self.assertEqual(source.exists('wont_exist'), None)
	882
	883	def test_isdir_false(self):
	884	source = self._makeOne('')
	885	self.assertEqual(source.isdir('test_assets.py'), False)
	886
	887	def test_isdir_true(self):
	888	source = self._makeOne('')
	889	self.assertEqual(source.isdir('files'), True)
	890
	891	def test_isdir_doesnt_exist(self):
	892	source = self._makeOne('')
	893	self.assertEqual(source.isdir('wont_exist'), None)
	894
	895	def test_listdir(self):
	896	source = self._makeOne('')
	897	self.assertTrue(source.listdir('files'))
	898
	899	def test_listdir_doesnt_exist(self):
	900	source = self._makeOne('')
	901	self.assertEqual(source.listdir('wont_exist'), None)
	902
	903
0c29cf	904	class TestPackageAssetSource(AssetSourceIntegrationTests, unittest.TestCase):
407b33	905	def _getTargetClass(self):
MM	906	from pyramid.config.assets import PackageAssetSource
0c29cf	907
407b33	908	return PackageAssetSource
MM	909
dd3cc8	910	def _makeOne(self, prefix, package='tests.test_config'):
407b33	911	klass = self._getTargetClass()
MM	912	return klass(package, prefix)
	913
0c29cf	914
407b33	915	class TestFSAssetSource(AssetSourceIntegrationTests, unittest.TestCase):
MM	916	def _getTargetClass(self):
	917	from pyramid.config.assets import FSAssetSource
0c29cf	918
407b33	919	return FSAssetSource
MM	920
	921	def _makeOne(self, prefix, base_prefix=here):
	922	klass = self._getTargetClass()
	923	return klass(os.path.join(base_prefix, prefix))
bea48e	924
0c29cf	925
6da017	926	class TestDirectoryOverride(unittest.TestCase):
CM	927	def _getTargetClass(self):
	928	from pyramid.config.assets import DirectoryOverride
0c29cf	929
6da017	930	return DirectoryOverride
CM	931
407b33	932	def _makeOne(self, path, source):
6da017	933	klass = self._getTargetClass()
407b33	934	return klass(path, source)
6da017	935
CM	936	def test_it_match(self):
407b33	937	source = DummyAssetSource()
MM	938	o = self._makeOne('foo/', source)
6da017	939	result = o('foo/something.pt')
407b33	940	self.assertEqual(result, (source, 'something.pt'))
0c29cf	941
6da017	942	def test_it_no_match(self):
407b33	943	source = DummyAssetSource()
MM	944	o = self._makeOne('foo/', source)
6da017	945	result = o('baz/notfound.pt')
CM	946	self.assertEqual(result, None)
	947
0c29cf	948
6da017	949	class TestFileOverride(unittest.TestCase):
CM	950	def _getTargetClass(self):
	951	from pyramid.config.assets import FileOverride
0c29cf	952
6da017	953	return FileOverride
CM	954
407b33	955	def _makeOne(self, path, source):
6da017	956	klass = self._getTargetClass()
407b33	957	return klass(path, source)
6da017	958
CM	959	def test_it_match(self):
407b33	960	source = DummyAssetSource()
MM	961	o = self._makeOne('foo.pt', source)
6da017	962	result = o('foo.pt')
407b33	963	self.assertEqual(result, (source, ''))
0c29cf	964
6da017	965	def test_it_no_match(self):
407b33	966	source = DummyAssetSource()
MM	967	o = self._makeOne('foo.pt', source)
6da017	968	result = o('notfound.pt')
CM	969	self.assertEqual(result, None)
0c29cf	970
6da017	971
CM	972	class DummyOverride:
	973	def __init__(self, result):
	974	self.result = result
	975
	976	def __call__(self, resource_name):
	977	return self.result
0c29cf	978
6da017	979
CM	980	class DummyOverrides:
	981	def __init__(self, result):
	982	self.result = result
	983
	984	def get_filename(self, resource_name):
	985	return self.result
	986
	987	listdir = isdir = has_resource = get_stream = get_string = get_filename
2deac8	988
0c29cf	989
2deac8	990	class DummyPackageOverrides:
CM	991	def __init__(self, package):
	992	self.package = package
	993	self.inserted = []
	994
407b33	995	def insert(self, path, source):
MM	996	self.inserted.append((path, source))
0c29cf	997
MM	998
6da017	999	class DummyPkgResources:
CM	1000	def __init__(self):
	1001	self.registered = []
	1002
	1003	def register_loader_type(self, typ, inst):
	1004	self.registered.append((typ, inst))
bea48e	1005
0c29cf	1006
6da017	1007	class DummyPackage:
CM	1008	def __init__(self, name):
	1009	self.__name__ = name
0c29cf	1010
407b33	1011
MM	1012	class DummyAssetSource:
	1013	def __init__(self, **kw):
	1014	self.kw = kw
	1015
	1016	def get_filename(self, resource_name):
	1017	self.resource_name = resource_name
	1018	return self.kw['filename']
	1019
	1020	def get_stream(self, resource_name):
	1021	self.resource_name = resource_name
	1022	return self.kw['stream']
	1023
	1024	def get_string(self, resource_name):
	1025	self.resource_name = resource_name
	1026	return self.kw['string']
	1027
	1028	def exists(self, resource_name):
	1029	self.resource_name = resource_name
	1030	return self.kw['exists']
	1031
	1032	def isdir(self, resource_name):
	1033	self.resource_name = resource_name
	1034	return self.kw['isdir']
	1035
	1036	def listdir(self, resource_name):
	1037	self.resource_name = resource_name
	1038	return self.kw['listdir']
0c29cf	1039
MM	1040
bea48e	1041	class DummyLoader:
TS	1042	_got_data = _is_package = None
0c29cf	1043
bea48e	1044	def get_data(self, path):
TS	1045	self._got_data = path
	1046	return b'DEADBEEF'
0c29cf	1047
bea48e	1048	def is_package(self, fullname):
TS	1049	self._is_package = fullname
	1050	return True
0c29cf	1051
bea48e	1052	def get_code(self, fullname):
TS	1053	self._got_code = fullname
	1054	return b'DEADBEEF'
0c29cf	1055
bea48e	1056	def get_source(self, fullname):
TS	1057	self._got_source = fullname
	1058	return 'def foo():\n pass'
0c29cf	1059
9ee830	1060
CM	1061	class DummyUnderOverride:
407b33	1062	def __call__(self, package, path, source, _info=''):
9ee830	1063	self.package = package
CM	1064	self.path = path
407b33	1065	self.source = source
9ee830	1066
0c29cf	1067
2544cf	1068	def read_(src):
MM	1069	with open(src, 'rb') as f:
	1070	contents = f.read()
	1071	return contents
0c29cf	1072
2544cf	1073
e6d802	1074	def _assertBody(body, filename):
CM	1075	# strip both \n and \r for windows
956b99	1076	body = body.replace(b'\r', b'')
CM	1077	body = body.replace(b'\n', b'')
e6d802	1078	data = read_(filename)
956b99	1079	data = data.replace(b'\r', b'')
CM	1080	data = data.replace(b'\n', b'')
0c29cf	1081	assert body == data