djangoldp/tests/performance_runner.py

 import sys
+import yaml
 
 import django
-from djangoldp.tests import settings_default
-from django.conf import settings
+from django.conf import settings as django_settings
+from djangoldp.conf.ldpsettings import LDPSettings
+from djangoldp.tests.server_settings import yaml_config
 
-# configure settings not to use pagination
-settings.configure(default_settings=settings_default,
-                   REST_FRAMEWORK = {
-                       'DEFAULT_PAGINATION_CLASS': None
-                   })
+# load test config
+config = yaml.safe_load(yaml_config)
+ldpsettings = LDPSettings(config)
+django_settings.configure(ldpsettings,
+                          REST_FRAMEWORK = {
+                                'DEFAULT_PAGINATION_CLASS': None
+                          },
+                          ANONYMOUS_USER_NAME=None)
 
 django.setup()
 from django.test.runner import DiscoverRunner

djangoldp/tests/permissions.py

+from djangoldp.filters import BaseFilterBackend
+from djangoldp.permissions import LDPBasePermission
+
+class StartsWithAFilter(BaseFilterBackend):
+    """Only objects whose title starts in A get through"""
+    def filter_queryset(self, request, queryset, view):
+        return queryset.filter(title__startswith='A')
+
+class ReadOnlyStartsWithA(LDPBasePermission):
+    """Only gives read-only access and only to objects which title starts with A"""
+    filter_backend = StartsWithAFilter
+    permissions = {'view', 'list'}
+    def check_perms(self, obj):
+        return getattr(obj, 'title', '').startswith('A')
+    def has_object_permission(self, request, view, obj=None):
+        return self.check_perms(obj)
+    def get_permissions(self, user, model, obj=None):
+        return self.permissions if self.check_perms(obj) else set()
+
+
+class ContainsSpace(BaseFilterBackend):
+    """Only objects whose title contains a space get through"""
+    def filter_queryset(self, request, queryset, view):
+        if request.user.username != 'toto':
+            return queryset.none()
+        return queryset.filter(title__contains=' ')
+
+class Only2WordsForToto(LDPBasePermission):
+    """Only gives access if the user's username is toto and only to objects whose title has two words (contains space)"""
+    filter_backend = ContainsSpace
+    def has_permission(self, request, view):
+        return request.user.username == 'toto'
+    def check_perms(self, obj):
+        return ' ' in getattr(obj, 'title', '')
+    def has_object_permission(self, request, view, obj=None):
+        return self.check_perms(obj)
+    def get_permissions(self, user, model, obj=None):
+        return self.permissions if self.check_perms(obj) else set()
\ No newline at end of file

djangoldp/tests/runner.py

 import sys
+import yaml
 
 import django
-from djangoldp.tests import settings_default
-from django.conf import settings
+from django.conf import settings as django_settings
+from djangoldp.conf.ldpsettings import LDPSettings
+from djangoldp.tests.server_settings import yaml_config
 
-settings.configure(default_settings=settings_default)
+# load test config
+config = yaml.safe_load(yaml_config)
+ldpsettings = LDPSettings(config)
+django_settings.configure(ldpsettings)
 
 django.setup()
 from django.test.runner import DiscoverRunner
