def test_noderequest(self):
"""
"""
f = open(os.path.join(self.tmp_template_dir, 'select_pagenames.sql'),
'w')
f.write("""
select 'yup' as test where :pagename in ('apple', 'pear', 'grapes');
""")
f.close()
with self.app.app_context():
with self.app.test_client() as c:
init_db()
page = insert_node(name='page', value=None)
insert_route(path='/page/<pagename>/', node_id=page)
pagenames = insert_node(name='pagenames', value=None)
insert_node_node(node_id=page, target_node_id=pagenames)
insert_query(name='select_pagenames.sql', node_id=pagenames)
rv = c.get('/page/cucumber/', follow_redirects=True)
assert 200 == rv.status_code
self.app.logger.debug('test: %s', rv.data)
assert 'yup' not in rv.data
rv = c.get('/page/pear/', follow_redirects=True)
assert 200 == rv.status_code
self.app.logger.debug('test: %s', rv.data)
assert 'yup' in rv.data
def test_noderequest(self):
"""
"""
f = open(os.path.join(self.tmp_template_dir, 'select_pagenames.sql'), 'w')
f.write("""
select 'yup' as test where :pagename in ('apple', 'pear', 'grapes');
""")
f.close()
with self.app.app_context():
with self.app.test_client() as c:
init_db()
page = insert_node(name='page', value=None)
insert_route(path='/page/<pagename>/', node_id=page)
pagenames = insert_node(name='pagenames', value=None)
insert_node_node(node_id=page, target_node_id=pagenames)
insert_query(name='select_pagenames.sql', node_id=pagenames)
rv = c.get('/page/cucumber/', follow_redirects=True)
assert 200 == rv.status_code
self.app.logger.debug('test: %s', rv.data)
assert 'yup' not in rv.data
rv = c.get('/page/pear/', follow_redirects=True)
assert 200 == rv.status_code
self.app.logger.debug('test: %s', rv.data)
assert 'yup' in rv.data
def test_noderequest_cookies(self):
"""
"""
f = open(os.path.join(self.tmp_template_dir, 'select_llama.sql'), 'w')
f.write("""
select :llama as llama;
""")
f.close()
with self.app.app_context():
with self.app.test_client() as c:
init_db()
page = insert_node(name='page', value=None)
insert_route(path='/page/', node_id=page)
llama = insert_node(name='llama', value=None)
insert_node_node(node_id=page, target_node_id=llama)
insert_query(name='select_llama.sql', node_id=llama)
c.set_cookie('localhost', 'llama', 'chuck')
rv = c.get('/page/', follow_redirects=True)
assert 200 == rv.status_code
self.app.logger.debug('test: %s', rv.data)
assert 'chuck' in rv.data
def test_noderequest_cookies(self):
"""
"""
f = open(os.path.join(self.tmp_template_dir, 'select_llama.sql'), 'w')
f.write("""
select :llama as llama;
""")
f.close()
with self.app.app_context():
with self.app.test_client() as c:
init_db()
page = insert_node(name='page', value=None)
insert_route(path='/page/', node_id=page)
llama = insert_node(name='llama', value=None)
insert_node_node(node_id=page, target_node_id=llama)
insert_query(name='select_llama.sql', node_id=llama)
c.set_cookie('localhost', 'llama', 'chuck')
rv = c.get('/page/', follow_redirects=True)
assert 200 == rv.status_code
self.app.logger.debug('test: %s', rv.data)
assert 'chuck' in rv.data
def test_dict(self):
"""
"""
f = open(os.path.join(self.tmp_template_dir, 'llama.html'), 'w')
f.write("""
<!doctype html>
<html><head><title>llama</title></head>
<body>
<h1>template for llama_name</h1>
{{ llama_name }}
</body>
</html>
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_llama.sql'), 'w')
f.write("""
select :llama_name as llama_name;
""")
f.close()
with self.app.app_context():
with self.app.test_client() as c:
init_db()
a = insert_node(name='a', value=None)
insert_route(path='/a/<llama_name>/', node_id=a)
insert_query(name='select_llama.sql', node_id=a)
add_template_for_node('llama.html', a)
rv = c.get('/a/chuck/', follow_redirects=True)
assert 'chuck' in rv.data
rv = c.get('/a/chase/', follow_redirects=True)
assert 'chase' in rv.data
def mode_new_collection():
"""
Create a new collection of items with common attributes.
"""
print globals()['mode_new_collection'].__doc__
collection_name = raw_input("Collection name: ")
item_attr_list = []
collection_node_id = None
if collection_name:
collection_node_id = insert_node(name=collection_name, value=None)
insert_query(name='select_link_node_from_node.sql', node_id=collection_node_id)
item_attr = True
while item_attr:
item_attr = raw_input("Add a collection item attribute name: ")
if item_attr:
item_attr_list.append(item_attr)
# if no collection name then exit
selection = collection_name
while selection:
selection = select([
'Add item',
])
if selection == 'Add item':
# create item
add_item_with_attributes_to_collection(
collection_name=collection_name,
collection_node_id=collection_node_id,
item_attr_list=item_attr_list)
if collection_node_id:
print "Added collection name '{0}' with node id: {1}".format(collection_name, collection_node_id)
def test_dict(self):
"""
"""
f = open(os.path.join(self.tmp_template_dir, 'llama.html'), 'w')
f.write("""
<!doctype html>
<html><head><title>llama</title></head>
<body>
<h1>template for llama_name</h1>
{{ llama_name }}
</body>
</html>
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_llama.sql'), 'w')
f.write("""
select :llama_name as llama_name;
""")
f.close()
with self.app.app_context():
with self.app.test_client() as c:
init_db()
a = insert_node(name='a', value=None)
insert_route(path='/a/<llama_name>/', node_id=a)
insert_query(name='select_llama.sql', node_id=a)
add_template_for_node('llama.html', a)
rv = c.get('/a/chuck/', follow_redirects=True)
assert 'chuck' in rv.data
rv = c.get('/a/chase/', follow_redirects=True)
assert 'chase' in rv.data
def test_a(self):
"""
"""
f = open(os.path.join(self.tmp_template_dir, 'insert_llama.sql'), 'w')
f.write("""
insert into Llama (llama_name, location, description) values (:llama_name, :location, :description);
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_llama.sql'), 'w')
f.write("""
select * from Llama
where llama_name = :llama_name;
""")
f.close()
with self.app.app_context():
with self.app.test_client() as c:
init_db()
db.execute(text("""
create table Llama (
llama_name varchar(255),
location varchar(255),
description text
);
"""))
llamas_id = insert_node(name='llamas', value=None)
insert_route(path='/api/llamas/', node_id=llamas_id, weight=1, method="POST")
insert_query(name='insert_llama.sql', node_id=llamas_id)
llama_1 = {
'llama_name': 'Rocky',
'location': 'unknown',
'description': 'first llama'
}
rv = c.post('/api/llamas/', data=llama_1)
assert 201 == rv.status_code
llama_2 = {
'llama_name': 'Nocky',
'location': 'unknown',
'description': 'second llama'
}
rv = c.post('/api/llamas/', data=llama_2)
assert 201 == rv.status_code
select_llama = insert_node(name='llamas', value=None)
insert_route(path='/api/llamas/name/<llama_name>/', node_id=select_llama, weight=1)
insert_query(name='select_llama.sql', node_id=select_llama)
rv = c.get('/api/llamas/name/Rocky/', follow_redirects=True)
rv_json = json.loads(rv.data)
assert set(llama_1.keys()) == set(rv_json.keys())
assert set(llama_1.values()) == set(rv_json.values())
rv = c.get('/api/llamas/name/Nocky/', follow_redirects=True)
rv_json = json.loads(rv.data)
assert set(llama_2.keys()) == set(rv_json.keys())
assert set(llama_2.values()) == set(rv_json.values())
def test_a(self):
"""
"""
f = open(os.path.join(self.tmp_template_dir, 'update_llama.sql'), 'w')
f.write("""
update Llama set location = :location, description = :description where llama_name = :llama_name;
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_llama.sql'), 'w')
f.write("""
select * from Llama
where llama_name = :llama_name;
""")
f.close()
with self.app.app_context():
with self.app.test_client() as c:
init_db()
cursor = db.cursor()
cursor.execute("""
create table Llama (
llama_name varchar(255),
location varchar(255),
description text
);
""")
db.commit()
cursor.execute("""
insert into Llama (llama_name) values ('Pocky');
""")
db.commit()
llamas_id = insert_node(name='llamas', value=None)
insert_route(path='/api/llamas/name/<llama_name>/',
node_id=llamas_id,
weight=1,
method="PATCH")
insert_query(name='update_llama.sql', node_id=llamas_id)
llama_1 = {
'llama_name': 'Pocky',
'location': 'unknown',
'description': 'first llama'
}
rv = c.patch('/api/llamas/name/Pocky/', data=llama_1)
assert 201 == rv.status_code
select_llama = insert_node(name='llamas', value=None)
insert_route(path='/api/llamas/name/<llama_name>/',
node_id=select_llama,
weight=1)
insert_query(name='select_llama.sql', node_id=select_llama)
rv = c.get('/api/llamas/name/Pocky/', follow_redirects=True)
rv_json = json.loads(rv.data)
assert set(llama_1.keys()) == set(rv_json.keys())
assert set(llama_1.values()) == set(rv_json.values())
def add_item_with_attributes_to_collection(collection_name, collection_node_id, item_attr_list):
item_node_id = insert_node(name='{0}_item'.format(collection_name), value=None)
insert_query(name='select_link_node_from_node.sql', node_id=item_node_id)
insert_node_node(node_id=collection_node_id, target_node_id=item_node_id)
for item_attr_name in item_attr_list:
value = raw_input("Enter item attribute value for '{0}': ".format(item_attr_name))
# set value to none if it's an empty string
value = value if len(value) else None
item_attr_node_id = insert_node(name=item_attr_name, value=value)
insert_node_node(node_id=item_node_id, target_node_id=item_attr_node_id)
def test_a(self):
"""
"""
f = open(os.path.join(self.tmp_template_dir, 'delete_llama.sql'), 'w')
f.write("""
Delete from Llama where llama_name = :llama_name;
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_llama.sql'), 'w')
f.write("""
select * from Llama
where llama_name = :llama_name;
""")
f.close()
with self.app.app_context():
with self.app.test_client() as c:
init_db()
cursor = db.cursor()
cursor.execute("""
create table Llama (
llama_name varchar(255),
location varchar(255),
description text
);
""")
db.commit()
cursor.execute("""
insert into Llama (llama_name, location, description) values ('Docky', 'somewhere', 'damaged');
""")
db.commit()
select_llama = insert_node(name='llamas', value=None)
insert_route(path='/api/llamas/name/<llama_name>/',
node_id=select_llama,
weight=1)
insert_query(name='select_llama.sql', node_id=select_llama)
llamas_id = insert_node(name='llamas', value=None)
insert_route(path='/api/llamas/name/<llama_name>/',
node_id=llamas_id,
weight=1,
method="DELETE")
insert_query(name='delete_llama.sql', node_id=llamas_id)
rv = c.get('/api/llamas/name/Docky/', follow_redirects=True)
assert 200 == rv.status_code
rv = c.delete('/api/llamas/name/Docky/')
assert 204 == rv.status_code
rv = c.get('/api/llamas/name/Docky/', follow_redirects=True)
assert 404 == rv.status_code
def test_a(self):
"""
"""
f = open(os.path.join(self.tmp_template_dir, 'delete_llama.sql'), 'w')
f.write("""
Delete from Llama where llama_name = :llama_name;
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_llama.sql'), 'w')
f.write("""
select * from Llama
where llama_name = :llama_name;
""")
f.close()
with self.app.app_context():
with self.app.test_client() as c:
init_db()
cursor = db.cursor()
cursor.execute("""
create table Llama (
llama_name varchar(255),
location varchar(255),
description text
);
""")
db.commit()
cursor.execute("""
insert into Llama (llama_name, location, description) values ('Docky', 'somewhere', 'damaged');
""")
db.commit()
select_llama = insert_node(name='llamas', value=None)
insert_route(path='/api/llamas/name/<llama_name>/', node_id=select_llama, weight=1)
insert_query(name='select_llama.sql', node_id=select_llama)
llamas_id = insert_node(name='llamas', value=None)
insert_route(path='/api/llamas/name/<llama_name>/', node_id=llamas_id, weight=1, method="DELETE")
insert_query(name='delete_llama.sql', node_id=llamas_id)
rv = c.get('/api/llamas/name/Docky/', follow_redirects=True)
assert 200 == rv.status_code
rv = c.delete('/api/llamas/name/Docky/')
assert 204 == rv.status_code
rv = c.get('/api/llamas/name/Docky/', follow_redirects=True)
assert 404 == rv.status_code
def init():
"Initialize the current directory with base starting files and database."
if not os.path.exists('site.cfg'):
f = open('site.cfg', 'w')
f.write(SITECFG)
f.close()
try:
os.mkdir('queries')
except OSError:
pass
try:
os.mkdir('templates')
except OSError:
pass
htmlfile = os.path.join('templates', 'homepage.html')
if not os.path.exists(htmlfile):
f = open(htmlfile, 'w')
f.write("""
<!doctype html>
<html>
<head>
<title>Chill</title>
</head>
<body>
<p>{{ homepage_content }}</p>
</body>
</html>
""")
f.close()
app = make_app(config='site.cfg', DEBUG=True)
with app.app_context():
app.logger.info("initializing database")
init_db()
homepage = insert_node(name='homepage', value=None)
insert_route(path='/', node_id=homepage)
insert_query(name='select_link_node_from_node.sql', node_id=homepage)
add_template_for_node('homepage.html', homepage)
homepage_content = insert_node(name='homepage_content', value="Cascading, Highly Irrelevant, Lost Llamas")
insert_node_node(node_id=homepage, target_node_id=homepage_content)
def test_simple(self):
"""
"""
f = open(os.path.join(self.tmp_template_dir, 'simple.sql'), 'w')
f.write("""
select 'yup' as a, 'pretty' as b, 'darn' as c, 'simple' as d;
""")
f.close()
with self.app.app_context():
with self.app.test_client() as c:
init_db()
simple_id = insert_node(name='simple', value=None)
insert_query(name='simple.sql', node_id=simple_id)
insert_route(path="/simple/", node_id=simple_id)
rv = c.get('/simple', follow_redirects=True)
assert 200 == rv.status_code
simple_json = json.loads(rv.data)
assert 'yup' == simple_json['a']
def test_simple(self):
"""
"""
f = open(os.path.join(self.tmp_template_dir, 'simple.sql'), 'w')
f.write("""
select 'yup' as a, 'pretty' as b, 'darn' as c, 'simple' as d;
""")
f.close()
with self.app.app_context():
with self.app.test_client() as c:
init_db()
simple_id = insert_node(name='simple', value=None)
insert_query(name='simple.sql', node_id=simple_id)
insert_route(path="/simple/", node_id=simple_id)
rv = c.get('/simple', follow_redirects=True)
assert 200 == rv.status_code
simple_json = json.loads(rv.data)
assert 'yup' == simple_json['a']
def mode_database_functions():
"Select a function to perform from chill.database"
print globals()['mode_database_functions'].__doc__
selection = True
database_functions = [
'init_db',
'insert_node',
'insert_node_node',
'delete_node',
'select_node',
'insert_route',
'insert_query',
'add_template_for_node',
'fetch_query_string',
]
while selection:
choices = database_functions + [
'help',
]
selection = select(choices)
if selection:
print globals().get(selection).__doc__
if selection == 'init_db':
confirm = raw_input("Initialize new database y/n? [n] ")
if confirm == 'y':
init_db()
elif selection == 'insert_node':
name = raw_input("Node name: ")
value = raw_input("Node value: ")
node = insert_node(name=name, value=value or None)
print "name: %s \nid: %s" % (name, node)
elif selection == 'insert_query':
sqlfile = choose_query_file()
if sqlfile:
node = existing_node_input()
if node >= 0:
insert_query(name=sqlfile, node_id=node)
print "adding %s to node id: %s" % (sqlfile, node)
elif selection == 'insert_node_node':
print "Add parent node id"
node = existing_node_input()
print "Add target node id"
target_node = existing_node_input()
if node >= 0 and target_node >= 0:
insert_node_node(node_id=node, target_node_id=target_node)
elif selection == 'delete_node':
node = existing_node_input()
if node >= 0:
delete_node(node_id=node)
elif selection == 'select_node':
node = existing_node_input()
if node >= 0:
result = select_node(node_id=node)
print safe_dump(dict(zip(result[0].keys(), result[0].values())), default_flow_style=False)
elif selection == 'insert_route':
path = raw_input('path: ')
weight = raw_input('weight: ') or None
method = raw_input('method: ') or 'GET'
node = existing_node_input()
if node >= 0:
insert_route(path=path, node_id=node, weight=weight, method=method)
elif selection == 'add_template_for_node':
folder = current_app.config.get('THEME_TEMPLATE_FOLDER')
choices = map(os.path.basename,
glob(os.path.join(folder, '*'))
)
choices.sort()
templatefile = select(choices)
if templatefile:
node = existing_node_input()
if node >= 0:
add_template_for_node(name=templatefile, node_id=node)
print "adding %s to node id: %s" % (templatefile, node)
elif selection == 'fetch_query_string':
sqlfile = choose_query_file()
if sqlfile:
sql = fetch_query_string(sqlfile)
print sql
elif selection == 'help':
print "------"
for f in database_functions:
print "\n** %s **" % f
print globals().get(f).__doc__
print "------"
else:
pass
def test_rules(self):
f = open(os.path.join(self.tmp_template_dir, 'insert_promoattr.sql'),
'w')
f.write("""
insert into PromoAttr (node_id, title, description) values (:node_id, :title, :description);
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_promoattr.sql'),
'w')
f.write("""
select * from PromoAttr where node_id = :node_id;
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_promos.sql'), 'w')
f.write("""
select id as node_id, * from Node where name = 'promo' order by id limit 2 offset 13;
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_mainmenu.sql'),
'w')
f.write("""
select name as link from Node where name like 'page_' order by link;
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_pageattr.sql'),
'w')
f.write("""
select 'example title' as title, 'a description of the page' as description;
""")
f.close()
expected = {
"mainmenu": [{
"link": "page1"
}, {
"link": "page2"
}, {
"link": "page3"
}],
"pageattr": {
"description": "a description of the page",
"title": "example title"
},
"promos": [{
"promo": {
"description": "aaaaaaaaaaaaa",
"node_id": 20,
"title": "promo 13"
}
}, {
"promo": {
"description": "aaaaaaaaaaaaaa",
"node_id": 21,
"title": "promo 14"
}
}]
}
with self.app.app_context():
with self.app.test_client() as c:
init_db()
trans = db.transaction()
db.query("""
create table PromoAttr (
node_id integer,
abc integer,
title varchar(255),
description text
);
""")
trans.commit()
page_id = insert_node(name='page1', value=None)
print page_id
insert_route(path='/page1/', node_id=page_id)
pageattr_id = insert_node(name='pageattr', value=None)
print pageattr_id
insert_node_node(node_id=page_id, target_node_id=pageattr_id)
insert_query(name='select_pageattr.sql', node_id=pageattr_id)
mainmenu_id = insert_node(name='mainmenu', value=None)
insert_node_node(node_id=page_id, target_node_id=mainmenu_id)
insert_query(name='select_mainmenu.sql', node_id=mainmenu_id)
# Add some other pages that will be shown in menu as just links
insert_node(name='page2', value=None)
insert_node(name='page3', value=None)
promos_id = insert_node(name='promos', value=None)
insert_node_node(node_id=page_id, target_node_id=promos_id)
insert_query(name='select_promos.sql', node_id=promos_id)
for a in range(0, 100):
a_id = insert_node(name='promo', value=None)
trans = db.transaction()
db.query(
fetch_query_string('insert_promoattr.sql'), **{
'node_id': a_id,
'title': 'promo %i' % a,
'description': 'a' * a
})
trans.commit()
# wire the promo to it's attr
insert_query(name='select_promoattr.sql', node_id=a_id)
rv = c.get('/page1', follow_redirects=True)
print rv
assert 200 == rv.status_code
rv_json = json.loads(rv.data)
assert set(expected.keys()) == set(rv_json.keys())
assert set(expected['pageattr'].keys()) == set(
rv_json['pageattr'].keys())
def test_rules(self):
f = open(os.path.join(self.tmp_template_dir, 'insert_promoattr.sql'), 'w')
f.write("""
insert into PromoAttr (node_id, title, description) values (:node_id, :title, :description);
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_promoattr.sql'), 'w')
f.write("""
select * from PromoAttr where node_id = :node_id;
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_promos.sql'), 'w')
f.write("""
select id as node_id, * from Node where name = 'promo' order by id limit 2 offset 13;
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_mainmenu.sql'), 'w')
f.write("""
select name as link from Node where name like 'page_' order by link;
""")
f.close()
f = open(os.path.join(self.tmp_template_dir, 'select_pageattr.sql'), 'w')
f.write("""
select 'example title' as title, 'a description of the page' as description;
""")
f.close()
expected = {
"mainmenu": [
{ "link": "page1" },
{ "link": "page2" },
{ "link": "page3" }
],
"pageattr": {
"description": "a description of the page",
"title": "example title"
},
"promos": [
{ "promo": {
"description": "aaaaaaaaaaaaa",
"node_id": 20,
"title": "promo 13"
}
},
{ "promo": {
"description": "aaaaaaaaaaaaaa",
"node_id": 21,
"title": "promo 14"
}
}
]
}
with self.app.app_context():
with self.app.test_client() as c:
init_db()
db.execute(text("""
create table PromoAttr (
node_id integer,
abc integer,
title varchar(255),
description text
);
"""))
page_id = insert_node(name='page1', value=None)
insert_route(path='/page1/', node_id=page_id)
pageattr_id = insert_node(name='pageattr', value=None)
insert_node_node(node_id=page_id, target_node_id=pageattr_id)
insert_query(name='select_pageattr.sql', node_id=pageattr_id)
mainmenu_id = insert_node(name='mainmenu', value=None)
insert_node_node(node_id=page_id, target_node_id=mainmenu_id)
insert_query(name='select_mainmenu.sql', node_id=mainmenu_id)
# Add some other pages that will be shown in menu as just links
insert_node(name='page2', value=None)
insert_node(name='page3', value=None)
promos_id = insert_node(name='promos', value=None)
insert_node_node(node_id=page_id, target_node_id=promos_id)
insert_query(name='select_promos.sql', node_id=promos_id)
for a in range(0,100):
a_id = insert_node(name='promo', value=None)
db.execute(text(fetch_query_string('insert_promoattr.sql')), **{'node_id':a_id, 'title':'promo %i' % a, 'description': 'a'*a})
# wire the promo to it's attr
insert_query(name='select_promoattr.sql', node_id=a_id)
rv = c.get('/page1', follow_redirects=True)
assert 200 == rv.status_code
rv_json = json.loads(rv.data)
assert set(expected.keys()) == set(rv_json.keys())
assert set(expected['pageattr'].keys()) == set(rv_json['pageattr'].keys())
