def _make_entry(self, name='testentry', region='testregion', amount=1.0,
dataset=None, **kwargs):
if dataset is None:
dataset = self._make_dataset()
entry = Entry(name=name, region=region, amount=amount,
dataset=dataset, **kwargs)
entry.save()
return entry
def test_loader_checks_duplicate_entries(self):
loader = self._make_loader(unique_keys=['name'])
self._make_entry(loader, name=u'Test Entry')
second_entry = Entry(name=u'Test Entry',
dataset=loader.dataset.to_ref_dict())
second_entry.save()
h.assert_raises(ValueError, self._make_loader,
unique_keys=['name'])
def test_successful_import(self):
data = csv_fixture("successful_import")
model = csv_fixture_model()
importer = CSVImporter(data, model)
importer.run()
dataset = Dataset.find_one()
h.assert_true(dataset is not None, "Dataset should not be None")
h.assert_equal(dataset.name, "test-csv")
entries = list(Entry.find({"dataset.name": dataset.name}))
h.assert_equal(len(entries), 4)
entry = Entry.find_one({"provenance.line": 2})
h.assert_true(entry is not None, "Entry with name could not be found")
h.assert_equal(entry.amount, 130000.0)
def _make_entry(self, loader, **kwargs):
from openspending.model import Entry
entry = {"name": "Test Entry", "amount": 1000.00, "time": {"from": {"year": 2009, "day": 20090101}}}
entry.update(kwargs)
if "from" not in entry:
entry["from"] = loader.create_entity(u"Test From Entity")
if "to" not in entry:
entry["to"] = loader.create_entity(u"Test To Entity")
spec = loader.create_entry(**entry)
new = Entry.find_one(spec)
return new
def test_create_entry_returns_query_spec(self):
from bson import ObjectId
loader = self._make_loader()
entry = {'name': 'one',
'amount': 1000.00,
'from': loader.create_entity(u'From Entity'),
'to': loader.create_entity(u'To Entity'),
'first': u'first',
'second': u'second',
'extra': u'extra'}
query_spec = loader.create_entry(**entry)
h.assert_true(isinstance(query_spec['_id'], ObjectId))
fetched_entry = Entry.find_one(query_spec)
h.assert_equal(fetched_entry['name'], 'one')
def flag(self, id):
entry = Entry.by_id(id)
if not entry:
abort(404, _('Sorry, there is no entry with code %r') % id)
if not c.account:
abort(403, _('You need to have an account'))
flag_name = request.params.get("flag", None)
result = False
try:
result = logic.flag.inc_flag(entry, flag_name, c.account)
except KeyError:
abort(400, _("Unknown Flag"))
if not result:
abort(409, _("This account already flagged this entry"))
if request.headers.get("X-Requested-With", None) == "XMLHttpRequest":
return "{'status': 'OK'}"
return redirect(url_for(controller="entry", action="view", id=id))
def test_successful_import_with_simple_testdata(self):
data = csv_fixture("simple")
model = csv_fixture_model(name="simple")
importer = CSVImporter(data, model)
importer.run()
h.assert_equal(importer.errors, [])
dataset = Dataset.find_one()
h.assert_true(dataset is not None, "Dataset should not be None")
entries = list(Entry.find({"dataset.name": dataset.name}))
h.assert_equal(len(entries), 5)
entry = entries[0]
h.assert_equal(entry["from"]["label"], "Test From")
h.assert_equal(entry["to"]["label"], "Test To")
h.assert_equal(entry["time"]["unparsed"], "2010-01-01")
h.assert_equal(entry["amount"], 100.00)
def command(self):
super(GraphCommand, self).command()
if not nx:
print "Could not load 'networkx' module, which is needed for graph"\
" command.\nHave you tried `pip install networkx`?"
return 1
if len(self.args) != 2:
GraphCommand.parser.print_help()
return 1
dataset_name, file_name = self.args
g = nx.DiGraph()
edges = {}
def _edge(f, t, w):
ew = edges.get((f, t), 0.0)
edges[(f, t)] = ew + w
for entry in Entry.find({"dataset.name": dataset_name}):
to = entry.get('to')
if to.get('name') not in g:
g.add_node(to.get('name'), label=to.get('label'),
type='entity', country=to.get('country', ''))
from_ = entry.get('from')
if from_.get('name') not in g:
g.add_node(from_.get('name'), label=from_.get('label'),
type='entity', country=from_.get('country', ''))
_edge(from_.get('name'), to.get('name'), entry.get('amount'))
for k, v in entry.items():
if k in ['time', 'dataset', 'from', 'to'] or not isinstance(v, dict):
continue
if v.get('name') not in g:
_type = 'classifier'
if isinstance(v.get('ref'), dict):
_type = v.get('ref').get('$ref')
g.add_node(v.get('name'), label=v.get('label', v.get('name')),
type=_type)
#_edge(v.get('name'), to.get('name'), entry.get('amount'))
#_edge(from_.get('name'), v.get('name'), entry.get('amount'))
for (f, t), w in edges.items():
g.add_edge(f, t, weight=w)
nx.write_graphml(g, file_name)
def _test_dataset_dir(self, dir):
data_csv = h.fixture_file("csv_import/%s/data.csv" % dir)
mapping_json = h.fixture_file("csv_import/%s/mapping.json" % dir)
dataset_name = unicode(dir)
model = csv_fixture_model()
model["mapping"] = json.load(mapping_json)
model["dataset"]["name"] = dataset_name
lines = self.count_lines_in_stream(data_csv) - 1
importer = CSVImporter(data_csv, model)
importer.run()
assert len(importer.errors) == 0, "Import should not throw errors"
# check correct number of entries
entries = Entry.find({"dataset.name": dataset_name})
assert entries.count() == lines
def test_03_changeset_auto_created(self):
c1 = Changeset(author='me')
e1 = Entry(name='infinitejest', label='abc')
e1.save(c1)
out = Changeset.youngest()
co = out.manifest[0]
assert co.object_id == ['entry', e1.id]
assert co.data['name'] == 'infinitejest'
oute1 = Entry.by_id(e1.id)
oute1.name = 'hamlet'
ec2 = Entry(name='horatio')
cs2 = Changeset(author='you')
oute1.save(cs2)
ec2.save(cs2)
out = Changeset.youngest()
assert len(out.manifest) == 2
co = out.manifest[0]
assert co.object_id == ['entry', e1.id]
assert co.data['name'] == 'hamlet'
def times(dataset, time_axis):
return sorted(Entry.find({'dataset.name': dataset}).distinct(time_axis))