@@ -12,11 +17,15 @@ from django.test.runner import DiscoverRunner
 test_runner = DiscoverRunner(verbosity=1)
 
 failures = test_runner.run_tests([
+    'djangoldp.tests.tests_settings',
     'djangoldp.tests.tests_ldp_model',
-    'djangoldp.tests.tests_save',
+    'djangoldp.tests.tests_model_serializer',
+    'djangoldp.tests.tests_ldp_viewset',
     'djangoldp.tests.tests_user_permissions',
     'djangoldp.tests.tests_guardian',
     'djangoldp.tests.tests_anonymous_permissions',
+    'djangoldp.tests.tests_permissions',
+    'djangoldp.tests.tests_post',
     'djangoldp.tests.tests_update',
     'djangoldp.tests.tests_auto_author',
     'djangoldp.tests.tests_get',
@@ -26,7 +35,6 @@ failures = test_runner.run_tests([
     'djangoldp.tests.tests_inbox',
     'djangoldp.tests.tests_backlinks_service',
     'djangoldp.tests.tests_cache'
-
 ])
 if failures:
     sys.exit(failures)

djangoldp/tests/scripts/prod_data_generator.py

+import json
+import argparse
+from pathlib import Path
+from datetime import datetime
+from utils import generate_users, generate_projects, generate_skills
+
+'''
+A script which generates and outputs random production data, into a parameterised file (json), which can be used as
+a Django fixture or imported into a live database
+e.g. python manage.py loaddata fixture.json
+for help run python prod_data_generator.py -h
+'''
+
+# starting from offset ensures that existing users etc are not disturbed
+parser = argparse.ArgumentParser(description='generates and outputs random test data, into a file used by the performance unit tests')
+parser.add_argument(dest='count', metavar='N', type=int, help='the number of users (and projects) to generate')
+parser.add_argument('--offset', dest='offset', type=int, default=100, help='an offset to start primary keys at (should be larger than the largest pre-existing project/user primary key)')
+parser.add_argument('-f', dest='file_dest', type=str, default="../fixtures/live.json", help='the file destination to write to')
+parser.add_argument('-s', dest='generate_skills', type=bool, default=False, help='Do you want to generate skills too ?')
+
+args = parser.parse_args()
+count = args.count
+OFFSET = args.offset
+
+user_template = {
+    'model': 'djangoldp_account.ldpuser',
+    'pk': 0,
+    'fields': {
+        'username': 'john',
+        'email': 'jlennon@c.coop',
+        'password':'glassonion',
+        'first_name': 'John',
+        'last_name': 'Lennon'
+    }
+}
+
+project_template = {
+    'model': 'djangoldp_project.project',
+    'pk': 0,
+    'fields': {
+        'description': 'Test',
+        'status': 'Public',
+        'creationDate': str(datetime.date(datetime.now()))
+    }
+}
+
+skill_template = {
+    'model': 'djangoldp_skill.skill',
+    'pk': 0,
+    'fields': {
+        'name': 'PHP',
+    }
+}
+
+fixture = generate_users(count, user_template, offset=OFFSET)
+fixture = generate_projects(count, project_template, fixture=fixture, offset=OFFSET)
+
+if args.generate_skills:
+    fixture = generate_skills(count, skill_template, fixture=fixture, offset=OFFSET)
+
+with open(Path(__file__).parent / args.file_dest, 'w') as output:
+    json.dump(fixture, output)
+
+print(str(count))

djangoldp/tests/scripts/test_data_generator.py

-import uuid
 import json
-import sys
-import random
+import argparse
 from pathlib import Path
-from copy import deepcopy
+from utils import generate_users, generate_projects
 
 '''
 A script which generates and outputs random test data, into a file used by the performance unit tests
-usage: python test_data_generator.py [number_rows]
-e.g. python test_data_generator.py 2000
+for help run python test_data_generator.py -h
 '''
 
-count = int(sys.argv[1])
-fixture = list()
+parser = argparse.ArgumentParser(description='generates and outputs random test data, into a file used by the performance unit tests')
+parser.add_argument(dest='count', metavar='N', type=int, help='the number of users (and projects) to generate')
+parser.add_argument('-f', dest='file_dest', type=str, default="../fixtures/test.json", help='the file destination to write to')
+
+args = parser.parse_args()
+count = args.count
 
 user_template = {
     'model': 'tests.user',
@@ -20,7 +21,9 @@ user_template = {
     'fields': {
         'username': 'john',
         'email': 'jlennon@c.coop',
-        'password':'glass onion'
+        'password':'glassonion',
+        'first_name': 'John',
+        'last_name': 'Lennon'
     }
 }
 
@@ -28,38 +31,15 @@ project_template = {
     'model': 'tests.project',
     'pk': 0,
     'fields': {
+        'status': 'Public',
         'description': 'Test'
     }
 }
 
-def generate_user(i):
-    user = deepcopy(user_template)
-    user['pk'] = i
-    user['fields']['username'] = str(uuid.uuid4())
-    user['fields']['email'] = user['fields']['username'] + "@c.coop"
-    return user
-
-def generate_project(i):
-    project = deepcopy(project_template)
-    project['pk'] = i
-    project['fields']['team'] = list()
-
-    # append random number of users, max 10 for a single project
-    for j in range(random.randint(1, 10)):
-        project['fields']['team'].append(random.randint(1, count-1))
-    return project
-
-# create N users
-for i in range(count):
-    user = generate_user(i)
-    fixture.append(user)
-
-# create N projects
-for i in range(count):
-    project = generate_project(i)
-    fixture.append(project)
+fixture = generate_users(count, user_template)
+fixture = generate_projects(count, project_template, fixture=fixture, production=False)
 
-with open(Path(__file__).parent / "../fixtures/test.json", 'w') as output:
+with open(Path(__file__).parent / args.file_dest, 'w') as output:
     json.dump(fixture, output)
 
 print(str(count))

djangoldp/tests/scripts/utils.py

+from copy import deepcopy
+import random
+from faker import Faker
+
+'''
+Contains definitions used in common by multiple scripts within this directory
+'''
+def generate_user(i, user_template):
+    myFactory = Faker()
+    user = deepcopy(user_template)
+    email = myFactory.unique.email().split('@')
+    email.insert(1, str(random.randint(0, 5)))
+    email.insert(2, "@")
+    email_str = "".join(email)
+    user['pk'] = i
+    user['fields']['username'] = myFactory.unique.user_name() + str(random.randint(0, 100))
+    user['fields']['email'] = email_str
+    user['fields']['first_name'] = myFactory.first_name()
+    user['fields']['last_name'] = myFactory.last_name()
+    return user
+
+
+def generate_users(count, user_template, fixture=None, offset=0):
+    if fixture is None:
+        fixture = list()
+
+    for i in range(count):
+        j = offset + i
+        user = generate_user(j, user_template)
+        fixture.append(user)
+
+    return fixture
+
+
+def generate_project_member_and_user_pks(project_pk, offset, total_users, max_members_per_project):
+    '''
+    returns a generator of tuples (new project member PKs and selected user PKs)
+    raises error if there are not enough users
+    '''
+    # we want to select a handful of random users
+    # to save time we just select a random user within a safe range and then grab a bunch of adjacent users
+    start_user_pk = random.randint(max(offset, 1), offset + (total_users - (max_members_per_project + 1)))
+    if start_user_pk < offset:
+        raise IndexError('not enough users!')
+    
+    for i in range(random.randint(1, max_members_per_project)):
+        j = offset + (i + (project_pk * max_members_per_project))  # generate a unique integer id
+        user_pk = start_user_pk + i  # select the next user
+
+        yield (j, user_pk)
+
+
+def generate_project_members(project_pk, fixture, offset, total_users):
+    max_members_per_project = 10
+
+    def generate_project_member(i, user_pk):
+        return {
+            'model': 'djangoldp_project.member',
+            'pk': i,
+            'fields': {
+                'project': project_pk,
+                'user': user_pk
+            }
+        }
+
+    for (j, user_pk) in generate_project_member_and_user_pks(project_pk, offset, total_users, max_members_per_project):
+        fixture.append(generate_project_member(j, user_pk))
+
+    return fixture
+
+def generate_skill(i, skill_template):
+    myFactory = Faker()
+    skill = deepcopy(skill_template)
+
+    skill['pk'] = i
+    skill['fields']['name'] = myFactory.unique.job()
+    return skill
+
+
+def generate_user_pks(skill_pk, offset, total_users, max_users_per_skill):
+    '''
+    returns a generator of tuples ()
+    raises error if there are not enough users
+    '''
+    # we want to select a handful of random users
+    # to save time we just select a random user within a safe range and then grab a bunch of adjacent users
+    start_user_pk = random.randint(0, offset + (total_users - (max_users_per_skill + 1)))
+    # if start_user_pk < offset:
+    #     raise IndexError('not enough users!')
+    
+    for i in range(random.randint(1, max_users_per_skill)):
+        j = offset + (i + (skill_pk * max_users_per_skill))  # generate a unique integer id
+        user_pk = start_user_pk + i  # select the next user
+
+        yield (j, user_pk)
+
+def append_users_to_skill(skill, offset, total_users):
+    max_users_per_skill = 250
+
+    skill['fields']['users'] = []
+    for (j, user_pk) in generate_user_pks(skill['pk'], offset, total_users, max_users_per_skill):
+        skill['fields']['users'].append(user_pk)
+
+    return skill
+
+def generate_skills(count, skill_template, fixture=None, offset=0):
+    if fixture is None:
+        fixture = list()
+
+    for i in range(count):
+        j = offset + i
+        skill = generate_skill(j, skill_template)
+
+        skill = append_users_to_skill(skill, offset, count)
+        fixture.append(skill)
+
+    return fixture
+
+def generate_project(i, project_template):
+    project = deepcopy(project_template)
+    project['pk'] = i
+
+    return project
+
+
+def append_members_to_project(project, offset, total_users):
+    max_members_per_project = 10
+
+    project['members'] = []
+    for (j, user_pk) in generate_project_member_and_user_pks(project['pk'], offset, total_users, max_members_per_project):
+        project['members'].append(user_pk)
+
+    return project
+
+
+def generate_projects(count, project_template, fixture=None, offset=0, production=True):
+    if fixture is None:
+        fixture = list()
+
+    for i in range(count):
+        j = offset + i
+        project = generate_project(j, project_template)
+
+        # project members using direct ManyToMany field. Generate them as a field on project
+        if not production:
+            project = append_members_to_project(project, offset, count)
+
+        fixture.append(project)
+
+        # project members using Member through model, generate them as separate in the fixture
+        if production:
+            # append random number of project members, max 10 for a single project
+            generate_project_members(j, fixture, offset, count)
+
+    return fixture