def test_creation(self):
int_type = Type(name='INTEGER',
validator=self._base('/validate/int'),
repr=self._base('/repr/int'))
int_type.save()
i = Type.objects(name='INTEGER').first()
self.assertIsNotNone(i)
def test_validation(self):
int_type = Type(name='INTEGER2',
validator=self._base('/validate/int'),
repr=self._base('/repr/int'))
int_type.save()
i = Type.objects(name='INTEGER2').first()
self.assertTrue(i.validate_value('100', 5))
try:
i.validate_value('something', 10)
raise AssertionError()
except OneBaseException as e:
self.assertEqual(e.error_code, 'E-101')
def setUp(self):
super(TestKeys, self).setUp()
int_type = Type(name='INTEGER',
validator=self._base('/validate/int'),
repr=self._base('/repr/int'))
int_type.save()
self.int_type = int_type
def delete_type(type_id):
""" Delete a given type. """
type = Type.objects(id=type_id).first()
if 'confirm' in request.args:
if int(request.args['confirm']) == 1:
type.delete()
return render_template('type/delete.html',
confirm=request.args['confirm'],
title="Delete {}".format(type.name),
type=type)
return render_template('type/delete.html', type=type,
title="Delete {}".format(type.name))
def create_node(*args, **kwargs):
""" Create a new Node. """
class FieldedNodeForm(CreateNodeForm):
pass
key_count = int(request.values.get('keyCount', 1))
logger.debug("begin adding {} fields".format(key_count))
for i in range(0, key_count):
f1 = 'key_{}_name'.format(i)
f2 = 'key_{}_type'.format(i)
f3 = 'key_{}_size'.format(i)
logger.debug("Adding {}, {}".format(f1, f2))
key_name = request.values.get(f1)
key_type = request.values.get(f2)
setattr(FieldedNodeForm, f1,
StringField('Key {} Name'.format(i), default=key_name))
setattr(FieldedNodeForm, f2,
SelectField(default=key_type, choices=Type.as_select()))
setattr(FieldedNodeForm, f3, IntegerField())
logger.debug("FieldedNodeForm now has {} fields".format(
len([
f for f in FieldedNodeForm.__dict__.keys()
if f.startswith('key')
])))
if request.method == 'POST':
logger.debug("Form data: {}".format(dict(request.form)))
assert len(request.form['path']) > 1
form = FieldedNodeForm(request.form)
if form.validate():
u = get_user()
created_node = form.submit(u)
return redirect(
url_for('node.view_node', path=request.args['path']))
logger.debug('{} did not validate'.format(form))
logger.debug('arguments: {}'.format(args))
assert len(args) == 0 and len(kwargs.items()) == 0
template = "create.html"
path = request.args.get('path')
form = FieldedNodeForm(request.values)
if path is None:
raise OneBaseException('E-207')
updated_kw = {
'keyCount': str(key_count + 1),
}
add_key_url = reconstruct_url(request, updated_kw)
return render_template(template,
form=form,
path=path,
pathparts=path.split("/"),
add_key_url=add_key_url)
def test_node_view(self):
""" A node can be viewed. """
def _base(u):
return 'http://localhost:5002' + u
types = {
'integer': Type(name='INTEGER',
validator=_base('/api/1.0/validate/int'),
repr=_base('/api/1.0/repr/int'),
)
}
for t in types:
t.save()
keys = [
Key(name='first', type=types['integer'])
]
node = Node()
path = create_node_at_path(self.admin, '/root/a/b', node)
def create_type():
""" Create a new type. """
form = CreateTypeForm()
if request.method == 'POST':
form = CreateTypeForm(**request.form)
logger.debug("Form data: {}".format(form.data))
logger.debug("Request values: {}".format(request.form))
if form.validate():
type = Type(name=form.data['name'][0],
repr=form.data['repr'][0],
is_primitive=form.data['is_primitive'],
validator=form.data['validator'][0])
if type.save(get_user()):
return redirect(url_for('type.show_type',
type_id=type.id))
return render_template('type/create_type.html', form=form,
title="Create Type")
def update_type(type_id):
""" Update a type. """
type = Type.objects(id=type_id).first()
# from json import loads
data = type.to_json()
if 'id' in data:
del data['id']
form = CreateTypeForm(**data)
if request.method == 'POST':
form = CreateTypeForm(request.form)
if form.validate():
logger.debug('saving {} with {}'.format(type, form.data))
for (k, v) in form.data.items():
if hasattr(type, k):
setattr(type, k, v)
if type.save():
return redirect(url_for('type.show_type',
type_id=type.id))
return render_template('type/modify.html', form=form)
def create_keys_from_fields(self, user):
""" Helper function to create node keys from fields. """
keys = []
for i in range(0, self.maximum_keys):
f1 = 'key_{}_name'.format(i)
f2 = 'key_{}_type'.format(i)
f3 = 'key_{}_size'.format(i)
if f1 not in self.data:
break
key_name = self.data[f1]
key_size = self.data[f3]
_key_type = self.data[f2]
if key_name is None:
return keys
key_type = Type.objects(id=_key_type).first()
key = Key(name=key_name, size=key_size, soft_type=key_type)
key.save(user)
keys.append(key)
return keys
def show_type(type_id):
""" Show a type. """
return render_template('show.html', type=Type.objects(id=type_id).first())