archive/pillar
0
0
Fork 0
Code Issues 42 Pull Requests Projects Releases Wiki Activity

Ran 2to3 on unittests, same sort of manual fixups as before

Browse Source
This commit is contained in:
Sybren A. Stüvel 2017-03-03 12:07:11 +01:00
parent b65dd49aa6
commit b454b011b0
16 changed files with 405 additions and 413 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
tests/test_api/test_auth.py
View File

@ -19,15 +19,15 @@ EXAMPLE_PROJECT = copy.deepcopy(ctd.EXAMPLE_PROJECT)
_texture_nt = next(nt for nt in EXAMPLE_PROJECT['node_types'] _texture_nt = next(nt for nt in EXAMPLE_PROJECT['node_types']
if nt['name'] == 'texture') if nt['name'] == 'texture')
_texture_nt['permissions'] = {'groups': [ _texture_nt['permissions'] = {'groups': [
{u'group': ObjectId('5596e975ea893b269af85c0f'), u'methods': [u'GET']}, {'group': ObjectId('5596e975ea893b269af85c0f'), 'methods': ['GET']},
{u'group': ObjectId('564733b56dcaf85da2faee8a'), u'methods': [u'GET']} {'group': ObjectId('564733b56dcaf85da2faee8a'), 'methods': ['GET']}
]} ]}
_asset_nt = next(nt for nt in EXAMPLE_PROJECT['node_types'] _asset_nt = next(nt for nt in EXAMPLE_PROJECT['node_types']
if nt['name'] == 'asset') if nt['name'] == 'asset')
_asset_nt['permissions'] = {'groups': [ _asset_nt['permissions'] = {'groups': [
{u'group': ObjectId('5596e975ea893b269af85c0f'), u'methods': [u'DELETE', u'GET']}, {'group': ObjectId('5596e975ea893b269af85c0f'), 'methods': ['DELETE', 'GET']},
{u'group': ObjectId('564733b56dcaf85da2faee8a'), u'methods': [u'GET']} {'group': ObjectId('564733b56dcaf85da2faee8a'), 'methods': ['GET']}
]} ]}
@ -127,7 +127,7 @@ class AuthenticationTests(AbstractPillarTest):
from pillar.api.utils import authentication as auth from pillar.api.utils import authentication as auth
from pillar.api.utils import PillarJSONEncoder, remove_private_keys from pillar.api.utils import PillarJSONEncoder, remove_private_keys
user_id = self.create_user(roles=[u'subscriber']) user_id = self.create_user(roles=['subscriber'])
now = datetime.datetime.now(tz_util.utc) now = datetime.datetime.now(tz_util.utc)
future = now + datetime.timedelta(days=1) future = now + datetime.timedelta(days=1)
@ -174,7 +174,7 @@ class AuthenticationTests(AbstractPillarTest):
users = self.app.data.driver.db['users'] users = self.app.data.driver.db['users']
db_user = users.find_one(user_id) db_user = users.find_one(user_id)
self.assertEqual([u'subscriber'], db_user['roles']) self.assertEqual(['subscriber'], db_user['roles'])
def test_token_expiry(self): def test_token_expiry(self):
"""Expired tokens should be deleted from the database.""" """Expired tokens should be deleted from the database."""
@ -207,9 +207,9 @@ class UserListTests(AbstractPillarTest):
def setUp(self, **kwargs): def setUp(self, **kwargs):
super(UserListTests, self).setUp() super(UserListTests, self).setUp()
self.create_user(roles=[u'subscriber'], user_id='123456789abc123456789abc') self.create_user(roles=['subscriber'], user_id='123456789abc123456789abc')
self.create_user(roles=[u'admin'], user_id='223456789abc123456789abc') self.create_user(roles=['admin'], user_id='223456789abc123456789abc')
self.create_user(roles=[u'subscriber'], user_id='323456789abc123456789abc') self.create_user(roles=['subscriber'], user_id='323456789abc123456789abc')
self.create_valid_auth_token('123456789abc123456789abc', 'token') self.create_valid_auth_token('123456789abc123456789abc', 'token')
self.create_valid_auth_token('223456789abc123456789abc', 'admin-token') self.create_valid_auth_token('223456789abc123456789abc', 'admin-token')
@ -371,7 +371,7 @@ class UserListTests(AbstractPillarTest):
'roles': ['subscriber'], 'roles': ['subscriber'],
'settings': {'email_communications': 1}, 'settings': {'email_communications': 1},
'auth': [], 'auth': [],
'full_name': u'คนรักของผัดไทย', 'full_name': 'คนรักของผัดไทย',
'email': TEST_EMAIL_ADDRESS, 'email': TEST_EMAIL_ADDRESS,
} }
@ -464,22 +464,22 @@ class PermissionComputationTest(AbstractPillarTest):
# Test project permissions. # Test project permissions.
self.assertEqual( self.assertEqual(
{ {
u'groups': [{u'group': ObjectId('5596e975ea893b269af85c0e'), 'groups': [{'group': ObjectId('5596e975ea893b269af85c0e'),
u'methods': [u'DELETE', u'GET', u'POST', u'PUT']}], 'methods': ['DELETE', 'GET', 'POST', 'PUT']}],
u'world': [u'GET'] 'world': ['GET']
}, },
self.sort(compute_aggr_permissions('projects', EXAMPLE_PROJECT, None))) self.sort(compute_aggr_permissions('projects', EXAMPLE_PROJECT, None)))
# Test node type permissions. # Test node type permissions.
self.assertEqual( self.assertEqual(
{ {
u'groups': [{u'group': ObjectId('5596e975ea893b269af85c0e'), 'groups': [{'group': ObjectId('5596e975ea893b269af85c0e'),
u'methods': [u'DELETE', u'GET', u'POST', u'PUT']}, 'methods': ['DELETE', 'GET', 'POST', 'PUT']},
{u'group': ObjectId('5596e975ea893b269af85c0f'), {'group': ObjectId('5596e975ea893b269af85c0f'),
u'methods': [u'GET']}, 'methods': ['GET']},
{u'group': ObjectId('564733b56dcaf85da2faee8a'), {'group': ObjectId('564733b56dcaf85da2faee8a'),
u'methods': [u'GET']}], 'methods': ['GET']}],
u'world': [u'GET'] 'world': ['GET']
}, },
self.sort(compute_aggr_permissions('projects', EXAMPLE_PROJECT, 'texture'))) self.sort(compute_aggr_permissions('projects', EXAMPLE_PROJECT, 'texture')))
@ -492,13 +492,13 @@ class PermissionComputationTest(AbstractPillarTest):
# Test node permissions without embedded project. # Test node permissions without embedded project.
self.ensure_project_exists(project_overrides=EXAMPLE_PROJECT) self.ensure_project_exists(project_overrides=EXAMPLE_PROJECT)
self.assertEqual( self.assertEqual(
{u'groups': [{u'group': ObjectId('5596e975ea893b269af85c0e'), {'groups': [{'group': ObjectId('5596e975ea893b269af85c0e'),
u'methods': [u'DELETE', u'GET', u'POST', u'PUT']}, 'methods': ['DELETE', 'GET', 'POST', 'PUT']},
{u'group': ObjectId('5596e975ea893b269af85c0f'), {'group': ObjectId('5596e975ea893b269af85c0f'),
u'methods': [u'DELETE', u'GET']}, 'methods': ['DELETE', 'GET']},
{u'group': ObjectId('564733b56dcaf85da2faee8a'), {'group': ObjectId('564733b56dcaf85da2faee8a'),
u'methods': [u'GET']}], 'methods': ['GET']}],
u'world': [u'GET']}, 'world': ['GET']},
self.sort(compute_aggr_permissions('nodes', node, None))) self.sort(compute_aggr_permissions('nodes', node, None)))
with self.app.test_request_context(): with self.app.test_request_context():
@ -506,13 +506,13 @@ class PermissionComputationTest(AbstractPillarTest):
node = copy.deepcopy(EXAMPLE_NODE) node = copy.deepcopy(EXAMPLE_NODE)
node['project'] = EXAMPLE_PROJECT node['project'] = EXAMPLE_PROJECT
self.assertEqual( self.assertEqual(
{u'groups': [{u'group': ObjectId('5596e975ea893b269af85c0e'), {'groups': [{'group': ObjectId('5596e975ea893b269af85c0e'),
u'methods': [u'DELETE', u'GET', u'POST', u'PUT']}, 'methods': ['DELETE', 'GET', 'POST', 'PUT']},
{u'group': ObjectId('5596e975ea893b269af85c0f'), {'group': ObjectId('5596e975ea893b269af85c0f'),
u'methods': [u'DELETE', u'GET']}, 'methods': ['DELETE', 'GET']},
{u'group': ObjectId('564733b56dcaf85da2faee8a'), {'group': ObjectId('564733b56dcaf85da2faee8a'),
u'methods': [u'GET']}], 'methods': ['GET']}],
u'world': [u'GET']}, 'world': ['GET']},
self.sort(compute_aggr_permissions('nodes', node, None))) self.sort(compute_aggr_permissions('nodes', node, None)))
@ -529,7 +529,7 @@ class RequireRolesTest(AbstractPillarTest):
with self.app.test_request_context(): with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'), g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'succubus']} 'roles': ['succubus']}
call_me() call_me()
self.assertTrue(called[0]) self.assertTrue(called[0])
@ -540,19 +540,19 @@ class RequireRolesTest(AbstractPillarTest):
called = [False] called = [False]
@require_login(require_roles={u'admin'}) @require_login(require_roles={'admin'})
def call_me(): def call_me():
called[0] = True called[0] = True
with self.app.test_request_context(): with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'), g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'succubus']} 'roles': ['succubus']}
self.assertRaises(Forbidden, call_me) self.assertRaises(Forbidden, call_me)
self.assertFalse(called[0]) self.assertFalse(called[0])
with self.app.test_request_context(): with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'), g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'admin']} 'roles': ['admin']}
call_me() call_me()
self.assertTrue(called[0]) self.assertTrue(called[0])
@ -562,32 +562,32 @@ class RequireRolesTest(AbstractPillarTest):
called = [False] called = [False]
@require_login(require_roles={u'service', u'badger'}, @require_login(require_roles={'service', 'badger'},
require_all=True) require_all=True)
def call_me(): def call_me():
called[0] = True called[0] = True
with self.app.test_request_context(): with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'), g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'admin']} 'roles': ['admin']}
self.assertRaises(Forbidden, call_me) self.assertRaises(Forbidden, call_me)
self.assertFalse(called[0]) self.assertFalse(called[0])
with self.app.test_request_context(): with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'), g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'service']} 'roles': ['service']}
self.assertRaises(Forbidden, call_me) self.assertRaises(Forbidden, call_me)
self.assertFalse(called[0]) self.assertFalse(called[0])
with self.app.test_request_context(): with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'), g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'badger']} 'roles': ['badger']}
self.assertRaises(Forbidden, call_me) self.assertRaises(Forbidden, call_me)
self.assertFalse(called[0]) self.assertFalse(called[0])
with self.app.test_request_context(): with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'), g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'service', u'badger']} 'roles': ['service', 'badger']}
call_me() call_me()
self.assertTrue(called[0]) self.assertTrue(called[0])
@ -596,8 +596,8 @@ class RequireRolesTest(AbstractPillarTest):
with self.app.test_request_context(): with self.app.test_request_context():
self.assertTrue(user_has_role('subscriber', {'roles': ['aap', 'noot', 'subscriber']})) self.assertTrue(user_has_role('subscriber', {'roles': ['aap', 'noot', 'subscriber']}))
self.assertTrue(user_has_role('subscriber', {'roles': [u'aap', u'subscriber']})) self.assertTrue(user_has_role('subscriber', {'roles': ['aap', 'subscriber']}))
self.assertFalse(user_has_role('admin', {'roles': [u'aap', u'noot', u'subscriber']})) self.assertFalse(user_has_role('admin', {'roles': ['aap', 'noot', 'subscriber']}))
self.assertFalse(user_has_role('admin', {'roles': []})) self.assertFalse(user_has_role('admin', {'roles': []}))
self.assertFalse(user_has_role('admin', {'roles': None})) self.assertFalse(user_has_role('admin', {'roles': None}))
self.assertFalse(user_has_role('admin', {})) self.assertFalse(user_has_role('admin', {}))

