class ArchiveItemDetailView(TestCase):
def setUp(self):
self.archive_item = ArchiveItemFactory()
def test_archiveitem_empty(self):
obj = ArchiveItemFactory()
response = self.client.get(obj.get_absolute_url())
self.assertContains(response, obj.dataset.get_absolute_url())
self.assertContains(response, obj.dataset.source.get_absolute_url())
self.assertContains(response, obj.tablename)
self.assertNotContains(response, "Rule")
self.assertNotContains(response, settings.REFINE_EXTERNAL_HOST)
def test_archiveitem_with_refine_data(self):
obj = ArchiveItemFactory(refine_url="http://blablah.com",
refine_projectid="123213")
response = self.client.get(obj.get_absolute_url())
self.assertContains(response, obj.refine_url)
def test_archiveitem_with_rule(self):
obj = ArchiveItemFactory(rule=RuleFactory())
response = self.client.get(obj.get_absolute_url())
self.assertContains(response, obj.rule.rule)
def test_archiveitem_edit_rule(self):
obj = ArchiveItemFactory(rule=RuleFactory())
new_rule = '[{"that": "is a brand new rule :D"}]'
response = self.client.post(obj.get_absolute_url(), {"rule": new_rule},
follow=True)
self.assertContains(
response,
"[\n {\n "that": "is a brand new rule " +
":D"\n }\n]")
def test_contains_sparql_metagraph_query(self):
from webui.cnmain.utils import get_sparql_query_metagraph_info
query = get_sparql_query_metagraph_info(self.archive_item)
response = self.client.get(self.archive_item.get_absolute_url())
self.assertContains(response,
'<a href="/sparql/?query=' + quote_plus(query))
def test_contains_sparql_datagraph_raw_query(self):
from webui.cnmain.utils import get_sparql_query_graph
query = get_sparql_query_graph(self.archive_item.datagraph_raw_name)
response = self.client.get(self.archive_item.get_absolute_url())
self.assertContains(response,
'<a href="/sparql/?query=' + quote_plus(query))
def test_contains_sparql_datagraph_mapped_query(self):
from webui.cnmain.utils import get_sparql_query_graph
query = get_sparql_query_graph(self.archive_item.datagraph_mapped_name)
response = self.client.get(self.archive_item.get_absolute_url())
self.assertContains(response,
'<a href="/sparql/?query=' + quote_plus(query))
def test_archiveitem_with_refine_data(self):
obj = ArchiveItemFactory(
refine_url="http://blablah.com", refine_projectid="123213"
)
response = self.client.get(obj.get_absolute_url())
self.assertContains(response, obj.refine_url)
def setUp(self):
self.archiveitem = ArchiveItemFactory()
self.aggregator = AggregatorFactory()
AggregatorArchiveItem.objects.create(
aggregator=self.aggregator,
archiveitem=self.archiveitem,
)
self.url = reverse('archiveitem_aggregator_del',
args=(self.archiveitem.pk, ))
def test_archiveitem_empty(self):
obj = ArchiveItemFactory()
response = self.client.get(obj.get_absolute_url())
self.assertContains(response, obj.dataset.get_absolute_url())
self.assertContains(response, obj.dataset.source.get_absolute_url())
self.assertContains(response, obj.tablename)
self.assertNotContains(response, "Rule")
self.assertNotContains(response, settings.REFINE_EXTERNAL_HOST)
def test_archiveitem_empty(self):
obj = ArchiveItemFactory()
response = self.client.get(obj.get_absolute_url())
self.assertContains(response, obj.dataset.get_absolute_url())
self.assertContains(response, obj.dataset.source.get_absolute_url())
self.assertContains(response, obj.tablename)
self.assertNotContains(response, "Rule")
self.assertNotContains(response, settings.REFINE_EXTERNAL_HOST)
def test_archiveitem_edit_rule(self):
obj = ArchiveItemFactory(rule=RuleFactory())
new_rule = '[{"that": "is a brand new rule :D"}]'
response = self.client.post(obj.get_absolute_url(), {"rule": new_rule},
follow=True)
self.assertContains(
response,
"[\n {\n "that": "is a brand new rule " +
":D"\n }\n]")
def test_contains_archiveitems(self):
item1 = ArchiveItemFactory()
item2 = ArchiveItemFactory()
for item in (item1, item2):
AggregatorArchiveItem.objects.create(
aggregator=self.aggregator,
archiveitem=item
)
response = self.client.get(self.aggregator.get_absolute_url())
self.assertContains(response, item1.get_absolute_url())
self.assertContains(response, item2.get_absolute_url())
def test_archiveitem_edit_rule(self):
obj = ArchiveItemFactory(rule=RuleFactory())
new_rule = '[{"that": "is a brand new rule :D"}]'
response = self.client.post(
obj.get_absolute_url(), {"rule": new_rule}, follow=True
)
self.assertContains(
response,
"[\n {\n "that": "is a brand new rule " +
":D"\n }\n]"
)
def test_archiveitem_sync(self):
from refine.refine import IllegalRuleCheckSum
rule = {"amazing": "rule"}
obj = ArchiveItemFactory(rule=RuleFactory(hash="LOL", rule=rule),
file_hash="WUT")
with self.assertRaises(IllegalRuleCheckSum):
obj.get_refine_rule()
self.client.post(
reverse("archiveitem_refine_sync", kwargs={'pk': obj.pk}))
obj = ArchiveItem.objects.get(pk=obj.pk)
self.assertEquals(obj.get_refine_rule(), rule)
class ArchiveItemAggregatorDelView(TestCase):
def setUp(self):
self.archiveitem = ArchiveItemFactory()
self.aggregator = AggregatorFactory()
AggregatorArchiveItem.objects.create(
aggregator=self.aggregator,
archiveitem=self.archiveitem,
)
self.url = reverse('archiveitem_aggregator_del',
args=(self.archiveitem.pk, ))
def test_del(self):
self.client_login('admin')
self.assertEquals(len(self.archiveitem.aggregators.all()), 1)
post_data = {"aggregator": self.aggregator.pk}
response = self.client.post(self.url, data=post_data, follow=True)
self.assertContains(response, 'success')
self.assertEquals(len(self.archiveitem.aggregators.all()), 0)
def test_del_invalid(self):
self.client_login('admin')
self.assertEquals(len(self.archiveitem.aggregators.all()), 1)
post_data = {"aggregator": 99999}
response = self.client.post(self.url, data=post_data, follow=True)
self.assertEquals(len(self.archiveitem.aggregators.all()), 1)
self.assertContains(response, 'error')
response = self.client.get(self.archiveitem.get_absolute_url())
self.assertContains(response, self.aggregator.name)
class ArchiveItemAggregatorDelView(TestCase):
def setUp(self):
self.archiveitem = ArchiveItemFactory()
self.aggregator = AggregatorFactory()
AggregatorArchiveItem.objects.create(
aggregator=self.aggregator,
archiveitem=self.archiveitem,
)
self.url = reverse('archiveitem_aggregator_del',
args=(self.archiveitem.pk, ))
def test_del(self):
self.client_login('admin')
self.assertEquals(len(self.archiveitem.aggregators.all()), 1)
post_data = {"aggregator": self.aggregator.pk}
response = self.client.post(self.url, data=post_data, follow=True)
self.assertContains(response, 'success')
self.assertEquals(len(self.archiveitem.aggregators.all()), 0)
def test_del_invalid(self):
self.client_login('admin')
self.assertEquals(len(self.archiveitem.aggregators.all()), 1)
post_data = {"aggregator": 99999}
response = self.client.post(self.url, data=post_data, follow=True)
self.assertEquals(len(self.archiveitem.aggregators.all()), 1)
self.assertContains(response, 'error')
response = self.client.get(self.archiveitem.get_absolute_url())
self.assertContains(response, self.aggregator.name)
def test_archiveitem_sync(self):
from refine.refine import IllegalRuleCheckSum
rule = {"amazing": "rule"}
obj = ArchiveItemFactory(
rule=RuleFactory(hash="LOL", rule=rule),
file_hash="WUT"
)
with self.assertRaises(IllegalRuleCheckSum):
obj.get_refine_rule()
self.client.post(
reverse("archiveitem_refine_sync", kwargs={'pk': obj.pk})
)
obj = ArchiveItem.objects.get(pk=obj.pk)
self.assertEquals(obj.get_refine_rule(), rule)
def setUp(self):
self.archiveitem = ArchiveItemFactory()
self.aggregator = AggregatorFactory()
AggregatorArchiveItem.objects.create(
aggregator=self.aggregator,
archiveitem=self.archiveitem,
)
self.url = reverse('archiveitem_aggregator_del',
args=(self.archiveitem.pk, ))
def test_post(self):
self.client_login('admin')
archiveitem = ArchiveItemFactory()
self.post_data['archiveitems'] = [archiveitem.pk]
print self.post_data
response = self.client.post(self.update_url, data=self.post_data)
self.assertRedirects(response, self.aggregator.get_absolute_url())
aggregator = Aggregator.objects.get(pk=self.aggregator.pk)
self.assertEqual(aggregator.name, self.post_data['name'])
self.assertEqual(aggregator.description, self.post_data['description'])
self.assertIn(archiveitem, aggregator.archiveitems.all())
def test_archiveitem_csv_ok(self):
obj = ArchiveItemFactory()
with patch.object(ArchiveItem,
'data',
return_value=((x, x, 42) for x in range(20))):
csv_url = reverse("archiveitem_csv", kwargs={"pk": obj.pk})
response = self.client.get(csv_url)
self.assertEqual(response['Content-Type'], 'text/csv')
self.assertContains(response, '1,1,42')
self.assertEqual(len(response.content.split("\n")), 21)
def test_contains_archiveitems(self):
item1 = ArchiveItemFactory()
item2 = ArchiveItemFactory()
for item in (item1, item2):
AggregatorArchiveItem.objects.create(aggregator=self.aggregator,
archiveitem=item)
response = self.client.get(self.aggregator.get_absolute_url())
self.assertContains(response, item1.get_absolute_url())
self.assertContains(response, item2.get_absolute_url())
def test_post(self):
self.client_login('admin')
archiveitem = ArchiveItemFactory()
self.post_data['archiveitems'] = [archiveitem.pk]
response = self.client.post(self.update_url, data=self.post_data)
self.assertRedirects(response, self.aggregator.get_absolute_url())
aggregator = Aggregator.objects.get(pk=self.aggregator.pk)
self.assertEqual(
aggregator.silk_rule.strip().replace("\n", ""),
'<LinkageRule> '
'<Compare id="unnamed_5" metric="levenshtein" required="false" '
'threshold="0.0" weight="1"> '
'<TransformInput function="lowerCase" id="unnamed_3"> '
'<Input id="unnamed_1" path="?a/sd:Event#name" /> '
'</TransformInput> <TransformInput function="lowerCase" '
'id="unnamed_4"> '
'<Input id="unnamed_2" path="?b/sd:Event#name" /> '
'</TransformInput> <Param name="minChar" value="0" />'
' <Param name="maxChar" value="z" /> '
'</Compare> </LinkageRule>'.strip())
def test_can_silk_rules_file_is_valid(self):
import xml.etree.ElementTree as ET
from django.template.loader import render_to_string
archive_item = ArchiveItemFactory()
AggregatorArchiveItem.objects.create(
aggregator=self.aggregator,
archiveitem=archive_item
)
self.aggregator.silk_rule = \
'<LinkageRule><smart data="now" /></LinkageRule>'
self.aggregator.save()
output_filename = 'a_really_cool_filename.thm'
context = {
'aggregator': self.aggregator,
'sd_prefix': settings.TRIPLE_DATABASE['PREFIXES']['sdv1'],
'sparql_endpoint': get_virtuoso_endpoint(),
'archive_item': archive_item,
'output_filename': output_filename,
'mastergraph_host': settings.TRIPLE_DATABASE_MASTER['HOST'],
'mastergraph_port':
settings.TRIPLE_DATABASE_MASTER['KWARGS']['rexpro_port'],
'mastergraph_graphname':
settings.TRIPLE_DATABASE_MASTER['KWARGS']['graph'],
'resource_namespace':
settings.TRIPLE_DATABASE_MASTER['PREFIXES']['sdres'],
}
tree = ET.fromstring(render_to_string(
'controller/aggregator/silk_rules.xml', context
))
self.assertIn(
(settings.TRIPLE_DATABASE['PREFIXES']['sdv1'], 'sd'),
[(x.get('namespace'), x.get('id'))
for x in tree.findall('.//Prefix')]
)
# check datasources
datasources_dom = tree.findall('.//DataSource')
self.assertEqual(len(datasources_dom), 2)
self.assertEqual(datasources_dom[0].get('id'), 'master-graph')
mastergraph, datasource = datasources_dom
# check datasource endpoints
self.assertEqual(
get_virtuoso_endpoint(),
datasource.find('Param[@name="endpointURI"]').get("value"),
)
# check datasources graph names
self.assertEqual(
mastergraph.find('Param[@name="graph"]').get('value'),
settings.TRIPLE_DATABASE_MASTER["KWARGS"]["graph"]
)
self.assertEqual(
archive_item.datagraph_mapped_name,
datasource.find('Param[@name="graph"]').get("value")
)
# check tasks
datasource_id = datasource.get('id')
rules = tree.findall('.//Interlink')
self.assertEqual(len(rules), 1)
self.assertEqual(datasource_id, rules[0].get('id'))
# check rules parameters
rule = rules[0]
self.assertEqual(
rule.find('.//SourceDataset').get('dataSource'),
datasource_id
)
self.assertEqual(
rule.find('.//TargetDataset').get('dataSource'),
'master-graph'
)
self.assertEqual(
ET.tostring(rule.find('.//LinkageRule')).strip(),
self.aggregator.silk_rule
)
self.assertEqual(
rule.find('.//SourceDataset').find('RestrictTo').text.strip(),
'?a rdf:type <{}> .'.format(self.aggregator.entity_type)
)
self.assertEqual(
rule.find('.//TargetDataset').find('RestrictTo').text.strip(),
'b -> {}'.format(self.aggregator.vertex_selector)
)
self.assertIsNone(rule.find('.//Filter').text)
output = rule.find('.//Outputs').find('Output')
self.assertEqual(output.get('type'), 'file')
self.assertEqual(output.findall('Param')[0].get('name'), 'file')
self.assertEqual(
output.findall('Param')[0].get('value'), output_filename)
self.assertEqual(output.findall('Param')[1].get('name'), 'format')
self.assertEqual(output.findall('Param')[1].get('value'), 'ntriples')
def setUp(self):
self.archive_item = ArchiveItemFactory()
def test_archiveitem_with_refine_data(self):
obj = ArchiveItemFactory(refine_url="http://blablah.com",
refine_projectid="123213")
response = self.client.get(obj.get_absolute_url())
self.assertContains(response, obj.refine_url)
def test_archiveitem_with_rule(self):
obj = ArchiveItemFactory(rule=RuleFactory())
response = self.client.get(obj.get_absolute_url())
self.assertContains(response, obj.rule.rule)
def test_archiveitem_with_rule(self):
obj = ArchiveItemFactory(rule=RuleFactory())
response = self.client.get(obj.get_absolute_url())
self.assertContains(response, obj.rule.rule)
def test_archiveitem_csv_no_table(self):
obj = ArchiveItemFactory()
csv_url = reverse("archiveitem_csv", kwargs={"pk": obj.pk})
response = self.client.get(csv_url)
self.assertEqual(response.status_code, 404)
def test_silk_project_file_is_valid(self):
import xml.etree.ElementTree as ET
self.client_login('admin')
item1 = ArchiveItemFactory()
item2 = ArchiveItemFactory()
for item in (item1, item2):
AggregatorArchiveItem.objects.create(aggregator=self.aggregator,
archiveitem=item)
response = self.client.get(self.export_url)
tree = ET.fromstring(response.content)
self.assertIn((settings.TRIPLE_DATABASE['PREFIXES']['sdv1'], 'sd'),
[(x.get('namespace'), x.get('id'))
for x in tree.findall('.//Prefix')])
# check datasources
datasources = tree.findall('.//DataSource')
self.assertEqual(len(datasources), 3)
self.assertEqual(datasources[0].get('id'), 'master-graph')
mastergraph = datasources[0]
datasources = datasources[1:]
# check datasources endpoints
self.assertEqual(
mastergraph.find('Param[@name="host"]').get('value'),
settings.TRIPLE_DATABASE_MASTER['HOST'])
self.assertEqual([get_virtuoso_endpoint()] * 2, [
x.find('Param[@name="endpointURI"]').get("value")
for x in datasources
])
# check datasources graph names
self.assertEqual(
mastergraph.find('Param[@name="graph"]').get('value'),
settings.TRIPLE_DATABASE_MASTER["KWARGS"]["graph"])
self.assertEqual(
[item1.datagraph_mapped_name, item2.datagraph_mapped_name],
[x.find('Param[@name="graph"]').get("value") for x in datasources])
# check tasks
datasource_ids = [x.get('id') for x in datasources]
tasks = tree.findall('.//LinkingTask')
self.assertEqual(len(tasks), 2)
self.assertEqual(datasource_ids,
[x.find('.//Interlink').get('id') for x in tasks])
# check task parameters
for datasource_id, task in zip(datasource_ids, tasks):
self.assertEqual(
task.find('.//SourceDataset').get('dataSource'), datasource_id)
self.assertEqual(
task.find('.//TargetDataset').get('dataSource'),
'master-graph')
self.assertEqual(
task.find('.//SourceDataset').find('RestrictTo').text.strip(),
'?a rdf:type <{}> .'.format(self.aggregator.entity_type))
self.assertEqual(
task.find('.//TargetDataset').find('RestrictTo').text.strip(),
'b -> {}'.format(self.aggregator.vertex_selector))
self.assertIsNone(task.find('.//LinkageRule').text)
self.assertIsNone(task.find('.//Filter').text)
self.assertIsNone(task.find('.//Outputs').text)
self.assertIsNone(task.find('.//PositiveEntities').text)
self.assertIsNone(task.find('.//NegativeEntities').text)
self.assertIsNone(
task.find('.//Alignment/').find('{}Alignment'.format(
'{http://knowledgeweb.'
'semanticweb.org'
'/heterogeneity/alignment#}')).text)
class ArchiveItemDetailView(TestCase):
def setUp(self):
self.archive_item = ArchiveItemFactory()
def test_archiveitem_empty(self):
obj = ArchiveItemFactory()
response = self.client.get(obj.get_absolute_url())
self.assertContains(response, obj.dataset.get_absolute_url())
self.assertContains(response, obj.dataset.source.get_absolute_url())
self.assertContains(response, obj.tablename)
self.assertNotContains(response, "Rule")
self.assertNotContains(response, settings.REFINE_EXTERNAL_HOST)
def test_archiveitem_with_refine_data(self):
obj = ArchiveItemFactory(
refine_url="http://blablah.com", refine_projectid="123213"
)
response = self.client.get(obj.get_absolute_url())
self.assertContains(response, obj.refine_url)
def test_archiveitem_with_rule(self):
obj = ArchiveItemFactory(rule=RuleFactory())
response = self.client.get(obj.get_absolute_url())
self.assertContains(response, obj.rule.rule)
def test_archiveitem_edit_rule(self):
obj = ArchiveItemFactory(rule=RuleFactory())
new_rule = '[{"that": "is a brand new rule :D"}]'
response = self.client.post(
obj.get_absolute_url(), {"rule": new_rule}, follow=True
)
self.assertContains(
response,
"[\n {\n "that": "is a brand new rule " +
":D"\n }\n]"
)
def test_contains_sparql_metagraph_query(self):
from webui.cnmain.utils import get_sparql_query_metagraph_info
query = get_sparql_query_metagraph_info(self.archive_item)
response = self.client.get(self.archive_item.get_absolute_url())
self.assertContains(
response, '<a href="/sparql/?query=' + quote_plus(query)
)
def test_contains_sparql_datagraph_raw_query(self):
from webui.cnmain.utils import get_sparql_query_graph
query = get_sparql_query_graph(self.archive_item.datagraph_raw_name)
response = self.client.get(self.archive_item.get_absolute_url())
self.assertContains(
response, '<a href="/sparql/?query=' + quote_plus(query)
)
def test_contains_sparql_datagraph_mapped_query(self):
from webui.cnmain.utils import get_sparql_query_graph
query = get_sparql_query_graph(self.archive_item.datagraph_mapped_name)
response = self.client.get(self.archive_item.get_absolute_url())
self.assertContains(
response, '<a href="/sparql/?query=' + quote_plus(query)
)
def test_get_rule_valid(self):
obj = ArchiveItemFactory(rule=RuleFactory())
self.assertEqual(obj.get_refine_rule(), obj.rule.rule)
def test_get_rule_invalid(self):
from refine.refine import IllegalRuleCheckSum
obj = ArchiveItemFactory(rule=RuleFactory(hash="pippero"))
with self.assertRaises(IllegalRuleCheckSum):
obj.get_refine_rule()
def test_get_rule_none(self):
obj = ArchiveItemFactory()
self.assertIsNone(obj.get_refine_rule())
def setUp(self):
self.archiveitem = ArchiveItemFactory()
self.aggregator = AggregatorFactory()
self.url = reverse('archiveitem_aggregator_add',
args=(self.archiveitem.pk, ))
def handle(self, *args, **options):
"""
entry point
"""
from django.contrib.sites.models import Site
site = Site.objects.get()
site.name = 'controller'
site.domain = 'localhost:8001'
site.save()
AdminFactory()
trentinocultura = SourceFactory(
name='trentinocultura',
description='description description',
scraper_name='trentinocultura',
scraper_api_key='',
)
DatasetFactory(
source=trentinocultura,
name='Trentinocultura agenda',
url='http://www.trentinocultura.net/asp_cat/main.asp?IDProspettiva'
'=35&SearchType=AGENDA_SEARCH&Pag=%d&TipoVista=AGENDA&cmd=new',
description='Eventi in Trentino',
download='scraper:trentinocultura:trentinocultura',
curator='Federico Scrinzi',
license='All rights reserved',
other_meta='{}',
bounding_box='10.3817591116112,45.6730626059259,'
'12.4775685651704,47.0917759206089',
)
ingiro_local = SourceFactory(
name='in-giro (locale)',
description='i dati dello scraper di in-giro, ma in locale (file '
'webui.scheduler.tests.data/in-giro.zip) utile per'
'test, ma anche per boh, altro? =)',
)
DatasetFactory(
source=ingiro_local,
name='eventi-e-poi-ingiro',
url='http://in-giro.net',
description='Eventi e POI presi da in-giro',
download='http://testserver/in-giro.zip',
curator='Ciccio Pasticcio',
license='All rights reserved',
other_meta='{}',
)
bgg_source = SourceFactory(
name='BoardGameGeek (test)',
description='pochi dati per testare il matching su silk'
)
bgt_source = SourceFactory(
name='BoardGameTournament (test)',
description='pochi dati per testare il matching su silk',
)
bgg_dataset = DatasetFactory(
source=bgg_source,
name='boardgamegeek-games',
url='http://boardgamegeek.com',
description='Lista di boardgames presi da boardgamegeek',
download='https://dl.dropbox.com/u/3435878/boardgamegeek.csv',
curator='Stefano Parmesan',
license='All rights reserved',
other_meta='{}',
)
bgt_dataset = DatasetFactory(
source=bgt_source,
name='boardgametournament-games',
url='http://boardgametournament.com',
description='Lista di boardgames presi da boardgametournament',
download='https://dl.dropbox.com/u/3435878/'
'boardgametournament.csv',
curator='Stefano Parmesan',
license='All rights reserved',
other_meta='{}',
)
DatasetFactory(
source=bgt_source,
name='boardgametournament-games-xls',
url='http://boardgametournament.com',
description='Lista di boardgames presi da boardgametournament',
download='https://dl.dropbox.com/u/3435878/'
'boardgametournament.xls',
curator='Stefano Parmesan',
license='All rights reserved',
encoding="utf8",
other_meta='{}',
)
DatasetFactory(
source=bgt_source,
name='boardgametournament-games-xlsx',
url='http://boardgametournament.com',
description='Lista di boardgames presi da boardgametournament',
download='https://dl.dropbox.com/u/3435878/'
'boardgametournament.xlsx',
curator='Stefano Parmesan',
license='All rights reserved',
encoding="utf8",
other_meta='{}',
)
with open(get_test_file('boardgamegeek_refine_rules.json')) as fin:
rule = ''.join(fin.readlines())
bgg_archiveitem = ArchiveItemFactory(
dataset=bgg_dataset,
file_target='boardgamegeek.csv',
file_hash='ea6ee15e9b052171db4f96743aa11425',
rule=RuleFactory(
hash="ea6ee15e9b052171db4f96743aa11425",
rule=rule,
)
)
with open(get_test_file('boardgametournament_refine_rules.json')) \
as fin:
rule = ''.join(fin.readlines())
bgt_archiveitem = ArchiveItemFactory(
dataset=bgt_dataset,
file_target='boardgametournament.csv',
file_hash='be864f716b6a7716f3b1c2254f4f5eea',
rule=RuleFactory(
hash="be864f716b6a7716f3b1c2254f4f5eea",
rule=rule,
)
)
with open(get_test_file('boardgames_aggregator_silk_rules.xml')) \
as fin:
rule = ''.join(fin.readlines())
aggregator = AggregatorFactory(
name='BoardGames',
description='Un dataset di giochi da tavolo',
silk_rule=rule,
entity_type='{}BoardGame'.format(
settings.TRIPLE_DATABASE['PREFIXES']['sdv1']
),
vertex_selector="g.V('type', 'sd$BoardGame')%limit.id.fill(m)",
)
for archiveitem in (bgg_archiveitem, bgt_archiveitem):
AggregatorArchiveItem.objects.create(
aggregator=aggregator,
archiveitem=archiveitem,
)
osm_source = SourceFactory(
name='OSM (test)',
description='pochi dati per testare lo slicer'
)
osm_dataset = DatasetFactory(
source=osm_source,
name='osm-dataset',
url='http://openstreetmap.org',
download='https://dl.dropbox.com/u/781790/osm-10nodes.csv',
curator='Davide setti',
license='CC PUCCI',
)
with open(get_test_file('osm-refine-rules.json')) as fin:
rule = ''.join(fin.readlines())
osm_archiveitem = ArchiveItemFactory(
dataset=osm_dataset,
file_target='osm-10nodes.csv',
file_hash='e6f4a5c5f5fe12765f7b3ca04ab7a82d',
rule=RuleFactory(
hash="e6f4a5c5f5fe12765f7b3ca04ab7a82d",
rule=rule,
)
)
poi_aggregator = AggregatorFactory(
name='POI',
description='POI aggregator',
entity_type=settings.TRIPLE_DATABASE['PREFIXES']['sdv1'] + 'POI',
vertex_selector="g.V('type', 'sd$POI')%limit.id.fill(m)"
)
AggregatorArchiveItem.objects.create(
aggregator=poi_aggregator,
archiveitem=osm_archiveitem,
)
DatasetFactory(
source=osm_source,
name='Aeroporti',
url='http://dati.trentino.it',
description='Aeroporti del trentino, file SHP',
download='http://testserver/aeroporti_tn.zip',
curator='Federico Scrinzi',
license='Open Data',
other_meta='{}',
)
strange_source = SourceFactory(
name='Strange or malformed (test)',
description='pochi dati con valori strani tipo None',
)
DatasetFactory(
source=strange_source,
name='strange symbols',
url='http://testserver/',
description='Some strange symbols',
download='http://testserver/strangesymbols.csv',
curator='Federico Scrinzi',
license='Open Data',
other_meta='{}',
)
DatasetFactory(
source=strange_source,
name='looks like ascii',
url='http://testserver/',
description="file that looks like ascii but it's UTF8",
download='http://testserver/lookslikeascii.csv',
curator='Federico Scrinzi',
license='Open Data',
other_meta='{}',
)
def setUp(self):
self.archive_item = ArchiveItemFactory()
def test_index_unsynced(self):
obj = ArchiveItemFactory(file_hash='thesame',
rule=RuleFactory(hash='notthesame'))
response = self.client.get('/')
self.assertContains(response, obj.file_target)
def test_index_archiveitem_no_rule(self):
obj = ArchiveItemFactory(rule=None)
response = self.client.get('/')
self.assertNotContains(response, obj.file_target)
