def test_export_instance(self):
ed = importexport.export_data({
u'include_instance': True,
u'include_user': True,
u'user_personal': True,
})
# Test that we don't spill non-representable objects by accident
ex = importexport.render.render(ed,
u'json',
u'(title)',
response=_MockResponse())
e = importexport.parse.read_data(io.BytesIO(ex))
self.assertTrue(u'instance' in e)
self.assertTrue(len(e[u'instance']) >= 1)
self.assertTrue(self.instance.key in e[u'instance'])
idata = e[u'instance'][self.instance.key]
self.assertEqual(idata[u'label'], self.instance.label)
self.assertEqual(idata[u'key'], self.instance.key)
user_id = idata[u'creator']
assert user_id
self.assertTrue(isinstance(user_id, (str, unicode)))
self.assertEqual(e[u'user'][user_id][u'user_name'], self.u2.user_name)
self.assertEqual(idata[u'adhocracy_type'], u'instance')
def test_importexport_instance(self):
opts = {
u'include_instance': True
}
ed = importexport.export_data(opts)
testdata = ed[u'instance'][self.instance.key]
testdata[u'key'] += testtools.tt_make_str() + u'A' # Test uppercase
ed[u'instance'] = {testdata[u'key']: testdata}
importexport.import_data(opts, ed)
imported_instance = model.Instance.find(testdata[u'key'])
self.assertTrue(imported_instance)
INSTANCE_PROPS = [
u'label', u'creator', u'description', u'required_majority',
u'activation_delay',
u'create_time', u'access_time', u'delete_time',
u'default_group_id', u'allow_adopt', u'allow_delegate',
u'allow_propose', u'allow_index', u'hidden', u'locale', u'css',
u'frozen', u'milestones', u'use_norms', u'require_selection',
u'is_authenticated', u'hide_global_categories',
u'editable_comments_default', u'editable_proposals_default',
u'require_valid_email', u'allow_thumbnailbadges',
u'thumbnailbadges_height', u'thumbnailbadges_width',
]
for p in INSTANCE_PROPS:
imported = getattr(imported_instance, p)
expected = getattr(self.instance, p)
msg = (u'Instance.%s: Got %r, but expected %r' %
(p, imported, expected))
self.assertEqual(expected, imported, msg)
def test_export_anonymous(self):
e = importexport.export_data(dict(include_user=True))
users = e[u"user"]
self.assertTrue(len(users) >= 2)
self.assertTrue(all(len(u) == 0 for u in users.values()))
self.assertTrue(not any(self.u1.user_name in k for k in users.keys()))
u1 = next(iter(users))
self.assertTrue(u"gender" not in u1)
def test_export_anonymous(self):
e = importexport.export_data(dict(include_user=True))
users = e[u'user']
self.assertTrue(len(users) >= 2)
self.assertTrue(all(len(u) == 0 for u in users.values()))
self.assertTrue(not any(self.u1.user_name in k for k in users.keys()))
u1 = next(iter(users))
self.assertTrue(u'gender' not in u1)
def test_export_badge(self):
e = importexport.export_data(dict(include_user=True, user_personal=True, include_badge=True))
bdata = e[u"badge"]
assert len(bdata) >= 1
mykey, myb = next((bkey, bd) for bkey, bd in bdata.items() if bd[u"title"] == self.badge.title)
self.assertEqual(myb[u"color"], self.badge.color)
self.assertTrue(myb[u"visible"])
self.assertEqual(myb[u"description"], self.badge.description)
self.assertEqual(myb[u"adhocracy_badge_type"], u"user")
myu1 = next(u for u in e[u"user"].values() if u[u"email"] == self.u1.email)
self.assertEqual(myu1[u"badges"], [mykey])
def test_export_user(self):
e = importexport.export_data(dict(include_user=True, user_personal=True, user_password=True))
users = e[u"user"].values()
self.assertTrue(len(users) >= 2)
self.assertTrue(any(u[u"user_name"] == self.u1.user_name for u in users))
self.assertTrue(any(u[u"email"] == self.u2.email for u in users))
self.assertTrue(any(u[u"adhocracy_password"] == self.u1.password for u in users))
self.assertTrue(all(u"_" in u[u"locale"] for u in users))
u1 = next(u for u in users if u[u"email"] == self.u1.email)
self.assertEqual(u1[u"gender"], u"f")
assert len(users) == len(model.User.all())
def test_export_proposal(self):
p = testtools.tt_make_proposal(creator=self.u1)
e = importexport.export_data(
{u"include_instance": True, u"include_instance_proposal": True, u"include_users": True}
)
idata = e[u"instance"][p.instance.key]
self.assertTrue(u"proposals" in idata)
pdata = idata[u"proposals"][str(p.id)]
assert u"comments" not in pdata
self.assertEqual(pdata[u"title"], p.title)
self.assertEqual(pdata[u"description"], p.description)
self.assertEqual(pdata[u"adhocracy_type"], u"proposal")
def test_export_user(self):
e = importexport.export_data(
dict(include_user=True, user_personal=True, user_password=True))
users = e[u'user'].values()
self.assertTrue(len(users) >= 2)
self.assertTrue(
any(u[u'user_name'] == self.u1.user_name for u in users))
self.assertTrue(any(u[u'email'] == self.u2.email for u in users))
self.assertTrue(
any(u[u'adhocracy_password'] == self.u1.password for u in users))
self.assertTrue(all(u'_' in u[u'locale'] for u in users))
u1 = next(u for u in users if u[u'email'] == self.u1.email)
self.assertEqual(u1[u'gender'], u'f')
assert len(users) == len(model.User.all())
def test_export_badge(self):
e = importexport.export_data(
dict(include_user=True, user_personal=True, include_badge=True))
bdata = e[u'badge']
assert len(bdata) >= 1
mykey, myb = next((bkey, bd) for bkey, bd in bdata.items()
if bd[u'title'] == self.badge.title)
self.assertEqual(myb[u'color'], self.badge.color)
self.assertTrue(myb[u'visible'])
self.assertEqual(myb[u'description'], self.badge.description)
self.assertEqual(myb[u'adhocracy_badge_type'], u'user')
myu1 = next(u for u in e[u'user'].values()
if u[u'email'] == self.u1.email)
self.assertEqual(myu1[u'badges'], [mykey])
def test_export_proposal(self):
p = testtools.tt_make_proposal(creator=self.u1)
e = importexport.export_data({
u"include_instance": True,
u"include_instance_proposal": True,
u"include_users": True,
})
idata = e[u'instance'][p.instance.key]
self.assertTrue(u'proposals' in idata)
pdata = idata[u'proposals'][str(p.id)]
assert u'comments' not in pdata
self.assertEqual(pdata[u'title'], p.title)
self.assertEqual(pdata[u'description'], p.description)
self.assertEqual(pdata[u'adhocracy_type'], u'proposal')
def test_importexport_instance(self):
opts = {u"include_instance": True}
ed = importexport.export_data(opts)
testdata = ed[u"instance"][self.instance.key]
testdata[u"key"] += testtools.tt_make_str() + u"A" # Test uppercase
ed[u"instance"] = {testdata[u"key"]: testdata}
importexport.import_data(opts, ed)
imported_instance = model.Instance.find(testdata[u"key"])
self.assertTrue(imported_instance)
INSTANCE_PROPS = [
u"label",
u"creator",
u"description",
u"required_majority",
u"activation_delay",
u"create_time",
u"access_time",
u"delete_time",
u"default_group_id",
u"allow_adopt",
u"allow_delegate",
u"allow_propose",
u"allow_index",
u"hidden",
u"locale",
u"css",
u"frozen",
u"milestones",
u"use_norms",
u"require_selection",
u"is_authenticated",
u"hide_global_categories",
u"editable_comments_default",
u"editable_proposals_default",
u"require_valid_email",
u"allow_thumbnailbadges",
u"thumbnailbadges_height",
u"thumbnailbadges_width",
]
for p in INSTANCE_PROPS:
imported = getattr(imported_instance, p)
expected = getattr(self.instance, p)
msg = u"Instance.%s: Got %r, but expected %r" % (p, imported, expected)
self.assertEqual(expected, imported, msg)
def test_rendering(self):
e = importexport.export_data({
u'include_user': True,
u'user_personal': True,
u'user_password': True,
u'include_badge': True,
})
self.assertEqual(set(e.keys()), set([u'metadata', u'user', u'badge']))
render = importexport.render.render
parse = importexport.parse
response = _MockResponse()
zdata = render(e, u'zip', u'test', response=response)
bio = io.BytesIO(zdata)
with contextlib.closing(zipfile.ZipFile(bio, u'r')) as zf:
expected_files = set(
[u'metadata.json', u'user.json', u'badge.json'])
self.assertEqual(set(zf.namelist()), expected_files)
zio = io.BytesIO(zdata)
self.assertEqual(parse.detect_format(zio), u'zip')
self.assertEqual(zio.read(), zdata)
self.assertEqual(e, parse.read_data(io.BytesIO(zdata), u'zip'))
self.assertEqual(e, parse.read_data(io.BytesIO(zdata), u'detect'))
response = _MockResponse()
jdata = render(e, u'json', u'test', response=response)
response = _MockResponse()
jdata_dl = render(e, u'json_download', u'test', response=response)
self.assertEqual(jdata, jdata_dl)
self.assertTrue(isinstance(jdata, bytes))
jio = io.BytesIO(jdata)
self.assertEqual(parse.detect_format(jio), u'json')
self.assertEqual(jio.read(), jdata)
self.assertEqual(e, parse.read_data(io.BytesIO(jdata), u'json'))
self.assertEqual(e, parse.read_data(io.BytesIO(jdata), u'detect'))
self.assertRaises(ValueError,
render,
e,
u'invalid',
u'test',
response=response)
self.assertRaises(ValueError, parse.read_data, zdata, u'invalid')
self.assertEqual(parse.detect_format(io.BytesIO()), u'unknown')
def test_export_instance(self):
ed = importexport.export_data({u"include_instance": True, u"include_user": True, u"user_personal": True})
# Test that we don't spill non-representable objects by accident
ex = importexport.render.render(ed, u"json", u"(title)", response=_MockResponse())
e = importexport.parse.read_data(io.BytesIO(ex))
self.assertTrue(u"instance" in e)
self.assertTrue(len(e[u"instance"]) >= 1)
self.assertTrue(self.instance.key in e[u"instance"])
idata = e[u"instance"][self.instance.key]
self.assertEqual(idata[u"label"], self.instance.label)
self.assertEqual(idata[u"key"], self.instance.key)
user_id = idata[u"creator"]
assert user_id
self.assertTrue(isinstance(user_id, (str, unicode)))
self.assertEqual(e[u"user"][user_id][u"user_name"], self.u2.user_name)
self.assertEqual(idata[u"adhocracy_type"], u"instance")
def test_export_comments(self):
p = testtools.tt_make_proposal(creator=self.u1, with_description=True)
desc1 = testtools.tt_make_str()
desc2 = testtools.tt_make_str()
c1 = model.Comment.create(
text=desc1,
user=self.u1,
topic=p.description,
reply=None,
variant=u'HEAD',
sentiment=1)
c2 = model.Comment.create(
text=desc2,
user=self.u2,
topic=p.description,
reply=c1,
variant=u'HEAD',
sentiment=-1)
assert p.description.comments
e = importexport.export_data({
"include_instance": True,
"include_instance_proposal": True,
"include_instance_proposal_comment": True,
"include_users": True,
})
idata = e[u'instance'][p.instance.key]
pdata = idata[u'proposals'][str(p.id)]
assert u'comments' in pdata
self.assertEqual(len(pdata[u'comments']), 1)
cdata = next(iter(pdata[u'comments'].values()))
self.assertEqual(cdata[u'text'], desc1)
self.assertEqual(cdata[u'creator'], str(self.u1.id))
self.assertEqual(cdata[u'sentiment'], 1)
self.assertEqual(cdata[u'adhocracy_type'], u'comment')
self.assertEqual(len(cdata[u'comments']), 1)
cdata2 = next(iter(cdata[u'comments'].values()))
self.assertEqual(cdata2[u'text'], desc2)
self.assertEqual(cdata2[u'creator'], str(self.u2.id))
self.assertEqual(cdata2[u'sentiment'], -1)
self.assertEqual(cdata2[u'adhocracy_type'], u'comment')
def test_rendering(self):
e = importexport.export_data(
{u"include_user": True, u"user_personal": True, u"user_password": True, u"include_badge": True}
)
self.assertEqual(set(e.keys()), set([u"metadata", u"user", u"badge"]))
render = importexport.render.render
parse = importexport.parse
response = _MockResponse()
zdata = render(e, u"zip", u"test", response=response)
bio = io.BytesIO(zdata)
with contextlib.closing(zipfile.ZipFile(bio, u"r")) as zf:
expected_files = set([u"metadata.json", u"user.json", u"badge.json"])
self.assertEqual(set(zf.namelist()), expected_files)
zio = io.BytesIO(zdata)
self.assertEqual(parse.detect_format(zio), u"zip")
self.assertEqual(zio.read(), zdata)
self.assertEqual(e, parse.read_data(io.BytesIO(zdata), u"zip"))
self.assertEqual(e, parse.read_data(io.BytesIO(zdata), u"detect"))
response = _MockResponse()
jdata = render(e, u"json", u"test", response=response)
response = _MockResponse()
jdata_dl = render(e, u"json_download", u"test", response=response)
self.assertEqual(jdata, jdata_dl)
self.assertTrue(isinstance(jdata, bytes))
jio = io.BytesIO(jdata)
self.assertEqual(parse.detect_format(jio), u"json")
self.assertEqual(jio.read(), jdata)
self.assertEqual(e, parse.read_data(io.BytesIO(jdata), u"json"))
self.assertEqual(e, parse.read_data(io.BytesIO(jdata), u"detect"))
self.assertRaises(ValueError, render, e, u"invalid", u"test", response=response)
self.assertRaises(ValueError, parse.read_data, zdata, u"invalid")
self.assertEqual(parse.detect_format(io.BytesIO()), u"unknown")
def test_export_comments(self):
p = testtools.tt_make_proposal(creator=self.u1, with_description=True)
desc1 = testtools.tt_make_str()
desc2 = testtools.tt_make_str()
c1 = model.Comment.create(
text=desc1, user=self.u1, topic=p.description, reply=None, variant=u"HEAD", sentiment=1
)
c2 = model.Comment.create(
text=desc2, user=self.u2, topic=p.description, reply=c1, variant=u"HEAD", sentiment=-1
)
assert p.description.comments
e = importexport.export_data(
{
"include_instance": True,
"include_instance_proposal": True,
"include_instance_proposal_comment": True,
"include_users": True,
}
)
idata = e[u"instance"][p.instance.key]
pdata = idata[u"proposals"][str(p.id)]
assert u"comments" in pdata
self.assertEqual(len(pdata[u"comments"]), 1)
cdata = next(iter(pdata[u"comments"].values()))
self.assertEqual(cdata[u"text"], desc1)
self.assertEqual(cdata[u"creator"], str(self.u1.id))
self.assertEqual(cdata[u"sentiment"], 1)
self.assertEqual(cdata[u"adhocracy_type"], u"comment")
self.assertEqual(len(cdata[u"comments"]), 1)
cdata2 = next(iter(cdata[u"comments"].values()))
self.assertEqual(cdata2[u"text"], desc2)
self.assertEqual(cdata2[u"creator"], str(self.u2.id))
self.assertEqual(cdata2[u"sentiment"], -1)
self.assertEqual(cdata2[u"adhocracy_type"], u"comment")
def test_export_basic(self):
e = importexport.export_data({})
self.assertEqual(len(e), 1)
self.assertEqual(e[u'metadata'][u'type'], u'normsetting-export')
self.assertTrue(e[u'metadata'][u'version'] >= 3)
def test_export_basic(self):
e = importexport.export_data({})
self.assertEqual(len(e), 1)
self.assertEqual(e[u"metadata"][u"type"], u"normsetting-export")
self.assertTrue(e[u"metadata"][u"version"] >= 3)