38
tests/test_api/test_bcloud_home_project.py
View File

@ -24,7 +24,7 @@ class AbstractHomeProjectTest(AbstractPillarTest):
Adds the 'homeproject' role too, which we need to get past the AB-testing. Adds the 'homeproject' role too, which we need to get past the AB-testing.
""" """
user_id = self.create_user(roles=roles.union({u'homeproject'}), user_id=user_id) user_id = self.create_user(roles=roles.union({'homeproject'}), user_id=user_id)
self.create_valid_auth_token(user_id, token) self.create_valid_auth_token(user_id, token)
return user_id return user_id
@ -34,7 +34,7 @@ class HomeProjectTest(AbstractHomeProjectTest):
from pillar.api.blender_cloud import home_project from pillar.api.blender_cloud import home_project
from pillar.api.utils.authentication import validate_token from pillar.api.utils.authentication import validate_token
user_id = self._create_user_with_token(roles={u'subscriber'}, token='token') user_id = self._create_user_with_token(roles={'subscriber'}, token='token')
# Test home project creation # Test home project creation
with self.app.test_request_context(headers={'Authorization': self.make_header('token')}): with self.app.test_request_context(headers={'Authorization': self.make_header('token')}):
@ -42,7 +42,7 @@ class HomeProjectTest(AbstractHomeProjectTest):
proj = home_project.create_home_project(user_id, write_access=True) proj = home_project.create_home_project(user_id, write_access=True)
self.assertEqual('home', proj['category']) self.assertEqual('home', proj['category'])
self.assertEqual({u'group', u'asset', u'comment'}, self.assertEqual({'group', 'asset', 'comment'},
set(nt['name'] for nt in proj['node_types'])) set(nt['name'] for nt in proj['node_types']))
endpoint = url_for('blender_cloud.home_project.home_project') endpoint = url_for('blender_cloud.home_project.home_project')
@ -143,11 +143,11 @@ class HomeProjectTest(AbstractHomeProjectTest):
admin_group_id = json_proj['permissions']['groups'][0]['group'] admin_group_id = json_proj['permissions']['groups'][0]['group']
# Check that a Blender Sync node was created automatically. # Check that a Blender Sync node was created automatically.
expected_node_permissions = {u'users': [], expected_node_permissions = {'users': [],
u'groups': [ 'groups': [
{u'group': ObjectId(admin_group_id), {'group': ObjectId(admin_group_id),
u'methods': [u'GET', u'PUT', u'POST', u'DELETE']}, ], 'methods': ['GET', 'PUT', 'POST', 'DELETE']}, ],
u'world': []} 'world': []}
with self.app.test_request_context(headers={'Authorization': self.make_header('token')}): with self.app.test_request_context(headers={'Authorization': self.make_header('token')}):
nodes_coll = self.app.data.driver.db['nodes'] nodes_coll = self.app.data.driver.db['nodes']
node = nodes_coll.find_one({ node = nodes_coll.find_one({
@ -191,7 +191,7 @@ class HomeProjectTest(AbstractHomeProjectTest):
from pillar.api.blender_cloud import home_project from pillar.api.blender_cloud import home_project
from pillar.api.utils.authentication import validate_token from pillar.api.utils.authentication import validate_token
user_id = self._create_user_with_token(roles={u'subscriber'}, token='token') user_id = self._create_user_with_token(roles={'subscriber'}, token='token')
# Test home project creation # Test home project creation
with self.app.test_request_context(headers={'Authorization': self.make_header('token')}): with self.app.test_request_context(headers={'Authorization': self.make_header('token')}):
@ -257,8 +257,8 @@ class HomeProjectTest(AbstractHomeProjectTest):
from pillar.api.blender_cloud import home_project from pillar.api.blender_cloud import home_project
from pillar.api.utils.authentication import validate_token from pillar.api.utils.authentication import validate_token
uid1 = self._create_user_with_token(roles={u'subscriber'}, token='token1', user_id=24 * 'a') uid1 = self._create_user_with_token(roles={'subscriber'}, token='token1', user_id=24 * 'a')
uid2 = self._create_user_with_token(roles={u'subscriber'}, token='token2', user_id=24 * 'b') uid2 = self._create_user_with_token(roles={'subscriber'}, token='token2', user_id=24 * 'b')
# Create home projects # Create home projects
with self.app.test_request_context(headers={'Authorization': self.make_header('token1')}): with self.app.test_request_context(headers={'Authorization': self.make_header('token1')}):
@ -292,7 +292,7 @@ class HomeProjectTest(AbstractHomeProjectTest):
def test_delete_restore(self): def test_delete_restore(self):
"""Deleting and then recreating a home project should restore the deleted project.""" """Deleting and then recreating a home project should restore the deleted project."""
self._create_user_with_token(roles={u'subscriber'}, token='token') self._create_user_with_token(roles={'subscriber'}, token='token')
# Create home project by getting it. # Create home project by getting it.
resp = self.client.get('/api/bcloud/home-project', resp = self.client.get('/api/bcloud/home-project',
@ -460,8 +460,8 @@ class TextureLibraryTest(AbstractHomeProjectTest):
libs = resp.json()['_items'] libs = resp.json()['_items']
library_project_ids = {proj['_id'] for proj in libs} library_project_ids = {proj['_id'] for proj in libs}
self.assertNotIn(unicode(self.hdri_proj_id), library_project_ids) self.assertNotIn(str(self.hdri_proj_id), library_project_ids)
self.assertIn(unicode(self.tex_proj_id), library_project_ids) self.assertIn(str(self.tex_proj_id), library_project_ids)
def test_hdri_library__old_bcloud_addon(self): def test_hdri_library__old_bcloud_addon(self):
resp = self.get('/api/bcloud/texture-libraries', resp = self.get('/api/bcloud/texture-libraries',
@ -469,8 +469,8 @@ class TextureLibraryTest(AbstractHomeProjectTest):
headers={'Blender-Cloud-Addon': '1.3.3'}) headers={'Blender-Cloud-Addon': '1.3.3'})
libs = resp.json()['_items'] libs = resp.json()['_items']
library_project_ids = {proj['_id'] for proj in libs} library_project_ids = {proj['_id'] for proj in libs}
self.assertNotIn(unicode(self.hdri_proj_id), library_project_ids) self.assertNotIn(str(self.hdri_proj_id), library_project_ids)
self.assertIn(unicode(self.tex_proj_id), library_project_ids) self.assertIn(str(self.tex_proj_id), library_project_ids)
def test_hdri_library__new_bcloud_addon(self): def test_hdri_library__new_bcloud_addon(self):
resp = self.get('/api/bcloud/texture-libraries', resp = self.get('/api/bcloud/texture-libraries',
@ -478,8 +478,8 @@ class TextureLibraryTest(AbstractHomeProjectTest):
headers={'Blender-Cloud-Addon': '1.4.0'}) headers={'Blender-Cloud-Addon': '1.4.0'})
libs = resp.json()['_items'] libs = resp.json()['_items']
library_project_ids = {proj['_id'] for proj in libs} library_project_ids = {proj['_id'] for proj in libs}
self.assertIn(unicode(self.hdri_proj_id), library_project_ids) self.assertIn(str(self.hdri_proj_id), library_project_ids)
self.assertIn(unicode(self.tex_proj_id), library_project_ids) self.assertIn(str(self.tex_proj_id), library_project_ids)
class HdriSortingTest(AbstractHomeProjectTest): class HdriSortingTest(AbstractHomeProjectTest):
@ -488,7 +488,7 @@ class HdriSortingTest(AbstractHomeProjectTest):
super(HdriSortingTest, self).setUp(**kwargs) super(HdriSortingTest, self).setUp(**kwargs)
self.user_id = self._create_user_with_token({u'subscriber'}, 'token') self.user_id = self._create_user_with_token({'subscriber'}, 'token')
self.hdri_proj_id, proj = self.ensure_project_exists(project_overrides={ self.hdri_proj_id, proj = self.ensure_project_exists(project_overrides={
'user': self.user_id, 'user': self.user_id,
'permissions': {'world': ['DELETE', 'GET', 'POST', 'PUT']}, 'permissions': {'world': ['DELETE', 'GET', 'POST', 'PUT']},

450
tests/test_api/test_cli.py
View File

@ -1,6 +1,6 @@
# -*- encoding: utf-8 -*- # -*- encoding: utf-8 -*-
from __future__ import absolute_import
import datetime import datetime
from bson import tz_util, ObjectId from bson import tz_util, ObjectId
@ -11,202 +11,202 @@ from pillar.api.projects.utils import get_node_type
EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA_ID = ObjectId('5673541534134154134513c3') EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA_ID = ObjectId('5673541534134154134513c3')
EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA = { EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA = {
u'_created': datetime.datetime(2015, 12, 17, 13, 22, 56, tzinfo=tz_util.utc), '_created': datetime.datetime(2015, 12, 17, 13, 22, 56, tzinfo=tz_util.utc),
u'_etag': u'cc4643e98d3606f87bbfaaa200bfbae941b642f3', '_etag': 'cc4643e98d3606f87bbfaaa200bfbae941b642f3',
u'_id': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA_ID, '_id': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA_ID,
u'_updated': datetime.datetime(2016, 1, 7, 18, 59, 4, tzinfo=tz_util.utc), '_updated': datetime.datetime(2016, 1, 7, 18, 59, 4, tzinfo=tz_util.utc),
u'category': u'assets', 'category': 'assets',
u'description': u'Welcome to this curated collection of Blender Institute textures and image ' 'description': 'Welcome to this curated collection of Blender Institute textures and image '
u'resources. This collection is an on-going project, as with each project we ' 'resources. This collection is an on-going project, as with each project we '
u'create a number of textures based on our own resources (photographs, scans, ' 'create a number of textures based on our own resources (photographs, scans, '
u'etc.) or made completely from scratch. At the moment you can find all the ' 'etc.) or made completely from scratch. At the moment you can find all the '
u'textures from the past Open Projects that were deemed re-usable. \r\n\r\n' 'textures from the past Open Projects that were deemed re-usable. \r\n\r\n'
u'People who have contributed to these textures:\r\n\r\nAndrea Weikert, Andy ' 'People who have contributed to these textures:\r\n\r\nAndrea Weikert, Andy '
u'Goralczyk, Basse Salmela, Ben Dansie, Campbell Barton, Enrico Valenza, Ian ' 'Goralczyk, Basse Salmela, Ben Dansie, Campbell Barton, Enrico Valenza, Ian '
u'Hubert, Kjartan Tysdal, Manu J\xe4rvinen, Massimiliana Pulieso, Matt Ebb, ' 'Hubert, Kjartan Tysdal, Manu J\xe4rvinen, Massimiliana Pulieso, Matt Ebb, '
u'Pablo Vazquez, Rob Tuytel, Roland Hess, Sarah Feldlaufer, S\xf6nke M\xe4ter', 'Pablo Vazquez, Rob Tuytel, Roland Hess, Sarah Feldlaufer, S\xf6nke M\xe4ter',
u'is_private': False, 'is_private': False,
u'name': u'Unittest project', 'name': 'Unittest project',
u'node_types': [ 'node_types': [
{u'description': u'Group for texture node type', {'description': 'Group for texture node type',
u'dyn_schema': {u'order': {u'type': u'integer'}, 'dyn_schema': {'order': {'type': 'integer'},
u'status': {u'allowed': [u'published', u'pending'], 'status': {'allowed': ['published', 'pending'],
u'type': u'string'}, 'type': 'string'},
u'url': {u'type': u'string'}}, 'url': {'type': 'string'}},
u'form_schema': {}, 'form_schema': {},
u'name': u'group_texture', 'name': 'group_texture',
u'parent': [u'group_texture', u'project']}, 'parent': ['group_texture', 'project']},
{u'description': u'Folder node', {'description': 'Folder node',
u'dyn_schema': {u'notes': {u'maxlength': 256, u'type': u'string'}, 'dyn_schema': {'notes': {'maxlength': 256, 'type': 'string'},
u'order': {u'type': u'integer'}, 'order': {'type': 'integer'},
u'status': {u'allowed': [u'published', u'pending'], 'status': {'allowed': ['published', 'pending'],
u'type': u'string'}, 'type': 'string'},
u'url': {u'type': u'string'}}, 'url': {'type': 'string'}},
u'form_schema': {}, 'form_schema': {},
u'name': u'group', 'name': 'group',
u'parent': [u'group', u'project']}, 'parent': ['group', 'project']},
{u'description': u'Basic Asset Type', {'description': 'Basic Asset Type',
u'dyn_schema': { 'dyn_schema': {
u'attachments': {u'schema': {u'schema': {u'field': {u'type': u'string'}, 'attachments': {'schema': {'schema': {'field': {'type': 'string'},
u'files': {u'schema': { 'files': {'schema': {
u'schema': {u'file': { 'schema': {'file': {
u'data_relation': { 'data_relation': {
u'embeddable': True, 'embeddable': True,
u'field': u'_id', 'field': '_id',
u'resource': u'files'}, 'resource': 'files'},
u'type': u'objectid'}, 'type': 'objectid'},
u'size': { 'size': {
u'type': u'string'}, 'type': 'string'},
u'slug': { 'slug': {
u'minlength': 1, 'minlength': 1,
u'type': u'string'}}, 'type': 'string'}},
u'type': u'dict'}, 'type': 'dict'},
u'type': u'list'}}, 'type': 'list'}},
u'type': u'dict'}, 'type': 'dict'},
u'type': u'list'}, 'type': 'list'},
u'categories': {u'type': u'string'}, 'categories': {'type': 'string'},
u'content_type': {u'type': u'string'}, 'content_type': {'type': 'string'},
u'file': {u'data_relation': {u'embeddable': True, 'file': {'data_relation': {'embeddable': True,
u'field': u'_id', 'field': '_id',
u'resource': u'files'}, 'resource': 'files'},
u'type': u'objectid'}, 'type': 'objectid'},
u'order': {u'type': u'integer'}, 'order': {'type': 'integer'},
u'status': {u'allowed': [u'published', 'status': {'allowed': ['published',
u'pending', 'pending',
u'processing'], 'processing'],
u'type': u'string'}, 'type': 'string'},
u'tags': {u'schema': {u'type': u'string'}, u'type': u'list'}}, 'tags': {'schema': {'type': 'string'}, 'type': 'list'}},
u'form_schema': {u'attachments': {u'visible': False}, 'form_schema': {'attachments': {'visible': False},
u'content_type': {u'visible': False}, 'content_type': {'visible': False},
u'file': {u'visible': False}}, 'file': {'visible': False}},
u'name': u'asset', 'name': 'asset',
u'parent': [u'group']}, 'parent': ['group']},
{u'description': u'Entrypoint to a remote or local storage solution', {'description': 'Entrypoint to a remote or local storage solution',
u'dyn_schema': {u'backend': {u'type': u'string'}, 'dyn_schema': {'backend': {'type': 'string'},
u'subdir': {u'type': u'string'}}, 'subdir': {'type': 'string'}},
u'form_schema': {u'backend': {}, u'subdir': {}}, 'form_schema': {'backend': {}, 'subdir': {}},
u'name': u'storage', 'name': 'storage',
u'parent': [u'group', u'project'], 'parent': ['group', 'project'],
u'permissions': {u'groups': [{u'group': ctd.EXAMPLE_ADMIN_GROUP_ID, 'permissions': {'groups': [{'group': ctd.EXAMPLE_ADMIN_GROUP_ID,
u'methods': [u'GET', u'PUT', u'POST']}, 'methods': ['GET', 'PUT', 'POST']},
{u'group': ctd.EXAMPLE_PROJECT_READONLY_GROUP_ID, {'group': ctd.EXAMPLE_PROJECT_READONLY_GROUP_ID,
u'methods': [u'GET']}, 'methods': ['GET']},
{u'group': ctd.EXAMPLE_PROJECT_READONLY_GROUP2_ID, {'group': ctd.EXAMPLE_PROJECT_READONLY_GROUP2_ID,
u'methods': [u'GET']}], 'methods': ['GET']}],
u'users': [], 'users': [],
u'world': []}}, 'world': []}},
{u'description': u'Comments for asset nodes, pages, etc.', {'description': 'Comments for asset nodes, pages, etc.',
u'dyn_schema': {u'confidence': {u'type': u'float'}, 'dyn_schema': {'confidence': {'type': 'float'},
u'content': {u'minlength': 5, u'type': u'string'}, 'content': {'minlength': 5, 'type': 'string'},
u'is_reply': {u'type': u'boolean'}, 'is_reply': {'type': 'boolean'},
u'rating_negative': {u'type': u'integer'}, 'rating_negative': {'type': 'integer'},
u'rating_positive': {u'type': u'integer'}, 'rating_positive': {'type': 'integer'},
u'ratings': {u'schema': { 'ratings': {'schema': {
u'schema': {u'is_positive': {u'type': u'boolean'}, 'schema': {'is_positive': {'type': 'boolean'},
u'user': {u'type': u'objectid'}, 'user': {'type': 'objectid'},
u'weight': {u'type': u'integer'}}, 'weight': {'type': 'integer'}},
u'type': u'dict'}, 'type': 'dict'},
u'type': u'list'}, 'type': 'list'},
u'status': {u'allowed': [u'published', u'flagged', u'edited'], 'status': {'allowed': ['published', 'flagged', 'edited'],
u'type': u'string'}}, 'type': 'string'}},
u'form_schema': {}, 'form_schema': {},
u'name': u'comment', 'name': 'comment',
u'parent': [u'asset', u'comment']}, 'parent': ['asset', 'comment']},
{u'description': u'Container for node_type post.', {'description': 'Container for node_type post.',
u'dyn_schema': {u'categories': {u'schema': {u'type': u'string'}, 'dyn_schema': {'categories': {'schema': {'type': 'string'},
u'type': u'list'}, 'type': 'list'},
u'template': {u'type': u'string'}}, 'template': {'type': 'string'}},
u'form_schema': {}, 'form_schema': {},
u'name': u'blog', 'name': 'blog',
u'parent': [u'project']}, 'parent': ['project']},
{u'description': u'A blog post, for any project', {'description': 'A blog post, for any project',
u'dyn_schema': { 'dyn_schema': {
u'attachments': {u'schema': {u'schema': {u'field': {u'type': u'string'}, 'attachments': {'schema': {'schema': {'field': {'type': 'string'},
u'files': {u'schema': { 'files': {'schema': {
u'schema': {u'file': { 'schema': {'file': {
u'data_relation': { 'data_relation': {
u'embeddable': True, 'embeddable': True,
u'field': u'_id', 'field': '_id',
u'resource': u'files'}, 'resource': 'files'},
u'type': u'objectid'}, 'type': 'objectid'},
u'size': { 'size': {
u'type': u'string'}, 'type': 'string'},
u'slug': { 'slug': {
u'minlength': 1, 'minlength': 1,
u'type': u'string'}}, 'type': 'string'}},
u'type': u'dict'}, 'type': 'dict'},
u'type': u'list'}}, 'type': 'list'}},
u'type': u'dict'}, 'type': 'dict'},
u'type': u'list'}, 'type': 'list'},
u'category': {u'type': u'string'}, 'category': {'type': 'string'},
u'content': {u'maxlength': 90000, 'content': {'maxlength': 90000,
u'minlength': 5, 'minlength': 5,
u'required': True, 'required': True,
u'type': u'string'}, 'type': 'string'},
u'status': {u'allowed': [u'published', u'pending'], 'status': {'allowed': ['published', 'pending'],
u'default': u'pending', 'default': 'pending',
u'type': u'string'}, 'type': 'string'},
u'url': {u'type': u'string'}}, 'url': {'type': 'string'}},
u'form_schema': {u'attachments': {u'visible': False}}, 'form_schema': {'attachments': {'visible': False}},
u'name': u'post', 'name': 'post',
u'parent': [u'blog']}, 'parent': ['blog']},
{u'description': u'Image Texture', {'description': 'Image Texture',
u'dyn_schema': {u'aspect_ratio': {u'type': u'float'}, 'dyn_schema': {'aspect_ratio': {'type': 'float'},
u'categories': {u'type': u'string'}, 'categories': {'type': 'string'},
u'files': {u'schema': {u'schema': { 'files': {'schema': {'schema': {
u'file': {u'data_relation': {u'embeddable': True, 'file': {'data_relation': {'embeddable': True,
u'field': u'_id', 'field': '_id',
u'resource': u'files'}, 'resource': 'files'},
u'type': u'objectid'}, 'type': 'objectid'},
u'is_tileable': {u'type': u'boolean'}, 'is_tileable': {'type': 'boolean'},
u'map_type': {u'allowed': [u'color', 'map_type': {'allowed': ['color',
u'specular', 'specular',
u'bump', 'bump',
u'normal', 'normal',
u'translucency', 'translucency',
u'emission', 'emission',
u'alpha'], 'alpha'],
u'type': u'string'}}, 'type': 'string'}},
u'type': u'dict'}, 'type': 'dict'},
u'type': u'list'}, 'type': 'list'},
u'is_landscape': {u'type': u'boolean'}, 'is_landscape': {'type': 'boolean'},
u'is_tileable': {u'type': u'boolean'}, 'is_tileable': {'type': 'boolean'},
u'order': {u'type': u'integer'}, 'order': {'type': 'integer'},
u'resolution': {u'type': u'string'}, 'resolution': {'type': 'string'},
u'status': {u'allowed': [u'published', 'status': {'allowed': ['published',
u'pending', 'pending',
u'processing'], 'processing'],
u'type': u'string'}, 'type': 'string'},
u'tags': {u'schema': {u'type': u'string'}, u'type': u'list'}}, 'tags': {'schema': {'type': 'string'}, 'type': 'list'}},
u'form_schema': {u'content_type': {u'visible': False}, 'form_schema': {'content_type': {'visible': False},
u'files': {u'visible': False}}, 'files': {'visible': False}},
u'name': u'texture', 'name': 'texture',
u'parent': [u'group']}], 'parent': ['group']}],
u'nodes_blog': [], 'nodes_blog': [],
u'nodes_featured': [], 'nodes_featured': [],
u'nodes_latest': [], 'nodes_latest': [],
u'permissions': {u'groups': [{u'group': ctd.EXAMPLE_ADMIN_GROUP_ID, 'permissions': {'groups': [{'group': ctd.EXAMPLE_ADMIN_GROUP_ID,
u'methods': [u'GET', u'POST', u'PUT', u'DELETE']}], 'methods': ['GET', 'POST', 'PUT', 'DELETE']}],
u'users': [], 'users': [],
u'world': [u'GET']}, 'world': ['GET']},
u'status': u'published', 'status': 'published',
u'summary': u'Texture collection from all Blender Institute open projects.', 'summary': 'Texture collection from all Blender Institute open projects.',
u'url': u'attachment-schema-update', 'url': 'attachment-schema-update',
u'picture_header': ObjectId('5673f260c379cf0007b31bc4'), 'picture_header': ObjectId('5673f260c379cf0007b31bc4'),
u'picture_square': ObjectId('5673f256c379cf0007b31bc3'), 'picture_square': ObjectId('5673f256c379cf0007b31bc3'),
u'user': ctd.EXAMPLE_PROJECT_OWNER_ID} 'user': ctd.EXAMPLE_PROJECT_OWNER_ID}
EXAMPLE_ASSET_NODE_OLD_ATTACHMENT_SCHEMA = { EXAMPLE_ASSET_NODE_OLD_ATTACHMENT_SCHEMA = {
u'_id': ObjectId('572761099837730efe8e120d'), '_id': ObjectId('572761099837730efe8e120d'),
u'picture': ObjectId('5673f260c379cf0007b31bc4'), 'picture': ObjectId('5673f260c379cf0007b31bc4'),
u'description': u'', 'description': '',
u'node_type': u'asset', 'node_type': 'asset',
u'user': ctd.EXAMPLE_PROJECT_OWNER_ID, 'user': ctd.EXAMPLE_PROJECT_OWNER_ID,
u'properties': { 'properties': {
u'status': u'published', 'status': 'published',
u'content_type': u'image', 'content_type': 'image',
u'file': ObjectId('5673f260c379cf0007b31bed'), 'file': ObjectId('5673f260c379cf0007b31bed'),
u'attachments': [{ 'attachments': [{
'files': [ 'files': [
{'slug': '01', 'file': ObjectId('5679b25ec379cf25636688f6')}, {'slug': '01', 'file': ObjectId('5679b25ec379cf25636688f6')},
{'slug': '02b', 'file': ObjectId('5679b308c379cf25636688f7')}, {'slug': '02b', 'file': ObjectId('5679b308c379cf25636688f7')},
@ -215,24 +215,24 @@ EXAMPLE_ASSET_NODE_OLD_ATTACHMENT_SCHEMA = {
'field': 'properties.content' 'field': 'properties.content'
}], }],
}, },
u'_updated': datetime.datetime(2016, 5, 2, 14, 19, 58, 0, tzinfo=tz_util.utc), '_updated': datetime.datetime(2016, 5, 2, 14, 19, 58, 0, tzinfo=tz_util.utc),
u'name': u'Image test', 'name': 'Image test',
u'project': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA_ID, 'project': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA_ID,
u'_created': datetime.datetime(2016, 5, 2, 14, 19, 37, 0, tzinfo=tz_util.utc), '_created': datetime.datetime(2016, 5, 2, 14, 19, 37, 0, tzinfo=tz_util.utc),
u'_etag': u'6b8589b42c880e3626f43f3e82a5c5b946742687' '_etag': '6b8589b42c880e3626f43f3e82a5c5b946742687'
} }
EXAMPLE_PAGE_NODE_OLD_ATTACHMENT_SCHEMA = { EXAMPLE_PAGE_NODE_OLD_ATTACHMENT_SCHEMA = {
u'_id': ObjectId('572761099837730efe8e120a'), '_id': ObjectId('572761099837730efe8e120a'),
u'picture': ObjectId('5673f260c379cf0007b31bc4'), 'picture': ObjectId('5673f260c379cf0007b31bc4'),
u'description': u'', 'description': '',
u'node_type': u'page', 'node_type': 'page',
u'user': ctd.EXAMPLE_PROJECT_OWNER_ID, 'user': ctd.EXAMPLE_PROJECT_OWNER_ID,
u'properties': { 'properties': {
u'status': u'published', 'status': 'published',
u'content': u'Überinteressant Verhaaltje™ voor het slapengaan.', 'content': 'Überinteressant Verhaaltje™ voor het slapengaan.',
u'url': u'jemoeder', 'url': 'jemoeder',
u'attachments': [{ 'attachments': [{
'files': [ 'files': [
{'slug': '03', 'file': ObjectId('5679b33bc379cf256366ddd8')}, {'slug': '03', 'file': ObjectId('5679b33bc379cf256366ddd8')},
{'slug': '04', 'file': ObjectId('5679b35bc379cf256366ddd9')}, {'slug': '04', 'file': ObjectId('5679b35bc379cf256366ddd9')},
@ -240,11 +240,11 @@ EXAMPLE_PAGE_NODE_OLD_ATTACHMENT_SCHEMA = {
'field': 'properties.content' 'field': 'properties.content'
}], }],
}, },
u'_updated': datetime.datetime(2016, 5, 2, 14, 19, 58, 0, tzinfo=tz_util.utc), '_updated': datetime.datetime(2016, 5, 2, 14, 19, 58, 0, tzinfo=tz_util.utc),
u'name': u'Page test', 'name': 'Page test',
u'project': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA_ID, 'project': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA_ID,
u'_created': datetime.datetime(2016, 5, 2, 14, 19, 37, 0, tzinfo=tz_util.utc), '_created': datetime.datetime(2016, 5, 2, 14, 19, 37, 0, tzinfo=tz_util.utc),
u'_etag': u'6b8589b42c880e3626f43f3e82a5c5b946742687' '_etag': '6b8589b42c880e3626f43f3e82a5c5b946742687'
} }
@ -258,11 +258,11 @@ class AbstractNodeReplacementTest(AbstractPillarTest):
project_overrides=self.project_overrides) project_overrides=self.project_overrides)
self.ensure_file_exists({ self.ensure_file_exists({
'_id': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA[u'picture_header'], '_id': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA['picture_header'],
'project': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA_ID, 'project': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA_ID,
}) })
self.ensure_file_exists({ self.ensure_file_exists({
'_id': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA[u'picture_square'], '_id': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA['picture_square'],
'project': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA_ID, 'project': EXAMPLE_PROJECT_OLD_ATTACHMENT_SCHEMA_ID,
}) })
@ -270,8 +270,8 @@ class AbstractNodeReplacementTest(AbstractPillarTest):
return super(AbstractNodeReplacementTest, self).fetch_project_from_db(self.project_id) return super(AbstractNodeReplacementTest, self).fetch_project_from_db(self.project_id)
def add_group_permission_to_asset_node_type(self): def add_group_permission_to_asset_node_type(self):
group_perms = {u'group': ctd.EXAMPLE_PROJECT_READONLY_GROUP_ID, group_perms = {'group': ctd.EXAMPLE_PROJECT_READONLY_GROUP_ID,
u'methods': [u'POST', u'PUT']} 'methods': ['POST', 'PUT']}
# Assign some permissions to the node types, so we're sure they don't get overwritten. # Assign some permissions to the node types, so we're sure they don't get overwritten.
with self.app.app_context(): with self.app.app_context():
proj_coll = self.app.db()['projects'] proj_coll = self.app.db()['projects']
@ -314,13 +314,13 @@ class UpgradeAttachmentSchemaTest(AbstractNodeReplacementTest):
super(UpgradeAttachmentSchemaTest, self).setUp(**kwargs) super(UpgradeAttachmentSchemaTest, self).setUp(**kwargs)
self.ensure_file_exists( self.ensure_file_exists(
{'_id': EXAMPLE_ASSET_NODE_OLD_ATTACHMENT_SCHEMA[u'properties'][u'file']}) {'_id': EXAMPLE_ASSET_NODE_OLD_ATTACHMENT_SCHEMA['properties']['file']})
for node in (EXAMPLE_ASSET_NODE_OLD_ATTACHMENT_SCHEMA, for node in (EXAMPLE_ASSET_NODE_OLD_ATTACHMENT_SCHEMA,
EXAMPLE_PAGE_NODE_OLD_ATTACHMENT_SCHEMA): EXAMPLE_PAGE_NODE_OLD_ATTACHMENT_SCHEMA):
for att in node[u'properties'][u'attachments']: for att in node['properties']['attachments']:
for filedict in att[u'files']: for filedict in att['files']:
self.ensure_file_exists({'_id': filedict[u'file']}) self.ensure_file_exists({'_id': filedict['file']})
def test_schema_upgrade(self): def test_schema_upgrade(self):
from pillar.cli import upgrade_attachment_schema from pillar.cli import upgrade_attachment_schema
@ -348,8 +348,8 @@ class CreateBlogTest(AbstractPillarTest):
AbstractPillarTest.setUp(self, **kwargs) AbstractPillarTest.setUp(self, **kwargs)
self.project_id, self.proj = self.ensure_project_exists() self.project_id, self.proj = self.ensure_project_exists()
self.ensure_file_exists({'_id': self.proj[u'picture_header']}) self.ensure_file_exists({'_id': self.proj['picture_header']})
self.ensure_file_exists({'_id': self.proj[u'picture_square']}) self.ensure_file_exists({'_id': self.proj['picture_square']})
def test_create_blog(self): def test_create_blog(self):
"""Very simple test to check the create_blog CLI command.""" """Very simple test to check the create_blog CLI command."""

4
tests/test_api/test_file_caching.py
View File

@ -25,7 +25,7 @@ class FileCachingTest(AbstractPillarTest):
# Make sure the file link has not expired. # Make sure the file link has not expired.
expires = datetime.datetime.now(tz=bson.tz_util.utc) + datetime.timedelta(minutes=1) expires = datetime.datetime.now(tz=bson.tz_util.utc) + datetime.timedelta(minutes=1)
file_id, file_doc = self.ensure_file_exists(file_overrides={ file_id, file_doc = self.ensure_file_exists(file_overrides={
u'link_expires': expires 'link_expires': expires
}) })
updated = file_doc['_updated'].strftime(RFC1123_DATE_FORMAT) updated = file_doc['_updated'].strftime(RFC1123_DATE_FORMAT)
@ -49,7 +49,7 @@ class FileCachingTest(AbstractPillarTest):
# Make sure the file link has expired. # Make sure the file link has expired.
expires = datetime.datetime.now(tz=bson.tz_util.utc) - datetime.timedelta(seconds=1) expires = datetime.datetime.now(tz=bson.tz_util.utc) - datetime.timedelta(seconds=1)
file_id, file_doc = self.ensure_file_exists(file_overrides={ file_id, file_doc = self.ensure_file_exists(file_overrides={
u'link_expires': expires 'link_expires': expires
}) })
updated = file_doc['_updated'].strftime(RFC1123_DATE_FORMAT) updated = file_doc['_updated'].strftime(RFC1123_DATE_FORMAT)

16
tests/test_api/test_file_storage.py
View File

@ -75,8 +75,8 @@ class FileAccessTest(AbstractPillarTest):
img_file_id, _ = self.ensure_file_exists() img_file_id, _ = self.ensure_file_exists()
video_file_id, _ = self.ensure_file_exists({ video_file_id, _ = self.ensure_file_exists({
u'_id': None, '_id': None,
u'content_type': u'video/matroska', 'content_type': 'video/matroska',
'variations': [ 'variations': [
{ {
'format': 'mp4', 'format': 'mp4',
@ -105,14 +105,14 @@ class FileAccessTest(AbstractPillarTest):
] ]
}) })
blend_file_id, _ = self.ensure_file_exists({u'_id': None, blend_file_id, _ = self.ensure_file_exists({'_id': None,
u'content_type': u'application/x-blender', 'content_type': 'application/x-blender',
u'variations': None}) 'variations': None})
nonsub_user_id = self.create_user(user_id='cafef00dcafef00d00000000', roles=()) nonsub_user_id = self.create_user(user_id='cafef00dcafef00d00000000', roles=())
sub_user_id = self.create_user(user_id='cafef00dcafef00dcafef00d', roles=(u'subscriber',)) sub_user_id = self.create_user(user_id='cafef00dcafef00dcafef00d', roles=('subscriber',))
demo_user_id = self.create_user(user_id='cafef00dcafef00ddeadbeef', roles=(u'demo',)) demo_user_id = self.create_user(user_id='cafef00dcafef00ddeadbeef', roles=('demo',))
admin_user_id = self.create_user(user_id='aaaaaaaaaaaaaaaaaaaaaaaa', roles=(u'admin',)) admin_user_id = self.create_user(user_id='aaaaaaaaaaaaaaaaaaaaaaaa', roles=('admin',))
self.create_valid_auth_token(nonsub_user_id, 'nonsub-token') self.create_valid_auth_token(nonsub_user_id, 'nonsub-token')
self.create_valid_auth_token(sub_user_id, 'sub-token') self.create_valid_auth_token(sub_user_id, 'sub-token')

18
tests/test_api/test_file_storage_moving.py
View File

@ -1,5 +1,3 @@
from __future__ import absolute_import
import datetime import datetime
import responses import responses
@ -47,11 +45,11 @@ class ChangeBackendTest(AbstractPillarTest):
files_coll = self.app.data.driver.db['files'] files_coll = self.app.data.driver.db['files']
fdoc = files_coll.find_one(image_file_id) fdoc = files_coll.find_one(image_file_id)
self.assertEqual(u'gcs', fdoc['backend']) self.assertEqual('gcs', fdoc['backend'])
self.assertIn(u'/path/to/testing/gcs/', fdoc['link']) self.assertIn('/path/to/testing/gcs/', fdoc['link'])
for variation in fdoc['variations']: for variation in fdoc['variations']:
self.assertIn(u'/path/to/testing/gcs/', variation['link']) self.assertIn('/path/to/testing/gcs/', variation['link'])
@mock.activate @mock.activate
def test_only_variations(self): def test_only_variations(self):
@ -77,11 +75,11 @@ class ChangeBackendTest(AbstractPillarTest):
files_coll = self.app.data.driver.db['files'] files_coll = self.app.data.driver.db['files']
fdoc = files_coll.find_one(image_file_id) fdoc = files_coll.find_one(image_file_id)
self.assertEqual(u'gcs', fdoc['backend']) self.assertEqual('gcs', fdoc['backend'])
self.assertIn(u'/path/to/testing/gcs/', fdoc['link']) self.assertIn('/path/to/testing/gcs/', fdoc['link'])
for variation in fdoc['variations']: for variation in fdoc['variations']:
self.assertIn(u'/path/to/testing/gcs/', variation['link']) self.assertIn('/path/to/testing/gcs/', variation['link'])
@mock.activate @mock.activate
def test_no_variations(self): def test_no_variations(self):
@ -102,8 +100,8 @@ class ChangeBackendTest(AbstractPillarTest):
files_coll = self.app.data.driver.db['files'] files_coll = self.app.data.driver.db['files']
fdoc = files_coll.find_one(image_file_id) fdoc = files_coll.find_one(image_file_id)
self.assertEqual(u'gcs', fdoc['backend']) self.assertEqual('gcs', fdoc['backend'])
self.assertIn(u'/path/to/testing/gcs/', fdoc['link']) self.assertIn('/path/to/testing/gcs/', fdoc['link'])
def _create_image_file_doc(self, variations=True): def _create_image_file_doc(self, variations=True):
fdoc = {'status': 'complete', 'name': 'some-hash.jpg', 'backend': 'unittest', fdoc = {'status': 'complete', 'name': 'some-hash.jpg', 'backend': 'unittest',

14
tests/test_api/test_link_refresh.py
View File

@ -9,13 +9,13 @@ from datetime import datetime, timedelta
class LinkRefreshTest(AbstractPillarTest): class LinkRefreshTest(AbstractPillarTest):
# noinspection PyMethodOverriding # noinspection PyMethodOverriding
def ensure_file_exists(self, file_overrides): def ensure_file_exists(self, file_overrides):
file_id = file_overrides[u'_id'] file_id = file_overrides['_id']
file_overrides.update({ file_overrides.update({
u'_id': ObjectId(file_id), '_id': ObjectId(file_id),
u'name': '%s.png' % file_id, 'name': '%s.png' % file_id,
u'file_path': '%s.png' % file_id, 'file_path': '%s.png' % file_id,
u'backend': 'unittest', 'backend': 'unittest',
}) })
return super(LinkRefreshTest, self).ensure_file_exists(file_overrides) return super(LinkRefreshTest, self).ensure_file_exists(file_overrides)
@ -33,8 +33,8 @@ class LinkRefreshTest(AbstractPillarTest):
datetime(2016, 3, 22, 9, 28, 3, tzinfo=tz_util.utc), datetime(2016, 3, 22, 9, 28, 3, tzinfo=tz_util.utc),
self.now + timedelta(minutes=30), self.now + timedelta(minutes=90), ] self.now + timedelta(minutes=30), self.now + timedelta(minutes=90), ]
ids_and_files = [self.ensure_file_exists(file_overrides={ ids_and_files = [self.ensure_file_exists(file_overrides={
u'_id': 'cafef00ddeadbeef0000000%i' % file_idx, '_id': 'cafef00ddeadbeef0000000%i' % file_idx,
u'link_expires': expiry}) 'link_expires': expiry})
for file_idx, expiry in enumerate(expiry)] for file_idx, expiry in enumerate(expiry)]
self.file_id, self.file = zip(*ids_and_files) self.file_id, self.file = zip(*ids_and_files)

16
tests/test_api/test_nodes.py
View File

@ -43,7 +43,7 @@ class NodeContentTypeTest(AbstractPillarTest):
g.current_user = {'user_id': user_id, g.current_user = {'user_id': user_id,
# This group is hardcoded in the EXAMPLE_PROJECT. # This group is hardcoded in the EXAMPLE_PROJECT.
'groups': [ObjectId('5596e975ea893b269af85c0e')], 'groups': [ObjectId('5596e975ea893b269af85c0e')],
'roles': {u'subscriber', u'admin'}} 'roles': {'subscriber', 'admin'}}
nodes = self.app.data.driver.db['nodes'] nodes = self.app.data.driver.db['nodes']
# Create the node. # Create the node.
@ -81,7 +81,7 @@ class NodeContentTypeTest(AbstractPillarTest):
self.assertEqual(200, resp.status_code) self.assertEqual(200, resp.status_code)
data = json.loads(resp.data) data = json.loads(resp.data)
self.assertEqual([u'GET'], data['allowed_methods']) self.assertEqual(['GET'], data['allowed_methods'])
def test_default_picture_image_asset(self): def test_default_picture_image_asset(self):
from pillar.api.utils import dumps from pillar.api.utils import dumps
@ -240,12 +240,12 @@ class NodeSharingTest(AbstractPillarTest):
self.project_id, _ = self.ensure_project_exists( self.project_id, _ = self.ensure_project_exists(
project_overrides={ project_overrides={
u'category': 'home', 'category': 'home',
u'permissions': 'permissions':
{u'groups': [{u'group': ctd.EXAMPLE_ADMIN_GROUP_ID, {'groups': [{'group': ctd.EXAMPLE_ADMIN_GROUP_ID,
u'methods': [u'GET', u'POST', u'PUT', u'DELETE']}], 'methods': ['GET', 'POST', 'PUT', 'DELETE']}],
u'users': [], 'users': [],
u'world': []}} 'world': []}}
) )
self.user_id = self.create_user(groups=[ctd.EXAMPLE_ADMIN_GROUP_ID]) self.user_id = self.create_user(groups=[ctd.EXAMPLE_ADMIN_GROUP_ID])
self.create_valid_auth_token(self.user_id, 'token') self.create_valid_auth_token(self.user_id, 'token')

2
tests/test_api/test_nodes_moving.py
View File

@ -1,5 +1,3 @@
from __future__ import absolute_import, print_function
import unittest import unittest
import mock import mock

26
tests/test_api/test_patch.py
View File

@ -60,7 +60,7 @@ class VoteCommentTest(AbstractPatchCommentTest):
patched_node = self.get(self.node_url, auth_token='token').json() patched_node = self.get(self.node_url, auth_token='token').json()
self.assertEqual(1, patched_node['properties']['rating_positive']) self.assertEqual(1, patched_node['properties']['rating_positive'])
self.assertEqual(0, patched_node['properties']['rating_negative']) self.assertEqual(0, patched_node['properties']['rating_negative'])
self.assertEqual({u'user': str(self.user_id), u'is_positive': True}, self.assertEqual({'user': str(self.user_id), 'is_positive': True},
patched_node['properties']['ratings'][0]) patched_node['properties']['ratings'][0])
self.assertEqual(1, len(patched_node['properties']['ratings'])) self.assertEqual(1, len(patched_node['properties']['ratings']))
@ -81,7 +81,7 @@ class VoteCommentTest(AbstractPatchCommentTest):
patched_node = self.get(self.node_url, auth_token='token').json() patched_node = self.get(self.node_url, auth_token='token').json()
self.assertEqual(0, patched_node['properties']['rating_positive']) self.assertEqual(0, patched_node['properties']['rating_positive'])
self.assertEqual(1, patched_node['properties']['rating_negative']) self.assertEqual(1, patched_node['properties']['rating_negative'])
self.assertEqual({u'user': str(self.user_id), u'is_positive': False}, self.assertEqual({'user': str(self.user_id), 'is_positive': False},
patched_node['properties']['ratings'][0]) patched_node['properties']['ratings'][0])
self.assertEqual(1, len(patched_node['properties']['ratings'])) self.assertEqual(1, len(patched_node['properties']['ratings']))
@ -157,11 +157,11 @@ class VoteCommentTest(AbstractPatchCommentTest):
self.assertEqual(3, patched_node['properties']['rating_positive']) self.assertEqual(3, patched_node['properties']['rating_positive'])
self.assertEqual(2, patched_node['properties']['rating_negative']) self.assertEqual(2, patched_node['properties']['rating_negative'])
self.assertEqual([ self.assertEqual([
{u'user': unicode(other_user_ids[0]), u'is_positive': True}, {'user': str(other_user_ids[0]), 'is_positive': True},
{u'user': unicode(other_user_ids[1]), u'is_positive': True}, {'user': str(other_user_ids[1]), 'is_positive': True},
{u'user': unicode(other_user_ids[3]), u'is_positive': True}, {'user': str(other_user_ids[3]), 'is_positive': True},
{u'user': unicode(other_user_ids[4]), u'is_positive': False}, {'user': str(other_user_ids[4]), 'is_positive': False},
{u'user': unicode(self.user_id), u'is_positive': False}, {'user': str(self.user_id), 'is_positive': False},
], patched_node['properties'].get('ratings', [])) ], patched_node['properties'].get('ratings', []))
@ -172,19 +172,19 @@ class EditCommentTest(AbstractPatchCommentTest):
res = self.patch(self.node_url, res = self.patch(self.node_url,
json={'op': 'edit', 'content': 'Je moeder is niet je vader.'}, json={'op': 'edit', 'content': 'Je moeder is niet je vader.'},
auth_token=token).json() auth_token=token).json()
self.assertEqual(u'<p>Je moeder is niet je vader.</p>\n', self.assertEqual('<p>Je moeder is niet je vader.</p>\n',
res['properties']['content_html']) res['properties']['content_html'])
# Get the node again, to inspect its changed state. # Get the node again, to inspect its changed state.
patched_node = self.get(self.node_url, auth_token=token).json() patched_node = self.get(self.node_url, auth_token=token).json()
self.assertEqual(u'Je moeder is niet je vader.', self.assertEqual('Je moeder is niet je vader.',
patched_node['properties']['content']) patched_node['properties']['content'])
self.assertEqual(u'<p>Je moeder is niet je vader.</p>\n', self.assertEqual('<p>Je moeder is niet je vader.</p>\n',
patched_node['properties']['content_html']) patched_node['properties']['content_html'])
self.assertNotEqual(pre_node['_etag'], patched_node['_etag']) self.assertNotEqual(pre_node['_etag'], patched_node['_etag'])
def test_comment_edit_other_user_admin(self): def test_comment_edit_other_user_admin(self):
admin_id = self.create_user(user_id=24 * 'c', roles={u'admin'}) admin_id = self.create_user(user_id=24 * 'c', roles={'admin'})
self.create_valid_auth_token(admin_id, 'admin-token') self.create_valid_auth_token(admin_id, 'admin-token')
self.test_comment_edit_happy(token='admin-token') self.test_comment_edit_happy(token='admin-token')
@ -197,9 +197,9 @@ class EditCommentTest(AbstractPatchCommentTest):
# Get the node again, to inspect its old state. # Get the node again, to inspect its old state.
patched_node = self.get(self.node_url, auth_token='token').json() patched_node = self.get(self.node_url, auth_token='token').json()
self.assertEqual(u'Purrrr kittycat', self.assertEqual('Purrrr kittycat',
patched_node['properties']['content']) patched_node['properties']['content'])
self.assertEqual(u'<p>Purrrr kittycat</p>\n', self.assertEqual('<p>Purrrr kittycat</p>\n',
patched_node['properties']['content_html']) patched_node['properties']['content_html'])
def test_edit_noncomment_node(self): def test_edit_noncomment_node(self):

82
tests/test_api/test_project_management.py
View File

@ -5,7 +5,7 @@
import functools import functools
import json import json
import logging import logging
import urllib import urllib.request, urllib.parse, urllib.error
from bson import ObjectId from bson import ObjectId
from pillar.tests import AbstractPillarTest from pillar.tests import AbstractPillarTest
@ -26,7 +26,7 @@ class AbstractProjectTest(AbstractPillarTest):
return resp return resp
def _create_user_and_project(self, roles, user_id='cafef00df00df00df00df00d', token='token', def _create_user_and_project(self, roles, user_id='cafef00df00df00df00df00d', token='token',
project_name=u'Prøject El Niño'): project_name='Prøject El Niño'):
self._create_user_with_token(roles, token, user_id=user_id) self._create_user_with_token(roles, token, user_id=user_id)
resp = self._create_project(project_name, token) resp = self._create_project(project_name, token)
@ -38,8 +38,8 @@ class AbstractProjectTest(AbstractPillarTest):
class ProjectCreationTest(AbstractProjectTest): class ProjectCreationTest(AbstractProjectTest):
def test_project_creation_wrong_role(self): def test_project_creation_wrong_role(self):
self._create_user_with_token([u'whatever'], 'token') self._create_user_with_token(['whatever'], 'token')
resp = self._create_project(u'Prøject El Niño', 'token') resp = self._create_project('Prøject El Niño', 'token')
self.assertEqual(403, resp.status_code) self.assertEqual(403, resp.status_code)
@ -49,8 +49,8 @@ class ProjectCreationTest(AbstractProjectTest):
self.assertEqual(0, len(list(projects.find()))) self.assertEqual(0, len(list(projects.find())))
def test_project_creation_good_role(self): def test_project_creation_good_role(self):
user_id = self._create_user_with_token([u'subscriber'], 'token') user_id = self._create_user_with_token(['subscriber'], 'token')
resp = self._create_project(u'Prøject El Niño', 'token') resp = self._create_project('Prøject El Niño', 'token')
self.assertEqual(201, resp.status_code) self.assertEqual(201, resp.status_code)
# The response of a POST is the entire project, but we'll test a GET on # The response of a POST is the entire project, but we'll test a GET on
@ -69,7 +69,7 @@ class ProjectCreationTest(AbstractProjectTest):
project_id = project['_id'] project_id = project['_id']
# Check some of the more complex/interesting fields. # Check some of the more complex/interesting fields.
self.assertEqual(u'Prøject El Niño', project['name']) self.assertEqual('Prøject El Niño', project['name'])
self.assertEqual(str(user_id), project['user']) self.assertEqual(str(user_id), project['user'])
self.assertEqual('p-%s' % project_id, project['url']) self.assertEqual('p-%s' % project_id, project['url'])
self.assertEqual(1, len(project['permissions']['groups'])) self.assertEqual(1, len(project['permissions']['groups']))
@ -95,13 +95,13 @@ class ProjectCreationTest(AbstractProjectTest):
def test_project_creation_access_admin(self): def test_project_creation_access_admin(self):
"""Admin-created projects should be public""" """Admin-created projects should be public"""
proj = self._create_user_and_project(roles={u'admin'}) proj = self._create_user_and_project(roles={'admin'})
self.assertEqual(['GET'], proj['permissions']['world']) self.assertEqual(['GET'], proj['permissions']['world'])
def test_project_creation_access_subscriber(self): def test_project_creation_access_subscriber(self):
"""Subscriber-created projects should be private""" """Subscriber-created projects should be private"""
proj = self._create_user_and_project(roles={u'subscriber'}) proj = self._create_user_and_project(roles={'subscriber'})
self.assertEqual([], proj['permissions']['world']) self.assertEqual([], proj['permissions']['world'])
self.assertTrue(proj['is_private']) self.assertTrue(proj['is_private'])
@ -116,12 +116,12 @@ class ProjectCreationTest(AbstractProjectTest):
"""Test that we get an empty list when querying for non-existing projects, instead of 403""" """Test that we get an empty list when querying for non-existing projects, instead of 403"""
proj_a = self._create_user_and_project(user_id=24 * 'a', proj_a = self._create_user_and_project(user_id=24 * 'a',
roles={u'subscriber'}, roles={'subscriber'},
project_name=u'Prøject A', project_name='Prøject A',
token='token-a') token='token-a')
proj_b = self._create_user_and_project(user_id=24 * 'b', proj_b = self._create_user_and_project(user_id=24 * 'b',
roles={u'subscriber'}, roles={'subscriber'},
project_name=u'Prøject B', project_name='Prøject B',
token='token-b') token='token-b')
# Assertion: each user must have access to their own project. # Assertion: each user must have access to their own project.
@ -137,16 +137,16 @@ class ProjectCreationTest(AbstractProjectTest):
headers={'Authorization': self.make_header('token-a')}) headers={'Authorization': self.make_header('token-a')})
self.assertEqual(200, resp.status_code) self.assertEqual(200, resp.status_code)
proj_list = json.loads(resp.data) proj_list = json.loads(resp.data)
self.assertEqual({u'Prøject A'}, {p['name'] for p in proj_list['_items']}) self.assertEqual({'Prøject A'}, {p['name'] for p in proj_list['_items']})
resp = self.client.get('/api/projects', resp = self.client.get('/api/projects',
headers={'Authorization': self.make_header('token-b')}) headers={'Authorization': self.make_header('token-b')})
self.assertEqual(200, resp.status_code) self.assertEqual(200, resp.status_code)
proj_list = json.loads(resp.data) proj_list = json.loads(resp.data)
self.assertEqual({u'Prøject B'}, {p['name'] for p in proj_list['_items']}) self.assertEqual({'Prøject B'}, {p['name'] for p in proj_list['_items']})
# No access to anything for user C, should result in empty list. # No access to anything for user C, should result in empty list.
self._create_user_with_token(roles={u'subscriber'}, token='token-c', user_id=12 * 'c') self._create_user_with_token(roles={'subscriber'}, token='token-c', user_id=12 * 'c')
resp = self.client.get('/api/projects', resp = self.client.get('/api/projects',
headers={'Authorization': self.make_header('token-c')}) headers={'Authorization': self.make_header('token-c')})
self.assertEqual(200, resp.status_code) self.assertEqual(200, resp.status_code)
@ -161,7 +161,7 @@ class ProjectEditTest(AbstractProjectTest):
from pillar.api.utils import remove_private_keys, PillarJSONEncoder from pillar.api.utils import remove_private_keys, PillarJSONEncoder
dumps = functools.partial(json.dumps, cls=PillarJSONEncoder) dumps = functools.partial(json.dumps, cls=PillarJSONEncoder)
project_info = self._create_user_and_project([u'subscriber']) project_info = self._create_user_and_project(['subscriber'])
project_url = '/api/projects/%(_id)s' % project_info project_url = '/api/projects/%(_id)s' % project_info
resp = self.client.get(project_url, resp = self.client.get(project_url,
@ -180,11 +180,11 @@ class ProjectEditTest(AbstractProjectTest):
# Regular user should be able to PUT, but only be able to edit certain fields. # Regular user should be able to PUT, but only be able to edit certain fields.
put_project = remove_private_keys(project) put_project = remove_private_keys(project)
put_project['url'] = u'very-offensive-url' put_project['url'] = 'very-offensive-url'
put_project['description'] = u'Blender je besplatan set alata za izradu interaktivnog 3D ' \ put_project['description'] = 'Blender je besplatan set alata za izradu interaktivnog 3D ' \
u'sadržaja pod različitim operativnim sustavima.' 'sadržaja pod različitim operativnim sustavima.'
put_project['name'] = u'โครงการปั่นเมฆ' put_project['name'] = 'โครงการปั่นเมฆ'
put_project['summary'] = u'Это переведена на Google' put_project['summary'] = 'Это переведена на Google'
put_project['status'] = 'pending' put_project['status'] = 'pending'
put_project['category'] = 'software' put_project['category'] = 'software'
put_project['user'] = other_user_id put_project['user'] = other_user_id
@ -222,7 +222,7 @@ class ProjectEditTest(AbstractProjectTest):
from pillar.api.utils import remove_private_keys, PillarJSONEncoder from pillar.api.utils import remove_private_keys, PillarJSONEncoder
dumps = functools.partial(json.dumps, cls=PillarJSONEncoder) dumps = functools.partial(json.dumps, cls=PillarJSONEncoder)
project_info = self._create_user_and_project([u'subscriber', u'admin']) project_info = self._create_user_and_project(['subscriber', 'admin'])
project_url = '/api/projects/%(_id)s' % project_info project_url = '/api/projects/%(_id)s' % project_info
resp = self.client.get(project_url) resp = self.client.get(project_url)
@ -234,11 +234,11 @@ class ProjectEditTest(AbstractProjectTest):
# Admin user should be able to PUT everything. # Admin user should be able to PUT everything.
put_project = remove_private_keys(project) put_project = remove_private_keys(project)
put_project['url'] = u'very-offensive-url' put_project['url'] = 'very-offensive-url'
put_project['description'] = u'Blender je besplatan set alata za izradu interaktivnog 3D ' \ put_project['description'] = 'Blender je besplatan set alata za izradu interaktivnog 3D ' \
u'sadržaja pod različitim operativnim sustavima.' 'sadržaja pod različitim operativnim sustavima.'
put_project['name'] = u'โครงการปั่นเมฆ' put_project['name'] = 'โครงการปั่นเมฆ'
put_project['summary'] = u'Это переведена на Google' put_project['summary'] = 'Это переведена на Google'
put_project['is_private'] = False put_project['is_private'] = False
put_project['status'] = 'pending' put_project['status'] = 'pending'
put_project['category'] = 'software' put_project['category'] = 'software'
@ -272,7 +272,7 @@ class ProjectEditTest(AbstractProjectTest):
dumps = functools.partial(json.dumps, cls=PillarJSONEncoder) dumps = functools.partial(json.dumps, cls=PillarJSONEncoder)
# Create test project. # Create test project.
project = self._create_user_and_project([u'subscriber']) project = self._create_user_and_project(['subscriber'])
project_id = project['_id'] project_id = project['_id']
project_url = '/api/projects/%s' % project_id project_url = '/api/projects/%s' % project_id
@ -281,7 +281,7 @@ class ProjectEditTest(AbstractProjectTest):
# Admin user should be able to PUT. # Admin user should be able to PUT.
put_project = remove_private_keys(project) put_project = remove_private_keys(project)
put_project['name'] = u'โครงการปั่นเมฆ' put_project['name'] = 'โครงการปั่นเมฆ'
resp = self.client.put(project_url, resp = self.client.put(project_url,
data=dumps(put_project), data=dumps(put_project),
@ -297,7 +297,7 @@ class ProjectEditTest(AbstractProjectTest):
dumps = functools.partial(json.dumps, cls=PillarJSONEncoder) dumps = functools.partial(json.dumps, cls=PillarJSONEncoder)
# Create test project. # Create test project.
project = self._create_user_and_project([u'subscriber']) project = self._create_user_and_project(['subscriber'])
project_id = project['_id'] project_id = project['_id']
project_url = '/api/projects/%s' % project_id project_url = '/api/projects/%s' % project_id
@ -307,7 +307,7 @@ class ProjectEditTest(AbstractProjectTest):
# Regular subscriber should not be able to do this. # Regular subscriber should not be able to do this.
put_project = remove_private_keys(project) put_project = remove_private_keys(project)
put_project['name'] = u'Болту́н -- нахо́дка для шпио́на.' put_project['name'] = 'Болту́н -- нахо́дка для шпио́на.'
put_project['user'] = my_user_id put_project['user'] = my_user_id
resp = self.client.put(project_url, resp = self.client.put(project_url,
data=dumps(put_project), data=dumps(put_project),
@ -318,7 +318,7 @@ class ProjectEditTest(AbstractProjectTest):
def test_delete_by_admin(self): def test_delete_by_admin(self):
# Create public test project. # Create public test project.
project_info = self._create_user_and_project([u'admin']) project_info = self._create_user_and_project(['admin'])
project_id = project_info['_id'] project_id = project_info['_id']
project_url = '/api/projects/%s' % project_id project_url = '/api/projects/%s' % project_id
@ -338,7 +338,7 @@ class ProjectEditTest(AbstractProjectTest):
# ... but we should still get it in the body. # ... but we should still get it in the body.
db_proj = json.loads(resp.data) db_proj = json.loads(resp.data)
self.assertEqual(u'Prøject El Niño', db_proj['name']) self.assertEqual('Prøject El Niño', db_proj['name'])
self.assertTrue(db_proj['_deleted']) self.assertTrue(db_proj['_deleted'])
# Querying for deleted projects should include it. # Querying for deleted projects should include it.
@ -347,16 +347,16 @@ class ProjectEditTest(AbstractProjectTest):
projection = json.dumps({'name': 1, 'permissions': 1}) projection = json.dumps({'name': 1, 'permissions': 1})
where = json.dumps({'_deleted': True}) # MUST be True, 1 does not work. where = json.dumps({'_deleted': True}) # MUST be True, 1 does not work.
resp = self.client.get('/api/projects?where=%s&projection=%s' % resp = self.client.get('/api/projects?where=%s&projection=%s' %
(urllib.quote(where), urllib.quote(projection))) (urllib.parse.quote(where), urllib.parse.quote(projection)))
self.assertEqual(200, resp.status_code, resp.data) self.assertEqual(200, resp.status_code, resp.data)
projlist = json.loads(resp.data) projlist = json.loads(resp.data)
self.assertEqual(1, projlist['_meta']['total']) self.assertEqual(1, projlist['_meta']['total'])
self.assertEqual(u'Prøject El Niño', projlist['_items'][0]['name']) self.assertEqual('Prøject El Niño', projlist['_items'][0]['name'])
def test_delete_by_subscriber(self): def test_delete_by_subscriber(self):
# Create test project. # Create test project.
project_info = self._create_user_and_project([u'subscriber']) project_info = self._create_user_and_project(['subscriber'])
project_id = project_info['_id'] project_id = project_info['_id']
project_url = '/api/projects/%s' % project_id project_url = '/api/projects/%s' % project_id
@ -383,14 +383,14 @@ class ProjectNodeAccess(AbstractProjectTest):
from pillar.api.utils import PillarJSONEncoder from pillar.api.utils import PillarJSONEncoder
# Project is created by regular subscriber, so should be private. # Project is created by regular subscriber, so should be private.
self.user_id = self._create_user_with_token([u'subscriber'], 'token') self.user_id = self._create_user_with_token(['subscriber'], 'token')
resp = self._create_project(u'Prøject El Niño', 'token') resp = self._create_project('Prøject El Niño', 'token')
self.assertEqual(201, resp.status_code) self.assertEqual(201, resp.status_code)
self.assertEqual('application/json', resp.mimetype) self.assertEqual('application/json', resp.mimetype)
self.project = json.loads(resp.data) self.project = json.loads(resp.data)
self.project_id = ObjectId(self.project['_id']) self.project_id = ObjectId(self.project['_id'])
self.other_user_id = self._create_user_with_token([u'subscriber'], 'other-token', self.other_user_id = self._create_user_with_token(['subscriber'], 'other-token',
user_id='deadbeefdeadbeefcafef00d') user_id='deadbeefdeadbeefcafef00d')
self.test_node = { self.test_node = {
@ -435,7 +435,7 @@ class ProjectNodeAccess(AbstractProjectTest):
headers={'Authorization': self.make_header('token')}) headers={'Authorization': self.make_header('token')})
self.assertEqual(200, resp.status_code, (resp.status_code, resp.data)) self.assertEqual(200, resp.status_code, (resp.status_code, resp.data))
listed_nodes = json.loads(resp.data)['_items'] listed_nodes = json.loads(resp.data)['_items']
self.assertEquals(self.node_id, listed_nodes[0]['_id']) self.assertEqual(self.node_id, listed_nodes[0]['_id'])
# Listing all nodes should not include nodes from private projects. # Listing all nodes should not include nodes from private projects.
resp = self.client.get('/api/nodes', resp = self.client.get('/api/nodes',

10
tests/test_api/test_service_badger.py
View File

@ -11,8 +11,8 @@ class BadgerServiceTest(AbstractPillarTest):
with self.app.test_request_context(): with self.app.test_request_context():
self.badger, token_doc = service.create_service_account( self.badger, token_doc = service.create_service_account(
'serviceaccount@example.com', [u'badger'], 'serviceaccount@example.com', ['badger'],
{u'badger': [u'succubus', u'subscriber', u'demo']} {'badger': ['succubus', 'subscriber', 'demo']}
) )
self.badger_token = token_doc['token'] self.badger_token = token_doc['token']
@ -33,7 +33,7 @@ class BadgerServiceTest(AbstractPillarTest):
with self.app.test_request_context(): with self.app.test_request_context():
user = self.app.data.driver.db['users'].find_one(self.user_id) user = self.app.data.driver.db['users'].find_one(self.user_id)
self.assertIn(u'succubus', user['roles']) self.assertIn('succubus', user['roles'])
# Aaaahhhw it's gone again # Aaaahhhw it's gone again
resp = self._post({'action': 'revoke', 'user_email': self.user_email, 'role': 'succubus'}) resp = self._post({'action': 'revoke', 'user_email': self.user_email, 'role': 'succubus'})
@ -41,7 +41,7 @@ class BadgerServiceTest(AbstractPillarTest):
with self.app.test_request_context(): with self.app.test_request_context():
user = self.app.data.driver.db['users'].find_one(self.user_id) user = self.app.data.driver.db['users'].find_one(self.user_id)
self.assertNotIn(u'succubus', user['roles']) self.assertNotIn('succubus', user['roles'])
def test_grant_not_allowed_badge(self): def test_grant_not_allowed_badge(self):
resp = self._post({'action': 'grant', 'user_email': self.user_email, 'role': 'admin'}) resp = self._post({'action': 'grant', 'user_email': self.user_email, 'role': 'admin'})
@ -49,7 +49,7 @@ class BadgerServiceTest(AbstractPillarTest):
with self.app.test_request_context(): with self.app.test_request_context():
user = self.app.data.driver.db['users'].find_one(self.user_id) user = self.app.data.driver.db['users'].find_one(self.user_id)
self.assertNotIn(u'admin', user['roles']) self.assertNotIn('admin', user['roles'])
def test_group_membership(self): def test_group_membership(self):
"""Certain roles are linked to certain groups.""" """Certain roles are linked to certain groups."""

28
tests/test_api/test_utils.py
View File

@ -1,5 +1,5 @@
# -*- encoding: utf-8 -*- # -*- encoding: utf-8 -*-
from __future__ import absolute_import
import unittest import unittest
from bson import ObjectId from bson import ObjectId
@ -16,7 +16,7 @@ class Str2idTest(AbstractPillarTest):
happy(24 * 'a') happy(24 * 'a')
happy(12 * 'a') happy(12 * 'a')
happy(u'577e23ad98377323f74c368c') happy('577e23ad98377323f74c368c')
def test_unhappy(self): def test_unhappy(self):
from pillar.api.utils import str2id from pillar.api.utils import str2id
@ -25,10 +25,10 @@ class Str2idTest(AbstractPillarTest):
self.assertRaises(BadRequest, str2id, str_id) self.assertRaises(BadRequest, str2id, str_id)
unhappy(13 * 'a') unhappy(13 * 'a')
unhappy(u'577e23ad 8377323f74c368c') unhappy('577e23ad 8377323f74c368c')
unhappy(u'김치') # Kimchi unhappy('김치') # Kimchi
unhappy('')
unhappy('') unhappy('')
unhappy(u'')
unhappy(None) unhappy(None)
@ -84,26 +84,26 @@ class DocDiffTest(unittest.TestCase):
def test_no_diff_nested(self): def test_no_diff_nested(self):
from pillar.api.utils import doc_diff from pillar.api.utils import doc_diff
diff = doc_diff({'a': 'b', 'props': {'status': u'todo', 'notes': u'jemoeder'}}, diff = doc_diff({'a': 'b', 'props': {'status': 'todo', 'notes': 'jemoeder'}},
{'a': 'b', 'props': {'status': u'todo', 'notes': u'jemoeder'}}) {'a': 'b', 'props': {'status': 'todo', 'notes': 'jemoeder'}})
self.assertEqual([], list(diff)) self.assertEqual([], list(diff))
def test_diff_values_nested(self): def test_diff_values_nested(self):
from pillar.api.utils import doc_diff from pillar.api.utils import doc_diff
diff = doc_diff({'a': 'b', 'props': {'status': u'todo', 'notes': u'jemoeder'}}, diff = doc_diff({'a': 'b', 'props': {'status': 'todo', 'notes': 'jemoeder'}},
{'a': 'c', 'props': {'status': u'done', 'notes': u'jemoeder'}}) {'a': 'c', 'props': {'status': 'done', 'notes': 'jemoeder'}})
self.assertEqual({('a', 'b', 'c'), ('props.status', u'todo', u'done')}, self.assertEqual({('a', 'b', 'c'), ('props.status', 'todo', 'done')},
set(diff)) set(diff))
def test_diff_keys_nested(self): def test_diff_keys_nested(self):
from pillar.api.utils import doc_diff, DoesNotExist from pillar.api.utils import doc_diff, DoesNotExist
diff = doc_diff({'a': 'b', 'props': {'status1': u'todo', 'notes': u'jemoeder'}}, diff = doc_diff({'a': 'b', 'props': {'status1': 'todo', 'notes': 'jemoeder'}},
{'a': 'b', 'props': {'status2': u'todo', 'notes': u'jemoeder'}}) {'a': 'b', 'props': {'status2': 'todo', 'notes': 'jemoeder'}})
self.assertEqual({('props.status1', u'todo', DoesNotExist), self.assertEqual({('props.status1', 'todo', DoesNotExist),
('props.status2', DoesNotExist, u'todo')}, ('props.status2', DoesNotExist, 'todo')},
set(diff)) set(diff))

4
tests/test_sdk.py
View File

@ -84,8 +84,8 @@ class FlaskInternalApiTest(AbstractPillarTest):
with self.app.test_request_context(), open(blender_desktop_logo_path, 'rb') as fileobj: with self.app.test_request_context(), open(blender_desktop_logo_path, 'rb') as fileobj:
resp = pillarsdk.Node.create_asset_from_file( resp = pillarsdk.Node.create_asset_from_file(
unicode(self.project_id), str(self.project_id),
unicode(parent_id), str(parent_id),
'image', 'image',
blender_desktop_logo_path, blender_desktop_logo_path,
mimetype='image/jpeg', mimetype='image/jpeg',

8
tests/test_web/test_user_admin.py
View File

@ -2,8 +2,6 @@
"""Unit tests for the user admin interface.""" """Unit tests for the user admin interface."""
from __future__ import absolute_import
import json import json
import logging import logging
@ -32,7 +30,7 @@ class UserAdminTest(AbstractPillarTest):
import pillar.web.users.routes import pillar.web.users.routes
import pillar.auth import pillar.auth
user_id = self.create_user(roles=(u'mønkeybütler', )) user_id = self.create_user(roles=('mønkeybütler', ))
self.create_valid_auth_token(user_id, 'token') self.create_valid_auth_token(user_id, 'token')
# Try to access the home project, creating it. # Try to access the home project, creating it.
@ -72,7 +70,7 @@ class UserAdminTest(AbstractPillarTest):
dbuser = get_dbuser() dbuser = get_dbuser()
self.assertEqual({home_project_gid, self.subscriber_gid, self.demo_gid}, self.assertEqual({home_project_gid, self.subscriber_gid, self.demo_gid},
set(dbuser['groups'])) set(dbuser['groups']))
self.assertEqual({u'subscriber', u'demo', u'mønkeybütler'}, self.assertEqual({'subscriber', 'demo', 'mønkeybütler'},
set(dbuser['roles'])) set(dbuser['roles']))
# Edit user again, revoking demo role. # Edit user again, revoking demo role.
@ -80,5 +78,5 @@ class UserAdminTest(AbstractPillarTest):
dbuser = get_dbuser() dbuser = get_dbuser()
self.assertEqual({home_project_gid, self.subscriber_gid}, self.assertEqual({home_project_gid, self.subscriber_gid},
set(dbuser['groups'])) set(dbuser['groups']))
self.assertEqual({u'subscriber', u'mønkeybütler'}, self.assertEqual({'subscriber', 'mønkeybütler'},
set(dbuser['roles'])) set(dbuser['roles']))

12
tests/test_web/test_utils.py
View File

@ -1,7 +1,5 @@
# -*- encoding: utf-8 -*- # -*- encoding: utf-8 -*-
from __future__ import absolute_import
import unittest import unittest
import datetime import datetime
@ -13,20 +11,20 @@ class IsValidIdTest(unittest.TestCase):
def test_valid(self): def test_valid(self):
# 24-byte hex strings # 24-byte hex strings
self.assertTrue(utils.is_valid_id(24 * 'a')) self.assertTrue(utils.is_valid_id(24 * 'a'))
self.assertTrue(utils.is_valid_id(24 * u'a')) self.assertTrue(utils.is_valid_id(24 * 'a'))
self.assertTrue(utils.is_valid_id('deadbeefbeefcacedeadcace'))
self.assertTrue(utils.is_valid_id('deadbeefbeefcacedeadcace')) self.assertTrue(utils.is_valid_id('deadbeefbeefcacedeadcace'))
self.assertTrue(utils.is_valid_id(u'deadbeefbeefcacedeadcace'))
# 12-byte arbitrary ASCII strings # 12-byte arbitrary ASCII strings
self.assertTrue(utils.is_valid_id('DeadBeefCake')) self.assertTrue(utils.is_valid_id('DeadBeefCake'))
self.assertTrue(utils.is_valid_id(u'DeadBeefCake')) self.assertTrue(utils.is_valid_id('DeadBeefCake'))
# 12-byte str object # 12-byte str object
self.assertTrue(utils.is_valid_id('beef€67890')) self.assertTrue(utils.is_valid_id('beef€67890'))
def test_bad_length(self): def test_bad_length(self):
self.assertFalse(utils.is_valid_id(23 * 'a')) self.assertFalse(utils.is_valid_id(23 * 'a'))
self.assertFalse(utils.is_valid_id(25 * u'a')) self.assertFalse(utils.is_valid_id(25 * 'a'))
def test_non_string(self): def test_non_string(self):
self.assertFalse(utils.is_valid_id(None)) self.assertFalse(utils.is_valid_id(None))
@ -38,7 +36,7 @@ class IsValidIdTest(unittest.TestCase):
self.assertFalse(utils.is_valid_id('deadbeefbeefcakedeadcake')) self.assertFalse(utils.is_valid_id('deadbeefbeefcakedeadcake'))
# unicode variant of valid 12-byte str object # unicode variant of valid 12-byte str object
self.assertFalse(utils.is_valid_id(u'beef€67890')) self.assertFalse(utils.is_valid_id('beef€67890'))
class PrettyDateTest(unittest.TestCase): class PrettyDateTest(unittest.TestCase):