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 e0c525389f
commit bced6cae68
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']
if nt['name'] == 'texture')
_texture_nt['permissions'] = {'groups': [
{u'group': ObjectId('5596e975ea893b269af85c0f'), u'methods': [u'GET']},
{u'group': ObjectId('564733b56dcaf85da2faee8a'), u'methods': [u'GET']}
{'group': ObjectId('5596e975ea893b269af85c0f'), 'methods': ['GET']},
{'group': ObjectId('564733b56dcaf85da2faee8a'), 'methods': ['GET']}
]}
_asset_nt = next(nt for nt in EXAMPLE_PROJECT['node_types']
if nt['name'] == 'asset')
_asset_nt['permissions'] = {'groups': [
{u'group': ObjectId('5596e975ea893b269af85c0f'), u'methods': [u'DELETE', u'GET']},
{u'group': ObjectId('564733b56dcaf85da2faee8a'), u'methods': [u'GET']}
{'group': ObjectId('5596e975ea893b269af85c0f'), 'methods': ['DELETE', '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 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)
future = now + datetime.timedelta(days=1)
@ -174,7 +174,7 @@ class AuthenticationTests(AbstractPillarTest):
users = self.app.data.driver.db['users']
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):
"""Expired tokens should be deleted from the database."""
@ -207,9 +207,9 @@ class UserListTests(AbstractPillarTest):
def setUp(self, **kwargs):
super(UserListTests, self).setUp()
self.create_user(roles=[u'subscriber'], user_id='123456789abc123456789abc')
self.create_user(roles=[u'admin'], user_id='223456789abc123456789abc')
self.create_user(roles=[u'subscriber'], user_id='323456789abc123456789abc')
self.create_user(roles=['subscriber'], user_id='123456789abc123456789abc')
self.create_user(roles=['admin'], user_id='223456789abc123456789abc')
self.create_user(roles=['subscriber'], user_id='323456789abc123456789abc')
self.create_valid_auth_token('123456789abc123456789abc', 'token')
self.create_valid_auth_token('223456789abc123456789abc', 'admin-token')
@ -371,7 +371,7 @@ class UserListTests(AbstractPillarTest):
'roles': ['subscriber'],
'settings': {'email_communications': 1},
'auth': [],
'full_name': u'คนรักของผัดไทย',
'full_name': 'คนรักของผัดไทย',
'email': TEST_EMAIL_ADDRESS,
}
@ -464,22 +464,22 @@ class PermissionComputationTest(AbstractPillarTest):
# Test project permissions.
self.assertEqual(
{
u'groups': [{u'group': ObjectId('5596e975ea893b269af85c0e'),
u'methods': [u'DELETE', u'GET', u'POST', u'PUT']}],
u'world': [u'GET']
'groups': [{'group': ObjectId('5596e975ea893b269af85c0e'),
'methods': ['DELETE', 'GET', 'POST', 'PUT']}],
'world': ['GET']
},
self.sort(compute_aggr_permissions('projects', EXAMPLE_PROJECT, None)))
# Test node type permissions.
self.assertEqual(
{
u'groups': [{u'group': ObjectId('5596e975ea893b269af85c0e'),
u'methods': [u'DELETE', u'GET', u'POST', u'PUT']},
{u'group': ObjectId('5596e975ea893b269af85c0f'),
u'methods': [u'GET']},
{u'group': ObjectId('564733b56dcaf85da2faee8a'),
u'methods': [u'GET']}],
u'world': [u'GET']
'groups': [{'group': ObjectId('5596e975ea893b269af85c0e'),
'methods': ['DELETE', 'GET', 'POST', 'PUT']},
{'group': ObjectId('5596e975ea893b269af85c0f'),
'methods': ['GET']},
{'group': ObjectId('564733b56dcaf85da2faee8a'),
'methods': ['GET']}],
'world': ['GET']
},
self.sort(compute_aggr_permissions('projects', EXAMPLE_PROJECT, 'texture')))
@ -492,13 +492,13 @@ class PermissionComputationTest(AbstractPillarTest):
# Test node permissions without embedded project.
self.ensure_project_exists(project_overrides=EXAMPLE_PROJECT)
self.assertEqual(
{u'groups': [{u'group': ObjectId('5596e975ea893b269af85c0e'),
u'methods': [u'DELETE', u'GET', u'POST', u'PUT']},
{u'group': ObjectId('5596e975ea893b269af85c0f'),
u'methods': [u'DELETE', u'GET']},
{u'group': ObjectId('564733b56dcaf85da2faee8a'),
u'methods': [u'GET']}],
u'world': [u'GET']},
{'groups': [{'group': ObjectId('5596e975ea893b269af85c0e'),
'methods': ['DELETE', 'GET', 'POST', 'PUT']},
{'group': ObjectId('5596e975ea893b269af85c0f'),
'methods': ['DELETE', 'GET']},
{'group': ObjectId('564733b56dcaf85da2faee8a'),
'methods': ['GET']}],
'world': ['GET']},
self.sort(compute_aggr_permissions('nodes', node, None)))
with self.app.test_request_context():
@ -506,13 +506,13 @@ class PermissionComputationTest(AbstractPillarTest):
node = copy.deepcopy(EXAMPLE_NODE)
node['project'] = EXAMPLE_PROJECT
self.assertEqual(
{u'groups': [{u'group': ObjectId('5596e975ea893b269af85c0e'),
u'methods': [u'DELETE', u'GET', u'POST', u'PUT']},
{u'group': ObjectId('5596e975ea893b269af85c0f'),
u'methods': [u'DELETE', u'GET']},
{u'group': ObjectId('564733b56dcaf85da2faee8a'),
u'methods': [u'GET']}],
u'world': [u'GET']},
{'groups': [{'group': ObjectId('5596e975ea893b269af85c0e'),
'methods': ['DELETE', 'GET', 'POST', 'PUT']},
{'group': ObjectId('5596e975ea893b269af85c0f'),
'methods': ['DELETE', 'GET']},
{'group': ObjectId('564733b56dcaf85da2faee8a'),
'methods': ['GET']}],
'world': ['GET']},
self.sort(compute_aggr_permissions('nodes', node, None)))
@ -529,7 +529,7 @@ class RequireRolesTest(AbstractPillarTest):
with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'succubus']}
'roles': ['succubus']}
call_me()
self.assertTrue(called[0])
@ -540,19 +540,19 @@ class RequireRolesTest(AbstractPillarTest):
called = [False]
@require_login(require_roles={u'admin'})
@require_login(require_roles={'admin'})
def call_me():
called[0] = True
with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'succubus']}
'roles': ['succubus']}
self.assertRaises(Forbidden, call_me)
self.assertFalse(called[0])
with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'admin']}
'roles': ['admin']}
call_me()
self.assertTrue(called[0])
@ -562,32 +562,32 @@ class RequireRolesTest(AbstractPillarTest):
called = [False]
@require_login(require_roles={u'service', u'badger'},
@require_login(require_roles={'service', 'badger'},
require_all=True)
def call_me():
called[0] = True
with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'admin']}
'roles': ['admin']}
self.assertRaises(Forbidden, call_me)
self.assertFalse(called[0])
with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'service']}
'roles': ['service']}
self.assertRaises(Forbidden, call_me)
self.assertFalse(called[0])
with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'badger']}
'roles': ['badger']}
self.assertRaises(Forbidden, call_me)
self.assertFalse(called[0])
with self.app.test_request_context():
g.current_user = {'user_id': ObjectId(24 * 'a'),
'roles': [u'service', u'badger']}
'roles': ['service', 'badger']}
call_me()
self.assertTrue(called[0])
@ -596,8 +596,8 @@ class RequireRolesTest(AbstractPillarTest):
with self.app.test_request_context():
self.assertTrue(user_has_role('subscriber', {'roles': ['aap', 'noot', 'subscriber']}))
self.assertTrue(user_has_role('subscriber', {'roles': [u'aap', u'subscriber']}))
self.assertFalse(user_has_role('admin', {'roles': [u'aap', u'noot', u'subscriber']}))
self.assertTrue(user_has_role('subscriber', {'roles': ['aap', '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': None}))
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.
"""
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)
return user_id
@ -34,7 +34,7 @@ class HomeProjectTest(AbstractHomeProjectTest):
from pillar.api.blender_cloud import home_project
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
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)
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']))
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']
# Check that a Blender Sync node was created automatically.
expected_node_permissions = {u'users': [],
u'groups': [
{u'group': ObjectId(admin_group_id),
u'methods': [u'GET', u'PUT', u'POST', u'DELETE']}, ],
u'world': []}
expected_node_permissions = {'users': [],
'groups': [
{'group': ObjectId(admin_group_id),
'methods': ['GET', 'PUT', 'POST', 'DELETE']}, ],
'world': []}
with self.app.test_request_context(headers={'Authorization': self.make_header('token')}):
nodes_coll = self.app.data.driver.db['nodes']
node = nodes_coll.find_one({
@ -191,7 +191,7 @@ class HomeProjectTest(AbstractHomeProjectTest):
from pillar.api.blender_cloud import home_project
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
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.utils.authentication import validate_token
uid1 = self._create_user_with_token(roles={u'subscriber'}, token='token1', user_id=24 * 'a')
uid2 = self._create_user_with_token(roles={u'subscriber'}, token='token2', user_id=24 * 'b')
uid1 = self._create_user_with_token(roles={'subscriber'}, token='token1', user_id=24 * 'a')
uid2 = self._create_user_with_token(roles={'subscriber'}, token='token2', user_id=24 * 'b')
# Create home projects
with self.app.test_request_context(headers={'Authorization': self.make_header('token1')}):
@ -292,7 +292,7 @@ class HomeProjectTest(AbstractHomeProjectTest):
def test_delete_restore(self):
"""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.
resp = self.client.get('/api/bcloud/home-project',
@ -460,8 +460,8 @@ class TextureLibraryTest(AbstractHomeProjectTest):
libs = resp.json()['_items']
library_project_ids = {proj['_id'] for proj in libs}
self.assertNotIn(unicode(self.hdri_proj_id), library_project_ids)
self.assertIn(unicode(self.tex_proj_id), library_project_ids)
self.assertNotIn(str(self.hdri_proj_id), library_project_ids)
self.assertIn(str(self.tex_proj_id), library_project_ids)
def test_hdri_library__old_bcloud_addon(self):
resp = self.get('/api/bcloud/texture-libraries',
@ -469,8 +469,8 @@ class TextureLibraryTest(AbstractHomeProjectTest):
headers={'Blender-Cloud-Addon': '1.3.3'})
libs = resp.json()['_items']
library_project_ids = {proj['_id'] for proj in libs}
self.assertNotIn(unicode(self.hdri_proj_id), library_project_ids)
self.assertIn(unicode(self.tex_proj_id), library_project_ids)
self.assertNotIn(str(self.hdri_proj_id), library_project_ids)
self.assertIn(str(self.tex_proj_id), library_project_ids)
def test_hdri_library__new_bcloud_addon(self):
resp = self.get('/api/bcloud/texture-libraries',
@ -478,8 +478,8 @@ class TextureLibraryTest(AbstractHomeProjectTest):
headers={'Blender-Cloud-Addon': '1.4.0'})
libs = resp.json()['_items']
library_project_ids = {proj['_id'] for proj in libs}
self.assertIn(unicode(self.hdri_proj_id), library_project_ids)
self.assertIn(unicode(self.tex_proj_id), library_project_ids)
self.assertIn(str(self.hdri_proj_id), library_project_ids)
self.assertIn(str(self.tex_proj_id), library_project_ids)
class HdriSortingTest(AbstractHomeProjectTest):
@ -488,7 +488,7 @@ class HdriSortingTest(AbstractHomeProjectTest):
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={
'user': self.user_id,
'permissions': {'world': ['DELETE', 'GET', 'POST', 'PUT']},

450
tests/test_api/test_cli.py
View File

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

16
tests/test_api/test_file_storage.py
View File

@ -75,8 +75,8 @@ class FileAccessTest(AbstractPillarTest):
img_file_id, _ = self.ensure_file_exists()
video_file_id, _ = self.ensure_file_exists({
u'_id': None,
u'content_type': u'video/matroska',
'_id': None,
'content_type': 'video/matroska',
'variations': [
{
'format': 'mp4',
@ -105,14 +105,14 @@ class FileAccessTest(AbstractPillarTest):
]
})
blend_file_id, _ = self.ensure_file_exists({u'_id': None,
u'content_type': u'application/x-blender',
u'variations': None})
blend_file_id, _ = self.ensure_file_exists({'_id': None,
'content_type': 'application/x-blender',
'variations': None})
nonsub_user_id = self.create_user(user_id='cafef00dcafef00d00000000', roles=())
sub_user_id = self.create_user(user_id='cafef00dcafef00dcafef00d', roles=(u'subscriber',))
demo_user_id = self.create_user(user_id='cafef00dcafef00ddeadbeef', roles=(u'demo',))
admin_user_id = self.create_user(user_id='aaaaaaaaaaaaaaaaaaaaaaaa', roles=(u'admin',))
sub_user_id = self.create_user(user_id='cafef00dcafef00dcafef00d', roles=('subscriber',))
demo_user_id = self.create_user(user_id='cafef00dcafef00ddeadbeef', roles=('demo',))
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(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 responses
@ -47,11 +45,11 @@ class ChangeBackendTest(AbstractPillarTest):
files_coll = self.app.data.driver.db['files']
fdoc = files_coll.find_one(image_file_id)
self.assertEqual(u'gcs', fdoc['backend'])
self.assertIn(u'/path/to/testing/gcs/', fdoc['link'])
self.assertEqual('gcs', fdoc['backend'])
self.assertIn('/path/to/testing/gcs/', fdoc['link'])
for variation in fdoc['variations']:
self.assertIn(u'/path/to/testing/gcs/', variation['link'])
self.assertIn('/path/to/testing/gcs/', variation['link'])
@mock.activate
def test_only_variations(self):
@ -77,11 +75,11 @@ class ChangeBackendTest(AbstractPillarTest):
files_coll = self.app.data.driver.db['files']
fdoc = files_coll.find_one(image_file_id)
self.assertEqual(u'gcs', fdoc['backend'])
self.assertIn(u'/path/to/testing/gcs/', fdoc['link'])
self.assertEqual('gcs', fdoc['backend'])
self.assertIn('/path/to/testing/gcs/', fdoc['link'])
for variation in fdoc['variations']:
self.assertIn(u'/path/to/testing/gcs/', variation['link'])
self.assertIn('/path/to/testing/gcs/', variation['link'])
@mock.activate
def test_no_variations(self):
@ -102,8 +100,8 @@ class ChangeBackendTest(AbstractPillarTest):
files_coll = self.app.data.driver.db['files']
fdoc = files_coll.find_one(image_file_id)
self.assertEqual(u'gcs', fdoc['backend'])
self.assertIn(u'/path/to/testing/gcs/', fdoc['link'])
self.assertEqual('gcs', fdoc['backend'])
self.assertIn('/path/to/testing/gcs/', fdoc['link'])
def _create_image_file_doc(self, variations=True):
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):
# noinspection PyMethodOverriding
def ensure_file_exists(self, file_overrides):
file_id = file_overrides[u'_id']
file_id = file_overrides['_id']
file_overrides.update({
u'_id': ObjectId(file_id),
u'name': '%s.png' % file_id,
u'file_path': '%s.png' % file_id,
u'backend': 'unittest',
'_id': ObjectId(file_id),
'name': '%s.png' % file_id,
'file_path': '%s.png' % file_id,
'backend': 'unittest',
})
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),
self.now + timedelta(minutes=30), self.now + timedelta(minutes=90), ]
ids_and_files = [self.ensure_file_exists(file_overrides={
u'_id': 'cafef00ddeadbeef0000000%i' % file_idx,
u'link_expires': expiry})
'_id': 'cafef00ddeadbeef0000000%i' % file_idx,
'link_expires': expiry})
for file_idx, expiry in enumerate(expiry)]
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,
# This group is hardcoded in the EXAMPLE_PROJECT.
'groups': [ObjectId('5596e975ea893b269af85c0e')],
'roles': {u'subscriber', u'admin'}}
'roles': {'subscriber', 'admin'}}
nodes = self.app.data.driver.db['nodes']
# Create the node.
@ -81,7 +81,7 @@ class NodeContentTypeTest(AbstractPillarTest):
self.assertEqual(200, resp.status_code)
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):
from pillar.api.utils import dumps
@ -240,12 +240,12 @@ class NodeSharingTest(AbstractPillarTest):
self.project_id, _ = self.ensure_project_exists(
project_overrides={
u'category': 'home',
u'permissions':
{u'groups': [{u'group': ctd.EXAMPLE_ADMIN_GROUP_ID,
u'methods': [u'GET', u'POST', u'PUT', u'DELETE']}],
u'users': [],
u'world': []}}
'category': 'home',
'permissions':
{'groups': [{'group': ctd.EXAMPLE_ADMIN_GROUP_ID,
'methods': ['GET', 'POST', 'PUT', 'DELETE']}],
'users': [],
'world': []}}
)
self.user_id = self.create_user(groups=[ctd.EXAMPLE_ADMIN_GROUP_ID])
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 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()
self.assertEqual(1, patched_node['properties']['rating_positive'])
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])
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()
self.assertEqual(0, patched_node['properties']['rating_positive'])
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])
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(2, patched_node['properties']['rating_negative'])
self.assertEqual([
{u'user': unicode(other_user_ids[0]), u'is_positive': True},
{u'user': unicode(other_user_ids[1]), u'is_positive': True},
{u'user': unicode(other_user_ids[3]), u'is_positive': True},
{u'user': unicode(other_user_ids[4]), u'is_positive': False},
{u'user': unicode(self.user_id), u'is_positive': False},
{'user': str(other_user_ids[0]), 'is_positive': True},
{'user': str(other_user_ids[1]), 'is_positive': True},
{'user': str(other_user_ids[3]), 'is_positive': True},
{'user': str(other_user_ids[4]), 'is_positive': False},
{'user': str(self.user_id), 'is_positive': False},
], patched_node['properties'].get('ratings', []))
@ -172,19 +172,19 @@ class EditCommentTest(AbstractPatchCommentTest):
res = self.patch(self.node_url,
json={'op': 'edit', 'content': 'Je moeder is niet je vader.'},
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'])
# Get the node again, to inspect its changed state.
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'])
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'])
self.assertNotEqual(pre_node['_etag'], patched_node['_etag'])
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.test_comment_edit_happy(token='admin-token')
@ -197,9 +197,9 @@ class EditCommentTest(AbstractPatchCommentTest):
# Get the node again, to inspect its old state.
patched_node = self.get(self.node_url, auth_token='token').json()
self.assertEqual(u'Purrrr kittycat',
self.assertEqual('Purrrr kittycat',
patched_node['properties']['content'])
self.assertEqual(u'<p>Purrrr kittycat</p>\n',
self.assertEqual('<p>Purrrr kittycat</p>\n',
patched_node['properties']['content_html'])
def test_edit_noncomment_node(self):

82
tests/test_api/test_project_management.py
View File

@ -5,7 +5,7 @@
import functools
import json
import logging
import urllib
import urllib.request, urllib.parse, urllib.error
from bson import ObjectId
from pillar.tests import AbstractPillarTest
@ -26,7 +26,7 @@ class AbstractProjectTest(AbstractPillarTest):
return resp
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)
resp = self._create_project(project_name, token)
@ -38,8 +38,8 @@ class AbstractProjectTest(AbstractPillarTest):
class ProjectCreationTest(AbstractProjectTest):
def test_project_creation_wrong_role(self):
self._create_user_with_token([u'whatever'], 'token')
resp = self._create_project(u'Prøject El Niño', 'token')
self._create_user_with_token(['whatever'], 'token')
resp = self._create_project('Prøject El Niño', 'token')
self.assertEqual(403, resp.status_code)
@ -49,8 +49,8 @@ class ProjectCreationTest(AbstractProjectTest):
self.assertEqual(0, len(list(projects.find())))
def test_project_creation_good_role(self):
user_id = self._create_user_with_token([u'subscriber'], 'token')
resp = self._create_project(u'Prøject El Niño', 'token')
user_id = self._create_user_with_token(['subscriber'], 'token')
resp = self._create_project('Prøject El Niño', 'token')
self.assertEqual(201, resp.status_code)
# 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']
# 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('p-%s' % project_id, project['url'])
self.assertEqual(1, len(project['permissions']['groups']))
@ -95,13 +95,13 @@ class ProjectCreationTest(AbstractProjectTest):
def test_project_creation_access_admin(self):
"""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'])
def test_project_creation_access_subscriber(self):
"""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.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"""
proj_a = self._create_user_and_project(user_id=24 * 'a',
roles={u'subscriber'},
project_name=u'Prøject A',
roles={'subscriber'},
project_name='Prøject A',
token='token-a')
proj_b = self._create_user_and_project(user_id=24 * 'b',
roles={u'subscriber'},
project_name=u'Prøject B',
roles={'subscriber'},
project_name='Prøject B',
token='token-b')
# Assertion: each user must have access to their own project.
@ -137,16 +137,16 @@ class ProjectCreationTest(AbstractProjectTest):
headers={'Authorization': self.make_header('token-a')})
self.assertEqual(200, resp.status_code)
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',
headers={'Authorization': self.make_header('token-b')})
self.assertEqual(200, resp.status_code)
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.
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',
headers={'Authorization': self.make_header('token-c')})
self.assertEqual(200, resp.status_code)
@ -161,7 +161,7 @@ class ProjectEditTest(AbstractProjectTest):
from pillar.api.utils import remove_private_keys, 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
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.
put_project = remove_private_keys(project)
put_project['url'] = u'very-offensive-url'
put_project['description'] = u'Blender je besplatan set alata za izradu interaktivnog 3D ' \
u'sadržaja pod različitim operativnim sustavima.'
put_project['name'] = u'โครงการปั่นเมฆ'
put_project['summary'] = u'Это переведена на Google'
put_project['url'] = 'very-offensive-url'
put_project['description'] = 'Blender je besplatan set alata za izradu interaktivnog 3D ' \
'sadržaja pod različitim operativnim sustavima.'
put_project['name'] = 'โครงการปั่นเมฆ'
put_project['summary'] = 'Это переведена на Google'
put_project['status'] = 'pending'
put_project['category'] = 'software'
put_project['user'] = other_user_id
@ -222,7 +222,7 @@ class ProjectEditTest(AbstractProjectTest):
from pillar.api.utils import remove_private_keys, 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
resp = self.client.get(project_url)
@ -234,11 +234,11 @@ class ProjectEditTest(AbstractProjectTest):
# Admin user should be able to PUT everything.
put_project = remove_private_keys(project)
put_project['url'] = u'very-offensive-url'
put_project['description'] = u'Blender je besplatan set alata za izradu interaktivnog 3D ' \
u'sadržaja pod različitim operativnim sustavima.'
put_project['name'] = u'โครงการปั่นเมฆ'
put_project['summary'] = u'Это переведена на Google'
put_project['url'] = 'very-offensive-url'
put_project['description'] = 'Blender je besplatan set alata za izradu interaktivnog 3D ' \
'sadržaja pod različitim operativnim sustavima.'
put_project['name'] = 'โครงการปั่นเมฆ'
put_project['summary'] = 'Это переведена на Google'
put_project['is_private'] = False
put_project['status'] = 'pending'
put_project['category'] = 'software'
@ -272,7 +272,7 @@ class ProjectEditTest(AbstractProjectTest):
dumps = functools.partial(json.dumps, cls=PillarJSONEncoder)
# Create test project.
project = self._create_user_and_project([u'subscriber'])
project = self._create_user_and_project(['subscriber'])
project_id = project['_id']
project_url = '/api/projects/%s' % project_id
@ -281,7 +281,7 @@ class ProjectEditTest(AbstractProjectTest):
# Admin user should be able to PUT.
put_project = remove_private_keys(project)
put_project['name'] = u'โครงการปั่นเมฆ'
put_project['name'] = 'โครงการปั่นเมฆ'
resp = self.client.put(project_url,
data=dumps(put_project),
@ -297,7 +297,7 @@ class ProjectEditTest(AbstractProjectTest):
dumps = functools.partial(json.dumps, cls=PillarJSONEncoder)
# Create test project.
project = self._create_user_and_project([u'subscriber'])
project = self._create_user_and_project(['subscriber'])
project_id = 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.
put_project = remove_private_keys(project)
put_project['name'] = u'Болту́н -- нахо́дка для шпио́на.'
put_project['name'] = 'Болту́н -- нахо́дка для шпио́на.'
put_project['user'] = my_user_id
resp = self.client.put(project_url,
data=dumps(put_project),
@ -318,7 +318,7 @@ class ProjectEditTest(AbstractProjectTest):
def test_delete_by_admin(self):
# 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_url = '/api/projects/%s' % project_id
@ -338,7 +338,7 @@ class ProjectEditTest(AbstractProjectTest):
# ... but we should still get it in the body.
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'])
# Querying for deleted projects should include it.
@ -347,16 +347,16 @@ class ProjectEditTest(AbstractProjectTest):
projection = json.dumps({'name': 1, 'permissions': 1})
where = json.dumps({'_deleted': True}) # MUST be True, 1 does not work.
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)
projlist = json.loads(resp.data)
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):
# 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_url = '/api/projects/%s' % project_id
@ -383,14 +383,14 @@ class ProjectNodeAccess(AbstractProjectTest):
from pillar.api.utils import PillarJSONEncoder
# Project is created by regular subscriber, so should be private.
self.user_id = self._create_user_with_token([u'subscriber'], 'token')
resp = self._create_project(u'Prøject El Niño', 'token')
self.user_id = self._create_user_with_token(['subscriber'], 'token')
resp = self._create_project('Prøject El Niño', 'token')
self.assertEqual(201, resp.status_code)
self.assertEqual('application/json', resp.mimetype)
self.project = json.loads(resp.data)
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')
self.test_node = {
@ -435,7 +435,7 @@ class ProjectNodeAccess(AbstractProjectTest):
headers={'Authorization': self.make_header('token')})
self.assertEqual(200, resp.status_code, (resp.status_code, resp.data))
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.
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():
self.badger, token_doc = service.create_service_account(
'serviceaccount@example.com', [u'badger'],
{u'badger': [u'succubus', u'subscriber', u'demo']}
'serviceaccount@example.com', ['badger'],
{'badger': ['succubus', 'subscriber', 'demo']}
)
self.badger_token = token_doc['token']
@ -33,7 +33,7 @@ class BadgerServiceTest(AbstractPillarTest):
with self.app.test_request_context():
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
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():
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):
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():
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):
"""Certain roles are linked to certain groups."""

28
tests/test_api/test_utils.py
View File

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

8
tests/test_web/test_user_admin.py
View File

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

12
tests/test_web/test_utils.py
View File

@ -1,7 +1,5 @@
# -*- encoding: utf-8 -*-
from __future__ import absolute_import
import unittest
import datetime
@ -13,20 +11,20 @@ class IsValidIdTest(unittest.TestCase):
def test_valid(self):
# 24-byte hex strings
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(u'deadbeefbeefcacedeadcace'))
# 12-byte arbitrary ASCII strings
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
self.assertTrue(utils.is_valid_id('beef€67890'))
def test_bad_length(self):
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):
self.assertFalse(utils.is_valid_id(None))
@ -38,7 +36,7 @@ class IsValidIdTest(unittest.TestCase):
self.assertFalse(utils.is_valid_id('deadbeefbeefcakedeadcake'))
# 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):