def test_get_custom_wms_params_true():
Config._config = None
Config.init('./tests/contrib/print_proxy/resources/test_custom_config.yml',
'pyramid_oereb')
renderer = Renderer(DummyRenderInfo())
# Define different test cases
params1 = {
'TRANSPARENT': ['true'],
'OTHERCUSTOM': ['myvalue'],
'epoch': ['2018-11-29T15:13:31']
}
params2 = {'OTHERCUSTOM': ['myvalue'], 'epoch': ['2018-11-29T15:13:31']}
params3 = {'epoch': '2018-11-29T15:13:31'}
params4 = {'epoch': ['2018-11-29T15:13:31', '2020-11-29T17:13:50']}
config1 = renderer.get_custom_wms_params(params1)
config2 = renderer.get_custom_wms_params(params2)
config3 = renderer.get_custom_wms_params(params3)
config4 = renderer.get_custom_wms_params(params4)
# Restore normal config
Config._config = None
Config.init('./pyramid_oereb/standard/pyramid_oereb.yml', 'pyramid_oereb')
# Do the check for the different test cases. Value should match the ones from the YAML configuration.
assert config1 == {'TRANSPARENT': 'true', 'epoch': '2018-11-29T15:13:31'}
assert config2 == {'epoch': '2018-11-29T15:13:31'}
assert config3 == {'epoch': '2018-11-29T15:13:31'}
assert config4 == {'epoch': '2018-11-29T15:13:31,2020-11-29T17:13:50'}
def test_get_localized_text_from_string(config):
assert isinstance(config._config, dict)
renderer = Renderer(DummyRenderInfo())
localized_text = renderer.get_localized_text('Test')
assert isinstance(localized_text, dict)
assert localized_text.get('Text') == 'Test'
assert localized_text.get('Language') == config.get('default_language')
def test_format_map(config, params):
assert isinstance(config._config, dict)
with pyramid_oereb_test_config():
renderer = Renderer(DummyRenderInfo())
renderer._language = u'de'
renderer._params = params
renderer._request = MockRequest()
legend_entry = LegendEntryRecord(
ImageRecord('1'.encode('utf-8')), {u'de': u'Legendeneintrag'},
u'type1', u'type_code_list',
ThemeRecord(u'ContaminatedSites', {u'de': u'Test'}))
view_service = ViewServiceRecord(
'http://my.wms.ch',
'http://my.wms.ch?SERVICE=WMS&REQUEST=GetLegendGraphic',
[legend_entry])
view_service.image = ImageRecord('1'.encode('utf-8'))
result = renderer.format_map(view_service)
assert isinstance(result, dict)
assert result == {
'Image': base64.b64encode('1'.encode('utf-8')).decode('ascii'),
'ReferenceWMS': 'http://my.wms.ch',
'LegendAtWeb':
'http://my.wms.ch?SERVICE=WMS&REQUEST=GetLegendGraphic',
'OtherLegend': [renderer.format_legend_entry(legend_entry)]
}
def test_format_legend_entry(parameter, config):
assert isinstance(config._config, dict)
with pyramid_oereb_test_config():
renderer = Renderer(DummyRenderInfo())
renderer._language = u'de'
renderer._params = parameter
renderer._request = MockRequest()
theme = ThemeRecord(u'ContaminatedSites', {u'de': u'Test'})
legend_entry = LegendEntryRecord(ImageRecord('1'.encode('utf-8')),
{u'de': u'Legendeneintrag'}, u'type1',
u'type_code_list', theme, u'Subthema',
u'Weiteres Thema')
result = renderer.format_legend_entry(legend_entry)
expected = {
'LegendText':
renderer.get_multilingual_text({'de': 'Legendeneintrag'}),
'TypeCode': 'type1',
'TypeCodelist': 'type_code_list',
'Theme': renderer.format_theme(theme),
'SubTheme': 'Subthema',
'OtherTheme': 'Weiteres Thema'
}
if parameter.images:
expected.update(
{'Symbol': ImageRecord('1'.encode('utf-8')).encode()})
else:
expected.update({
'SymbolRef':
'http://example.com/image/symbol/{theme_code}/{code}'.format(
theme_code='ContaminatedSites', code='type1')
})
assert isinstance(result, dict)
assert result == expected
def test_format_document(params, document, result_dict):
renderer = Renderer(DummyRenderInfo())
renderer._language = u'de'
renderer._params = params
result = renderer.format_document(document)
assert isinstance(result, dict)
assert result == result_dict
def test_format_real_estate(config):
assert isinstance(config._config, dict)
renderer = Renderer(DummyRenderInfo())
renderer._language = u'de'
renderer._params = Parameter(
'reduced', 'json', True, False, 'BL0200002829', '1000', 'CH775979211712', 'de')
geometry = MultiPolygon([Polygon([(0, 0), (1, 1), (1, 0)])])
view_service = ViewServiceRecord(u'http://geowms.bl.ch', u'http://geowms.bl.ch')
document = DocumentRecord(law_status(), datetime.date.today(), {u'de': u'Test Dokument'},
OfficeRecord({u'de': u'BUD'}), {'de': 'http://mein.dokument.ch'})
real_estate = RealEstateRecord(u'RealEstate', u'BL', u'Liestal', 2829, 11395,
geometry, u'http://www.geocat.ch', u'1000', u'BL0200002829',
u'CH775979211712', u'Subunit', [], references=[document])
real_estate.plan_for_land_register = view_service
result = renderer.format_real_estate(real_estate)
assert isinstance(result, dict)
assert result == {
'Type': u'RealEstate',
'Canton': u'BL',
'Municipality': u'Liestal',
'FosNr': 2829,
'LandRegistryArea': 11395,
'PlanForLandRegister': renderer.format_map(view_service),
'Limit': renderer.from_shapely(geometry),
'Number': u'1000',
'IdentDN': u'BL0200002829',
'EGRID': u'CH775979211712',
'SubunitOfLandRegister': u'Subunit',
'MetadataOfGeographicalBaseData': u'http://www.geocat.ch',
'Reference': [renderer.format_document(document)]
}
def test_format_geometry(params, geometry, result_dict):
renderer = Renderer(DummyRenderInfo())
renderer._language = u'de'
renderer._params = params
result = renderer.format_geometry(geometry)
assert isinstance(result, dict)
assert result == result_dict
def test_legend():
renderer = Renderer(DummyRenderInfo())
pdf_to_join = set()
printable_extract = extract()
renderer.convert_to_printable_extract(printable_extract, geometry(), pdf_to_join)
first_plr = printable_extract.get('RealEstate_RestrictionOnLandownership')[0]
assert isinstance(first_plr, dict)
def test_format_map(params, legend_at_web, expected_legend_at_web):
with pyramid_oereb_test_config():
renderer = Renderer(DummyRenderInfo())
renderer._language = u'de'
renderer._params = params
renderer._request = MockRequest()
legend_entry = LegendEntryRecord(ImageRecord('1'.encode('utf-8')),
{u'de': u'Legendeneintrag'},
u'CodeA',
u'type_code_list',
ThemeRecord(u'ContaminatedSites',
{u'de': u'Test'}),
view_service_id=1)
view_service = ViewServiceRecord('http://my.wms.ch', 1, 1.0,
legend_at_web, [legend_entry])
view_service.image = ImageRecord('1'.encode('utf-8'))
result = renderer.format_map(view_service)
assert isinstance(result, dict)
expected_result = {
'Image': base64.b64encode('1'.encode('utf-8')).decode('ascii'),
'layerIndex': 1,
'layerOpacity': 1.0,
'ReferenceWMS': 'http://my.wms.ch',
'OtherLegend': [renderer.format_legend_entry(legend_entry)]
}
if expected_legend_at_web is not None:
expected_result['LegendAtWeb'] = expected_legend_at_web
assert result == expected_result
def test_sub_theme():
parameters = Parameter(
response_format='xml',
flavour='reduced',
with_geometry=False,
images=True,
identdn='BL0200002829',
number='1000',
egrid='CH775979211712',
language='de')
renderer = Renderer(DummyRenderInfo())
renderer._language = u'de'
renderer._request = MockRequest()
renderer._request.route_url = lambda url, **kwargs: "http://example.com/current/view"
legend_entry = LegendEntryRecord(
symbol=ImageRecord('1'.encode('utf-8')),
legend_text={'de': 'legend1'},
type_code='LandUsePlans',
type_code_list='bla',
theme=ThemeRecord(u'LandUsePlans', {'de': 'Theme 1'}),
sub_theme={'de': 'sub theme de'}
)
content = template.render(**{
'params': parameters,
'localized': renderer.get_localized_text,
'multilingual': renderer.get_multilingual_text,
'legend_entry': legend_entry
}).decode('utf-8').split('\n')
no_empty_lines = list(filter(lambda line: line != '', content))
assert no_empty_lines[19] == '<data:SubTheme>sub theme de</data:SubTheme>'
assert len(no_empty_lines) == 20
def test_get_localized_text_from_dict(language, result):
renderer = Renderer(DummyRenderInfo())
renderer._language = language
multilingual_text = {'de': u'Dies ist ein Test', 'en': u'This is a test'}
localized_text = renderer.get_localized_text(multilingual_text)
assert isinstance(localized_text, dict)
assert localized_text.get('Language') in ['de', 'en']
assert localized_text.get('Text') == result
def test_get_multilingual_text_from_dict(language, result):
renderer = Renderer(DummyRenderInfo())
renderer._language = language
multilingual_text = {'de': u'Dies ist ein Test', 'en': u'This is a test'}
ml_text = renderer.get_multilingual_text(multilingual_text)
assert isinstance(ml_text, list)
assert len(ml_text) == 1
assert ml_text[0].get('Language') in ['de', 'en']
assert ml_text[0].get('Text') == result
def test_bad_config_wms_url_params():
Config._config = None
Config.init('./tests/contrib/print_proxy/resources/test_bad_config.yml',
'pyramid_oereb')
renderer = Renderer(DummyRenderInfo())
config = renderer.get_wms_url_params()
# Restore normal config
Config._config = None
Config.init('./pyramid_oereb/standard/pyramid_oereb.yml', 'pyramid_oereb')
# Do the check for this test. Value should be empty.
assert config == {}
def test_format_theme(params):
renderer = Renderer(DummyRenderInfo())
renderer._language = u'de'
renderer._params = params
theme = ThemeRecord(u'TestTheme', {u'de': u'Test-Thema'})
result = renderer.format_theme(theme)
assert isinstance(result, dict)
assert result == {
'Code': 'TestTheme',
'Text': renderer.get_localized_text({'de': 'Test-Thema'})
}
def test_config_wms_url_params():
Config._config = None
Config.init('./tests/contrib/print_proxy/resources/test_config.yml',
'pyramid_oereb')
renderer = Renderer(DummyRenderInfo())
config = renderer.get_wms_url_params()
# Restore normal config
Config._config = None
Config.init('./pyramid_oereb/standard/pyramid_oereb.yml', 'pyramid_oereb')
# Do the check for this test. Value should match the one from the YAML configuration.
assert config == {'TRANSPARENT': 'true', 'OTHERCUSTOM': 'myvalue'}
def test_embeddable(params):
renderer = Renderer(DummyRenderInfo())
renderer._language = u'de'
renderer._params = params
date = datetime.datetime.now()
view_service = ViewServiceRecord(u'http://geowms.bl.ch',
1,
1.0,
{'de': u'http://geowms.bl.ch'},
None)
real_estate = RealEstateRecord(
u'RealEstate',
u'BL',
u'Liestal',
2829,
11395,
MultiPolygon([Polygon([(0, 0), (1, 1), (1, 0)])]),
u'http://www.geocat.ch', u'1000', u'BL0200002829', u'CH775979211712'
)
real_estate.plan_for_land_register = view_service
resolver = DottedNameResolver()
date_method_string = Config.get('extract').get('base_data').get('methods').get('date')
date_method = resolver.resolve(date_method_string)
av_update_date = date_method(real_estate)
av_provider_method_string = Config.get('extract').get('base_data').get('methods').get('provider')
av_provider_method = resolver.resolve(av_provider_method_string)
cadaster_state = date
theme = ThemeRecord(u'TEST', {u'de': u'TEST TEXT'})
datasources = [DatasourceRecord(theme, date, OfficeRecord({u'de': u'Test Office'}))]
plr_cadastre_authority = Config.get_plr_cadastre_authority()
embeddable = EmbeddableRecord(
cadaster_state,
plr_cadastre_authority,
av_provider_method(real_estate),
av_update_date,
datasources
)
result = renderer.format_embeddable(embeddable)
assert result == {
'cadasterOrganisationName': plr_cadastre_authority.name.get('de'),
'datasource': [{
'topic': {
'Text': {'Text': u'TEST TEXT', 'Language': 'de'},
'Code': 'TEST'
},
'dataownerName': u'Test Office',
'transferFromSource': date.strftime('%d-%m-%YT%H:%M:%S')
}],
'cadasterState': cadaster_state.strftime('%d-%m-%YT%H:%M:%S'),
'dataOwnerNameCadastralSurveying': u'This is only a dummy',
'transferFromSourceCadastralSurveying': av_update_date.strftime('%d-%m-%YT%H:%M:%S')
}
def test_sort_by_localized_text():
renderer = Renderer(DummyRenderInfo())
renderer._language = 'de'
# Elements like in the glossary
multilingual_elements = [{
'title': {
'fr': u'RDPPF',
'de': u'\xd6REB',
},
'content': {
'fr': u'Content-RDPPF',
'de': u'Content-\xd6REB',
},
}, {
'title': {
'fr': u'No OFS',
'de': u'BFS-Nr.',
},
'content': {
'fr': u'Content-No OFS',
'de': u'Content-BFS-Nr.',
},
}, {
'title': {
'fr': u'Ofo',
'de': u'WaV',
},
'content': {
'fr': u'Content-Ofo',
'de': u'Content-WaV',
},
}]
sorted_multilingual_elements = renderer.sort_by_localized_text(
multilingual_elements, lambda element: element['title'])
assert isinstance(sorted_multilingual_elements, list)
assert len(sorted_multilingual_elements) == 3
# Elements sorted by 'de' title:
assert sorted_multilingual_elements[0]['title']['de'] == u'BFS-Nr.'
assert sorted_multilingual_elements[1]['title']['de'] == u'\xd6REB'
assert sorted_multilingual_elements[2]['title']['de'] == u'WaV'
assert sorted_multilingual_elements[0]['content'][
'de'] == u'Content-BFS-Nr.'
assert sorted_multilingual_elements[1]['content'][
'de'] == u'Content-\xd6REB'
assert sorted_multilingual_elements[2]['content']['de'] == u'Content-WaV'
# Still sorted with 'de' language, effect on 'fr' elements:
assert sorted_multilingual_elements[0]['title']['fr'] == u'No OFS'
assert sorted_multilingual_elements[1]['title']['fr'] == u'RDPPF'
assert sorted_multilingual_elements[2]['title']['fr'] == u'Ofo'
assert sorted_multilingual_elements[0]['content'][
'fr'] == u'Content-No OFS'
assert sorted_multilingual_elements[1]['content']['fr'] == u'Content-RDPPF'
assert sorted_multilingual_elements[2]['content']['fr'] == u'Content-Ofo'
def test_extract_against_schema(parameter, test_extract):
extract = test_extract
renderer = Renderer(DummyRenderInfo())
renderer._language = u'de'
renderer._request = MockRequest()
renderer._request.route_url = lambda url, **kwargs: "http://example.com/current/view"
rendered = renderer._render(extract, parameter)
xmlschema_doc = etree.parse(schema_xml_extract)
xmlschema = etree.XMLSchema(xmlschema_doc)
buffer = BytesIO(rendered)
doc = etree.parse(buffer)
xmlschema.assertValid(doc)
def test_mapfish_print_entire_extract():
renderer = Renderer(DummyRenderInfo())
pdf_to_join = set()
printable_extract = extract()
renderer.convert_to_printable_extract(printable_extract, geometry(),
pdf_to_join)
# Uncomment to print the result
# f = open('/tmp/printable_extract.json', 'w')
# f.write(json.dumps(printable_extract))
# f.close()
assert deepCompare(printable_extract, expected_printable_extract())
# Do it twice, to test all keys in each reports
assert deepCompare(expected_printable_extract(), printable_extract)
def test_format_office():
renderer = Renderer(DummyRenderInfo())
renderer._language = 'de'
office = OfficeRecord({'de': u'Test'}, uid=u'test_uid', office_at_web=u'http://test.example.com',
line1=u'test_line1', line2=u'test_line2', street=u'test_street',
number=u'test_number', postal_code=1234, city=u'test_city')
assert renderer.format_office(office) == {
'Name': renderer.get_multilingual_text('Test'),
'UID': u'test_uid',
'OfficeAtWeb': u'http://test.example.com',
'Line1': u'test_line1',
'Line2': u'test_line2',
'Street': u'test_street',
'Number': u'test_number',
'PostalCode': 1234,
'City': u'test_city'
}
def test_get_custom_wms_params_false():
Config._config = None
Config.init('./tests/contrib/print_proxy/resources/test_config.yml',
'pyramid_oereb')
renderer = Renderer(DummyRenderInfo())
params = {
'TRANSPARENT': ['true'],
'OTHERCUSTOM': ['myvalue'],
'epoch': ['2018-11-29T15:13:31']
}
config = renderer.get_custom_wms_params(params)
# Restore normal config
Config._config = None
Config.init('./pyramid_oereb/standard/pyramid_oereb.yml', 'pyramid_oereb')
assert config == {'OTHERCUSTOM': 'myvalue', 'TRANSPARENT': 'true'}
def test_sub_theme():
parameters = Parameter(flavour='reduced',
format='xml',
geometry=False,
images=True,
identdn='BL0200002829',
number='1000',
egrid='CH775979211712',
language='de')
renderer = Renderer(DummyRenderInfo())
renderer._language = u'de'
renderer._request = MockRequest()
renderer._request.route_url = lambda url, **kwargs: "http://example.com/current/view"
office = OfficeRecord(name={'de': 'office de'})
law_status = LawStatusRecord(code='runningModifications',
text={'de': 'law status de'})
geometry = GeometryRecord(law_status,
datetime.now(),
Polygon(),
'test',
office=office)
public_law_restriction = PlrRecord(
theme=ThemeRecord(u'LandUsePlans', {'de': 'Theme 1'}),
information={'de': 'information de'},
law_status=law_status,
published_from=datetime.now(),
responsible_office=office,
symbol=ImageRecord('1'.encode('utf-8')),
view_service=ViewServiceRecord(reference_wms='',
layer_index=0,
layer_opacity=1.0),
geometries=[geometry],
sub_theme={'de': 'sub theme de'})
content = template.render(
**{
'params': parameters,
'localized': renderer.get_localized_text,
'multilingual': renderer.get_multilingual_text,
'public_law_restriction': public_law_restriction
}).decode('utf-8').split('\n')
no_empty_lines = list(filter(lambda line: line != '', content))
assert no_empty_lines[
18] == ' <data:SubTheme>sub theme de</data:SubTheme>'
assert len(no_empty_lines) == 72
def test_mapfish_print_entire_extract():
renderer = Renderer(DummyRenderInfo())
pdf_to_join = set()
printable_extract = extract()
renderer.convert_to_printable_extract(printable_extract, geometry(),
pdf_to_join)
# Uncomment to print the result
# f = open('/tmp/printable_extract.json', 'w')
# f.write(json.dumps(printable_extract))
# f.close()
expected = expected_printable_extract()
# FIXME Do the test only in python 2 because order of item are different
# in some cases with python 3. The Error will not be possible anymore with
# https://github.com/openoereb/pyramid_oereb/issues/651
if sys.version_info.major == 2:
assert deepCompare(printable_extract, expected)
# Do it twice, to test all keys in each reports
assert deepCompare(expected, printable_extract)
def test_version_against_schema():
versions = {
u'GetVersionsResponse': {
u'supportedVersion': [{
u'version':
u'1.0',
u'serviceEndpointBase':
u'https://example.com'
}]
}
}
renderer = VersionsRenderer(DummyRenderInfo())
rendered = renderer._render(versions)
xmlschema_doc = etree.parse(schema_xml_versions)
xmlschema = etree.XMLSchema(xmlschema_doc)
buffer = BytesIO(rendered)
doc = etree.parse(buffer)
assert xmlschema.validate(doc)
def test_format_legend_entry(parameter):
with pyramid_oereb_test_config():
renderer = Renderer(DummyRenderInfo())
renderer._language = u'de'
renderer._params = parameter
renderer._request = MockRequest()
theme = ThemeRecord(u'ContaminatedSites', {u'de': u'Test'})
legend_entry = LegendEntryRecord(
ImageRecord(FileAdapter().read('tests/resources/python.svg')),
{u'de': u'Legendeneintrag'},
u'CodeA',
u'type_code_list',
theme,
{'de': u'Subthema'},
u'Weiteres Thema',
view_service_id=1
)
result = renderer.format_legend_entry(legend_entry)
expected = {
'LegendText': renderer.get_multilingual_text({'de': 'Legendeneintrag'}),
'TypeCode': 'CodeA',
'TypeCodelist': 'type_code_list',
'Theme': renderer.format_theme(theme),
'SubTheme': 'Subthema',
'OtherTheme': 'Weiteres Thema'
}
if parameter.images:
expected.update({
'Symbol': ImageRecord(FileAdapter().read('tests/resources/python.svg')).encode()
})
else:
expected.update({
'SymbolRef': 'http://example.com/image/symbol/{theme_code}/{view_service_id}/{code}.svg'
.format(
theme_code='ContaminatedSites',
view_service_id=1,
code='CodeA'
)
})
assert isinstance(result, dict)
assert result == expected
def test_render(parameter, glossaries_input, glossaries_expected):
date = datetime.datetime.now()
with pyramid_oereb_test_config():
view_service = ViewServiceRecord(u'http://geowms.bl.ch', 1, 1.0,
{'de': u'http://geowms.bl.ch'}, None)
real_estate = RealEstateRecord(
u'RealEstate', u'BL', u'Liestal', 2829, 11395,
MultiPolygon([Polygon([(0, 0), (1, 1),
(1, 0)])]), u'http://www.geocat.ch',
u'1000', u'BL0200002829', u'CH775979211712')
real_estate.set_view_service(view_service)
real_estate.set_main_page_view_service(view_service)
office_record = OfficeRecord({'de': u'AGI'})
resolver = DottedNameResolver()
date_method_string = Config.get('extract').get('base_data').get(
'methods').get('date')
date_method = resolver.resolve(date_method_string)
av_update_date = date_method(real_estate)
base_data = Config.get_base_data(av_update_date)
av_provider_method_string = Config.get('extract').get('base_data').get(
'methods').get('provider')
av_provider_method = resolver.resolve(av_provider_method_string)
cadaster_state = date
theme = ThemeRecord(u'TEST', {'de': u'TEST TEXT'})
datasources = [DatasourceRecord(theme, date, office_record)]
plr_cadastre_authority = Config.get_plr_cadastre_authority()
embeddable = EmbeddableRecord(cadaster_state, plr_cadastre_authority,
av_provider_method(real_estate),
av_update_date, datasources)
extract = ExtractRecord(
real_estate,
ImageRecord('1'.encode('utf-8')),
ImageRecord('2'.encode('utf-8')),
ImageRecord('3'.encode('utf-8')),
ImageRecord('4'.encode('utf-8')),
office_record,
base_data,
embeddable,
exclusions_of_liability=[
ExclusionOfLiabilityRecord({'de': u'Haftungsausschluss'},
{'de': u'Test'})
],
glossaries=glossaries_input,
general_information={'de': u'Allgemeine Informationen'},
certification={'de': u'certification'},
certification_at_web={'de': u'certification_at_web'},
)
extract.qr_code = '1'.encode('utf-8')
extract.electronic_signature = 'Signature'
renderer = Renderer(DummyRenderInfo())
renderer._language = u'de'
renderer._request = MockRequest()
if parameter is None:
with pytest.raises(TypeError):
renderer._render(extract, None)
else:
result = renderer._render(extract, parameter)
assert isinstance(result, dict)
expected = {
'ExtractIdentifier':
extract.extract_identifier,
'CreationDate':
Base.date_time(extract.creation_date),
'ConcernedTheme': [],
'NotConcernedTheme': [],
'ThemeWithoutData': [],
'isReduced':
True,
'PLRCadastreAuthority':
renderer.format_office(office_record),
'BaseData':
renderer.get_multilingual_text(
Config.get_base_data(av_update_date)),
'RealEstate':
renderer.format_real_estate(real_estate),
'Certification': [{
'Language': 'de',
'Text': 'certification'
}],
'CertificationAtWeb': [{
'Language': 'de',
'Text': 'certification_at_web'
}],
'GeneralInformation': [{
'Language': 'de',
'Text': 'Allgemeine Informationen'
}],
'QRCode':
'1'.encode('utf-8'),
'ExclusionOfLiability': [{
'Title': [{
'Language': 'de',
'Text': 'Haftungsausschluss'
}],
'Content': [{
'Language': 'de',
'Text': 'Test'
}]
}],
'ElectronicSignature':
'Signature'
}
if glossaries_expected:
expected['Glossary'] = glossaries_expected
if parameter.images:
expected.update({
'LogoPLRCadastre':
base64.b64encode('1'.encode('utf-8')).decode('ascii'),
'FederalLogo':
base64.b64encode('2'.encode('utf-8')).decode('ascii'),
'CantonalLogo':
base64.b64encode('3'.encode('utf-8')).decode('ascii'),
'MunicipalityLogo':
base64.b64encode('4'.encode('utf-8')).decode('ascii'),
})
else:
expected.update({
'LogoPLRCadastreRef':
u'http://example.com/image/logo/oereb/de',
'FederalLogoRef':
u'http://example.com/image/logo/confederation/de',
'CantonalLogoRef':
u'http://example.com/image/logo/canton/de',
'MunicipalityLogoRef':
u'http://example.com/image/municipality/2829'
})
assert result == expected
def test_mapfish_print_entire_extract():
renderer = Renderer(DummyRenderInfo())
pdf_to_join = set()
printable_extract = extract()
renderer.convert_to_printable_extract(printable_extract, geometry(), pdf_to_join)
assert printable_extract == expected_printable_extract()
def test_format_plr(parameter):
with pyramid_oereb_test_config():
renderer = Renderer(DummyRenderInfo())
renderer._language = 'de'
renderer._params = parameter
renderer._request = MockRequest()
document = DocumentRecord('Law', law_status(), datetime.date.today(),
{u'de': u'Test Dokument'},
OfficeRecord({u'de': u'BUD'}),
{'de': 'http://mein.dokument.ch'})
if parameter.flavour == 'reduced':
documents = [document]
else:
documents = None
theme = ThemeRecord(u'ContaminatedSites', {u'de': u'Test theme'})
office = OfficeRecord({'de': 'Test Office'})
legend_entry = LegendEntryRecord(ImageRecord(
base64.b64encode('1'.encode('utf-8'))), {'de': 'Test'},
'CodeA',
'TypeCodeList',
theme,
view_service_id=1)
view_service = ViewServiceRecord('http://geowms.bl.ch', 1, 1.0,
{'de': u'http://geowms.bl.ch'},
[legend_entry])
geometry = GeometryRecord(law_status(), datetime.date.today(),
Point(1, 1))
plr = PlrRecord(theme, {'de': 'Test'},
law_status(),
datetime.date.today(),
office,
ImageRecord('1'.encode('utf-8')),
view_service, [geometry],
sub_theme={'de': 'Subtopic'},
other_theme='Additional topic',
type_code='CodeA',
type_code_list='TypeCodeList',
documents=documents,
view_service_id=1)
plr.part_in_percent = 0.5
if parameter.flavour == 'full':
with pytest.raises(ValueError):
renderer.format_plr([plr])
else:
result = renderer.format_plr([plr])
assert isinstance(result, list)
assert len(result) == 1
assert isinstance(result[0], dict)
expected = {
'Information': renderer.get_multilingual_text(plr.information),
'Theme': renderer.format_theme(plr.theme),
'Lawstatus': {
'Code': 'inForce',
'Text': {
'Language': 'de',
'Text': 'In Kraft'
}
},
'ResponsibleOffice':
renderer.format_office(plr.responsible_office),
'Map': renderer.format_map(plr.view_service),
'SubTheme': 'Subtopic',
'OtherTheme': 'Additional topic',
'TypeCode': 'CodeA',
'TypeCodelist': 'TypeCodeList',
'LegalProvisions': [renderer.format_document(document)],
'PartInPercent': 0.5
}
if parameter.images:
expected.update({
'Symbol':
base64.b64encode('1'.encode('utf-8')).decode('ascii')
})
else:
expected.update({
'SymbolRef':
'http://example.com/image/symbol/{theme}/{view_service_id}/{code}'
.format(theme='ContaminatedSites',
view_service_id=1,
code='CodeA')
})
assert result[0] == expected
def test_default_wms_url_param_config():
renderer = Renderer(DummyRenderInfo())
config = renderer.get_wms_url_params()
# Do the check for this test. Value should be the default setting.
assert config == {'TRANSPARENT': 'true'}
def test_call():
renderer = Base(DummyRenderInfo())
assert isinstance(renderer.info, DummyRenderInfo)
assert renderer.info.name == 'test'
