def main(request, rest_of_address):
address = Address(rest_of_address)
#import pdb; pdb.set_trace()
if not address.folder:
return render_to_response('documents_folders/error.html', {'error':'no_folder', 'current_folder_path': address.folder_path})
if address.file_path and not address.file:
return render_to_response('documents_folders/error.html', {'error':'no_file', 'current_folder': address.folder_path, 'open_file':address.file_path})
if 'submit_comment' in request.POST:
add_comment(request, address)
#Create new folder
if 'file' in request.FILES:
upload_file(request, address.folder.id)
if 'new_folder_name' in request.POST:
folder_name = str(request.POST.get('new_folder_name'))
if folder_name.strip():
p = Folder(name = folder_name, parent_folder = address.folder.id, folder_path = address.folder_path+'/'+folder_name)
p.save()
#Remove folder and all sub-folders of that folder
for folder_id in [a for a, b in request.POST.iteritems() if b == 'Delete']:
remove_folder(folder_id)
sub_folders = Folder.objects.filter(parent_folder=address.folder.id)
sub_files = File.objects.filter(parent_folder = address.folder.id)
relevant_comments = Comment.objects.filter(attached_to_type = address.type, attached_to_id = address.id)
try:
parent_folder = Folder.objects.get(id = address.folder.parent_folder)
except:
parent_folder = None
return render_to_response('documents_folders/blah.html', {'relevant_comments':relevant_comments, 'sub_folders': sub_folders, 'current_folder_path': address.folder.folder_path, 'parent_folder': parent_folder, 'sub_files':sub_files, 'open_file':address.file_path, 'current_path': '/documents/'+rest_of_address}, context_instance=RequestContext(request))
def test_model_folder(self):
"""Test Folder Model"""
obj = Folder(name='test')
obj.save()
self.assertEquals('test', obj.name)
self.assertNotEquals(obj.id, None)
obj.delete()
def test_get(self):
"""A logged in user ask to move a valid favorite."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(dummy, godzilla)
folders = []
for i in range(10):
folder = Folder(name="folder-%s" % i, user=godzilla)
folder.save()
folders.append(folder)
target_url = reverse('favorites:favorite_move',
kwargs={
'object_id': favorite.pk,
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 200)
instance = response.context['favorite']
self.assertEquals(instance.pk, favorite.pk)
favorite.delete()
godzilla.delete()
for folder in folders:
folder.delete()
dummy.delete()
def folders(request):
folders = Folder.objects.filter(user=request.user)
context = {'folders':folders}
if request.method == 'POST':
# changing to a different folder
if "change_folder" in request.POST:
request.session['notes_folder'] = request.POST['folder']
# If we are changing folders we don't
# want to keep to what page we were on in
# the other folder.
if 'page' in request.session:
del request.session['page']
return redirect('cloud_notes.views.list')
if "create_folder" in request.POST:
form = NewFolderForm(request.POST)
if form.is_valid():
folder_name = form.cleaned_data['folder']
folder = Folder(name = folder_name)
folder.save()
return redirect('cloud_notes.views.list')
else:
context['form'] = form
return render(request, 'cloud_notes/folders.html', context)
else:
return render(request, 'cloud_notes/folders.html', context)
def test_get(self):
"""A logged in user ask to move a valid favorite."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(dummy, godzilla)
folders = []
for i in range(10):
folder = Folder(name="folder-%s" % i, user=godzilla)
folder.save()
folders.append(folder)
target_url = reverse('favorites:favorite_move',
kwargs = {
'object_id': favorite.pk,
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 200)
instance = response.context['favorite']
self.assertEquals(instance.pk, favorite.pk)
favorite.delete()
godzilla.delete()
for folder in folders:
folder.delete()
dummy.delete()
def handle_uploaded_json_file(f, user):
def convert_date(str_date):
new_str = str_date.replace('+00:00','')
try:
new_dt = datetime.strptime(new_str, '%Y-%m-%d %H:%M:%S.%f')
except ValueError:
new_dt = datetime.strptime(new_str, '%Y-%m-%d %H:%M:%S')
return new_dt
with open('notes.json', 'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
f.close()
with open('notes.json', 'r') as fh:
json_data = json.load(fh)
fh.close()
version, notes = json_data
# for user in User.objects.all():
# if not Folder.)objects.filter(user = user, name = "Main").exists():
# folder = Folder(name="Main", user = user)
# folder.save()
# if not Folder.objects.filter(user = user, name = ")Trash").exists():
# folder = Folder(name="Trash", user = u)ser)
# folder.save()
for note in notes:
created_at = convert_date(note['created_at'])
title = note['title']
username = note['user']
# TODO: If user is blank we need to assign to a default user. For now just skip.
# Its technically a database integrity violation anyway.
if username is None: continue
user = User.objects.get(username = username)
if not Note.objects.filter(title = title,
created_at = created_at).exists():
new_note = Note()
new_note.title = title
new_note.created_at = created_at
new_note.modified_at = convert_date(note['modified_at'])
new_note.note_type = note['post_type']
new_note.note = note['note']
foldr = note['folder']
try:
folder = Folder.objects.get(name = foldr, user = user)
except Folder.DoesNotExist:
folder = Folder(name = foldr, user = user)
folder.save()
new_note.folder = folder
new_note.user = user
new_note.save()
def test_login_required(self):
"""User should be logged it to delete an object."""
godzilla = self.user('godzilla')
folder = Folder(name='japan', user=godzilla)
folder.save()
response = self.client.get(reverse('favorites:folder_update', args=(folder.pk,)))
self.assertEquals(response.status_code, 302)
folder.delete()
godzilla.delete()
def test_model_file(self):
"""Test File Model"""
folder = Folder(name='test')
folder.save()
obj = File(name='test', folder=folder)
obj.save()
self.assertEquals(folder, obj.folder)
self.assertNotEquals(obj.id, None)
obj.delete()
def test_model_document(self):
"""Test Document Model"""
folder = Folder(name='test')
folder.save()
obj = Document(title='test', folder=folder)
obj.save()
self.assertEquals(folder, obj.folder)
self.assertNotEquals(obj.id, None)
obj.delete()
def test_model_weblink(self):
"""Test WebLink Model"""
folder = Folder(name='test')
folder.save()
obj = WebLink(title='test', folder=folder, url='test')
obj.save()
self.assertEquals(folder, obj.folder)
self.assertNotEquals(obj.id, None)
obj.delete()
def RPC__Folder__getRoot(self):
"""Return the main folder for the current user ("My folders"). """
try:
folder = Folder.objects.get(user=self.user, parent=None)
except Folder.DoesNotExist:
folder = Folder(user=self.user, name="My folders")
folder.save()
self.return_api_result({'uuid': folder.uuid, 'name': folder.name})
def test_get(self):
"""User want to update an existing folder."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=godzilla)
folder.save()
response = self.client.get(reverse('favorites:folder_update', args=(folder.pk,)))
self.assertEquals(response.status_code, 200)
godzilla.delete()
folder.delete()
def test_post(self):
"""Submit a delete form with good credentials. Returns a redirect."""
godzilla = self.user('godzilla')
folder = Folder(name='japan', user=godzilla)
folder.save()
self.client.login(username='******', password='******')
response = self.client.post(reverse('favorites:folder_delete', args=(folder.pk,)), {'object_id': folder.pk})
self.assertEquals(response.status_code, 302)
self.assertEquals(Folder.objects.filter(user=godzilla).count(), 0)
godzilla.delete()
def test_get(self):
"""Test that the page is reachable with an existing folder."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=godzilla)
folder.save()
response = self.client.get(reverse('favorites:folder_delete', args=(folder.pk,)))
self.assertEquals(response.status_code, 200)
folder.delete()
godzilla.delete()
def test_login_required(self):
"""User should be logged it to delete an object."""
godzilla = self.user('godzilla')
folder = Folder(name='japan', user=godzilla)
folder.save()
response = self.client.get(
reverse('favorites:folder_update', args=(folder.pk, )))
self.assertEquals(response.status_code, 302)
folder.delete()
godzilla.delete()
def create_folder(user, folder_name):
"""
Args:
user: django.contrib.auth.models.User
returns:
models.Folder
"""
f = Folder(name=folder_name, user=user, times_used=0)
f.save()
return f
def test_get(self):
"""User want to update an existing folder."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=godzilla)
folder.save()
response = self.client.get(
reverse('favorites:folder_update', args=(folder.pk, )))
self.assertEquals(response.status_code, 200)
godzilla.delete()
folder.delete()
def test_get(self):
"""Test that the page is reachable with an existing folder."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=godzilla)
folder.save()
response = self.client.get(
reverse('favorites:folder_delete', args=(folder.pk, )))
self.assertEquals(response.status_code, 200)
folder.delete()
godzilla.delete()
def create_folder(request, internal=False):
folder_form = FolderForm(request.POST or None)
if folder_form is not None and folder_form.is_valid():
title = folder_form.cleaned_data['title']
owner = Searcher.objects.filter(user_profile=request.user)[0]
new_folder = Folder(title=title, owner=owner)
new_folder.save()
else:
print "error"
if internal:
return new_folder
def test_invalid_permission(self):
"""Try to delete a folder owned by someone else. Returns a 403."""
godzilla = self.user('godzilla')
folder = Folder(name='japan', user=godzilla)
folder.save()
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
response = self.client.post(reverse('favorites:folder_delete', args=(folder.pk,)), {'object_id': folder.pk})
self.assertEquals(response.status_code, 403)
godzilla.delete()
leviathan.delete()
def test_invalid_permission_on_favorite(self):
"""User should own the folder to delete it. Returns a 403."""
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=leviathan)
folder.save()
response = self.client.get(reverse('favorites:folder_update', args=(folder.pk,)))
self.assertEquals(response.status_code, 403)
godzilla.delete()
leviathan.delete()
folder.delete()
def test_post(self):
"""Submit a delete form with good credentials. Returns a redirect."""
godzilla = self.user('godzilla')
folder = Folder(name='japan', user=godzilla)
folder.save()
self.client.login(username='******', password='******')
response = self.client.post(
reverse('favorites:folder_delete', args=(folder.pk, )),
{'object_id': folder.pk})
self.assertEquals(response.status_code, 302)
self.assertEquals(Folder.objects.filter(user=godzilla).count(), 0)
godzilla.delete()
def test_get(self):
"""User request a valid content type / folder combination. Returns 200."""
godzilla = self.user('godzilla')
japan = Folder(name='japan', user=godzilla)
japan.save()
china = Folder(name='china', user=godzilla)
china.save()
def create_favorites(model, folder):
m = model()
m.save()
favorite = Favorite.objects.create_favorite(m, godzilla, folder)
return m, favorite
japan_folder_pks = []
instances = []
for _ in range(5):
instance, favorite = create_favorites(DummyModel, japan)
japan_folder_pks.append(favorite.pk)
instances.append((instance, favorite))
for _ in range(5):
instance, favorite = create_favorites(DummyModel, china)
instances.append((instance, favorite))
for _ in range(5):
instance, favorite = create_favorites(BarModel, japan)
instances.append((instance, favorite))
for _ in range(5):
instance, favorite = create_favorites(BarModel, china)
instances.append((instance, favorite))
self.client.login(username='******', password='******')
target_url = reverse('favorites:favorite_content_type_and_folder_list',
kwargs = {
'app_label': DummyModel._meta.app_label,
'object_name': DummyModel._meta.module_name,
'folder_id': japan.pk
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 200)
self.assertIsNotNone(response.context['favorites'])
for instance in response.context['favorites']:
self.assertIn(instance.pk, japan_folder_pks)
godzilla.delete()
for instance in instances:
instance[0].delete()
instance[1].delete()
japan.delete()
china.delete()
def test_get(self):
"""User request a valid content type / folder combination. Returns 200."""
godzilla = self.user('godzilla')
japan = Folder(name='japan', user=godzilla)
japan.save()
china = Folder(name='china', user=godzilla)
china.save()
def create_favorites(model, folder):
m = model()
m.save()
favorite = Favorite.objects.create_favorite(m, godzilla, folder)
return m, favorite
japan_folder_pks = []
instances = []
for _ in range(5):
instance, favorite = create_favorites(DummyModel, japan)
japan_folder_pks.append(favorite.pk)
instances.append((instance, favorite))
for _ in range(5):
instance, favorite = create_favorites(DummyModel, china)
instances.append((instance, favorite))
for _ in range(5):
instance, favorite = create_favorites(BarModel, japan)
instances.append((instance, favorite))
for _ in range(5):
instance, favorite = create_favorites(BarModel, china)
instances.append((instance, favorite))
self.client.login(username='******', password='******')
target_url = reverse('favorites:favorite_content_type_and_folder_list',
kwargs={
'app_label': DummyModel._meta.app_label,
'object_name': DummyModel._meta.module_name,
'folder_id': japan.pk
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 200)
self.assertIsNotNone(response.context['favorites'])
for instance in response.context['favorites']:
self.assertIn(instance.pk, japan_folder_pks)
godzilla.delete()
for instance in instances:
instance[0].delete()
instance[1].delete()
japan.delete()
china.delete()
def test_post(self):
"""User submit a valid POST request, updating the folder. Returns a redirect."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=godzilla)
folder.save()
response = self.client.post(reverse('favorites:folder_update', args=(folder.pk,)),
{'name': 'Nippon-koku'})
self.assertEquals(response.status_code, 302)
folder = Folder.objects.get(pk=folder.pk)
self.assertEquals(folder.name, 'Nippon-koku')
godzilla.delete()
folder.delete()
def test_invalid_permission_on_favorite(self):
"""User should own the folder to delete it. Returns a 403."""
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=leviathan)
folder.save()
response = self.client.get(
reverse('favorites:folder_update', args=(folder.pk, )))
self.assertEquals(response.status_code, 403)
godzilla.delete()
leviathan.delete()
folder.delete()
def test_invalid_permission(self):
"""Try to delete a folder owned by someone else. Returns a 403."""
godzilla = self.user('godzilla')
folder = Folder(name='japan', user=godzilla)
folder.save()
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
response = self.client.post(
reverse('favorites:folder_delete', args=(folder.pk, )),
{'object_id': folder.pk})
self.assertEquals(response.status_code, 403)
godzilla.delete()
leviathan.delete()
def RPC__Folder__create(self, name, uuid=None):
"""Create a new folder and add it to a parent with the given ``uuid``. """
try:
if uuid is not None:
parent = Folder.objects.get(user=self.user, uuid=uuid)
else:
parent = None
except Folder.DoesNotExist:
self.return_api_error('does-not-exist')
else:
folder = Folder(user=self.user, parent=parent, name=name)
folder.save()
self.return_api_result({'uuid': folder.uuid})
def test_post(self):
"""User submit a valid POST request, updating the folder. Returns a redirect."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=godzilla)
folder.save()
response = self.client.post(
reverse('favorites:folder_update', args=(folder.pk, )),
{'name': 'Nippon-koku'})
self.assertEquals(response.status_code, 302)
folder = Folder.objects.get(pk=folder.pk)
self.assertEquals(folder.name, 'Nippon-koku')
godzilla.delete()
folder.delete()
def test_get_owned_favorites_only(self):
"""User should only see her/his favorites."""
# setup
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
def create_object_n_favorite(user, folder=None):
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(dummy, user, folder)
return dummy, favorite
godzilla_instances = []
godzilla_favorite_pks = []
for i in range(5):
instance, favorite = create_object_n_favorite(godzilla)
godzilla_instances.append((instance, favorite))
godzilla_favorite_pks.append(favorite.pk)
japan = Folder(name='japan', user=godzilla)
japan.save()
for i in range(5):
instance, favorite = create_object_n_favorite(godzilla, japan)
godzilla_instances.append((instance, favorite))
godzilla_favorite_pks.append(favorite.pk)
leviathan_instances = []
for i in range(5):
leviathan_instances.append(create_object_n_favorite(leviathan))
# tests
target_url = reverse('favorites:favorite_content_type_list',
kwargs={
'app_label': DummyModel._meta.app_label,
'object_name': DummyModel._meta.module_name
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 200)
self.assertIsNotNone(response.context['favorites'])
for instance in response.context['favorites']:
self.assertIn(instance.pk, godzilla_favorite_pks)
# teardown
for instances in (leviathan_instances, godzilla_instances):
for instance, favorite in instances:
instance.delete()
favorite.delete()
godzilla.delete()
leviathan.delete()
def test_get_owned_favorites_only(self):
"""User should only see her/his favorites."""
# setup
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
def create_object_n_favorite(user, folder=None):
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(dummy, user, folder)
return dummy, favorite
godzilla_instances = []
godzilla_favorite_pks = []
for i in range(5):
instance, favorite = create_object_n_favorite(godzilla)
godzilla_instances.append((instance, favorite))
godzilla_favorite_pks.append(favorite.pk)
japan = Folder(name='japan', user=godzilla)
japan.save()
for i in range(5):
instance, favorite = create_object_n_favorite(godzilla, japan)
godzilla_instances.append((instance, favorite))
godzilla_favorite_pks.append(favorite.pk)
leviathan_instances = []
for i in range(5):
leviathan_instances.append(create_object_n_favorite(leviathan))
# tests
target_url = reverse('favorites:favorite_content_type_list',
kwargs = {
'app_label': DummyModel._meta.app_label,
'object_name': DummyModel._meta.module_name
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 200)
self.assertIsNotNone(response.context['favorites'])
for instance in response.context['favorites']:
self.assertIn(instance.pk, godzilla_favorite_pks)
# teardown
for instances in (leviathan_instances, godzilla_instances):
for instance, favorite in instances:
instance.delete()
favorite.delete()
godzilla.delete()
leviathan.delete()
def create_root_folder(user_id): root = MEDIA_ROOT user = User.objects.get(id=user_id) directory = root +"/"+ user.username print directory if not os.path.exists(directory): try: folder = Folder() folder.name = user.username folder.path = directory folder.user = user folder.save() os.makedirs(directory) except Exception, e: return False else: return True
def create_subfolder(request, parent_id):
parent = Folder.objects.get(pk=parent_id)
name = request.POST['name']
logger.info("Creating subfolder {} of {}".format(name, parent.name))
collection, collection_is_new = Collection.objects.get_or_create(
name="Dummy collection", disk_path="")
new_folder = Folder(name=name,
collection=collection,
disk_path="",
parent=parent)
new_folder.save()
response = {'id': new_folder.id}
return JsonResponse(response)
def compile_java(file_id):
#first traslate
traslate_java(file_id)
file = File.objects.get(id=file_id)
folder = file.folder
user = folder.user
galatea_code = GALATEA + "galatea.jar "
code = "javac -cp "+ galatea_code + folder.path + "/*.java"
#print code
value = subprocess.check_output([code], shell=True)
#print value
#get all the file in this folder
for root, dirs, files in os.walk(folder.path):
root_folder = Folder.objects.get(path=root, name = os.path.basename(root))
for dir in dirs:
folders = Folder.objects.filter(father=root_folder.id)
esta = False
for folder in folders:
if folder.name == dir:
esta = True
if not esta:
folder = Folder()
folder.name = dir
folder.path = root_folder.path + "/" + dir
folder.user = user
folder.father = root_folder.id
folder.active = True
folder.save()
#print dirs
for file in files:
files_folder = File.objects.filter(folder = root_folder.id)
esta = False
for f in files_folder:
if f.name == file:
esta = True
if not esta:
if (os.path.splitext(file)[1] != ".class"):
f = File()
f.name = file
f.folder = root_folder
f.active = True
f.save()
return value
def test_get(self):
"""User make a valid request, returns a 200"""
user = User.objects.create(username='******')
user.set_password('user')
user.save()
folder = Folder(user=user, name='name')
folder.save()
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(user=user,
content_object=dummy)
target_url = reverse('favorites:favorite_move_to_folder',
args=(favorite.pk, folder.pk))
client = Client()
self.assertTrue(client.login(username='******', password='******'))
response = client.get(target_url)
self.assertEqual(response.status_code, 200)
def test_invalid_permission_on_folder(self):
"""User try to list favorites for a folder he or she doesn't own. Returns a 403."""
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
folder = Folder(name='china', user=leviathan)
folder.save()
self.client.login(username='******', password='******')
target_url = reverse('favorites:favorite_content_type_and_folder_list',
kwargs = {
'app_label': DummyModel._meta.app_label,
'object_name': DummyModel._meta.module_name,
'folder_id': folder.pk
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 403)
godzilla.delete()
leviathan.delete()
folder.delete()
def test_invalid_permission_on_folder(self):
"""User try to list favorites for a folder he or she doesn't own. Returns a 403."""
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
folder = Folder(name='china', user=leviathan)
folder.save()
self.client.login(username='******', password='******')
target_url = reverse('favorites:favorite_content_type_and_folder_list',
kwargs={
'app_label': DummyModel._meta.app_label,
'object_name': DummyModel._meta.module_name,
'folder_id': folder.pk
})
response = self.client.get(target_url)
self.assertEquals(response.status_code, 403)
godzilla.delete()
leviathan.delete()
folder.delete()
def test_get(self):
"""User make a valid request, returns a 200"""
user = User.objects.create(username='******')
user.set_password('user')
user.save()
folder = Folder(user=user, name='name')
folder.save()
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(user=user,
content_object=dummy)
target_url = reverse('favorites:favorite_move_to_folder',
args=(favorite.pk,
folder.pk))
client = Client()
self.assertTrue(client.login(username='******', password='******'))
response = client.get(target_url)
self.assertEqual(response.status_code, 200)
def create_searcher(request):
searcher_form = SearcherForm(request.POST or None)
if searcher_form is not None and searcher_form.is_valid():
name = searcher_form.cleaned_data['name']
user = User.custom_objects.get_or_none(username=name)
if not user:
user = User(username=name)
user.save()
searcher = Searcher(user_profile=user)
root_folder = Folder(title="Bookmarks", owner=searcher)
root_folder.save()
complexity_score = BoozeComplexityScore.objects.create(level=random.randint(0, 4))
searcher.complexity_score = complexity_score
print searcher
searcher.save()
else:
return create_account(request)
return redirect(index)
def test_post(self):
"""User submit a valid form, the favorite is added to his or her favorites."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=godzilla)
folder.save()
dummy = DummyModel()
dummy.save()
target_url = reverse('favorites:favorite_add', kwargs={ # The target model
'app_label': DummyModel._meta.app_label, # doesn't have to be valid
'object_name': DummyModel._meta.module_name,
'object_id': dummy.pk
})
response = self.client.post(target_url,
{'folder_id': folder.pk})
self.assertEquals(response.status_code, 302)
godzilla.delete()
folder.delete()
dummy.delete()
def test_invalid_permission_on_folder(self):
"""User try to move a favorite to a folder he doesn't own. Returns a 403."""
user = User.objects.create(username='******')
user.set_password('user')
user.save()
user2 = User.objects.create(username='******')
user2.set_password('user2')
user2.save()
folder = Folder(user=user2, name='name')
folder.save()
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(user=user,
content_object=dummy)
target_url = reverse('favorites:favorite_move_to_folder',
kwargs={'favorite_id': favorite.pk, 'folder_id': folder.pk})
client = Client()
self.assertTrue(client.login(username='******', password='******'))
response = client.get(target_url)
self.assertEqual(response.status_code, 403)
def test_invalid_permission_on_favorite(self):
"""User try to move a favorite he or she doesn't own. Returns a 403."""
user = User.objects.create(username='******')
user.set_password('user')
user.save()
user2 = User.objects.create(username='******')
user2.set_password('user2')
user2.save()
folder = Folder(user=user, name='name')
folder.save()
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(user=user2,
content_object=dummy)
target_url = reverse('favorites:favorite_move_to_folder',
args=(favorite.pk, folder.pk))
client = Client()
self.assertTrue(client.login(username='******', password='******'))
response = client.get(target_url)
self.assertEqual(response.status_code, 403)
def test_post(self):
"""User submit a valid form, the favorite is added to his or her favorites."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=godzilla)
folder.save()
dummy = DummyModel()
dummy.save()
target_url = reverse(
'favorites:favorite_add',
kwargs={ # The target model
'app_label':
DummyModel._meta.app_label, # doesn't have to be valid
'object_name': DummyModel._meta.module_name,
'object_id': dummy.pk
})
response = self.client.post(target_url, {'folder_id': folder.pk})
self.assertEquals(response.status_code, 302)
godzilla.delete()
folder.delete()
dummy.delete()
def test_post_invalid_permission_on_folder(self):
"""User try to move a favorite to of folder he or she doesn't own. Returns the form."""
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(dummy, godzilla)
folder = Folder(name="china", user=leviathan)
folder.save()
target_url = reverse('favorites:favorite_move',
kwargs = {
'object_id': favorite.pk,
})
post_values = {'object_id': favorite.pk, 'folder_id': folder.pk}
response = self.client.post(target_url, post_values)
self.assertEquals(response.status_code, 200)
folder.delete()
favorite.delete()
godzilla.delete()
leviathan.delete()
dummy.delete()
def test_post(self):
"""User submits a valid form, favorites moved, and user redirected."""
godzilla = self.user('godzilla')
self.client.login(username='******', password='******')
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(dummy, godzilla)
folder = Folder(name="japan", user=godzilla)
folder.save()
target_url = reverse('favorites:favorite_move',
kwargs={
'object_id': favorite.pk,
})
post_values = {'object_id': favorite.pk, 'folder_id': folder.pk}
response = self.client.post(target_url, post_values)
self.assertEquals(response.status_code, 302)
instance = Favorite.objects.get(pk=favorite.pk)
self.assertEqual(folder.pk, instance.folder.pk)
folder.delete()
favorite.delete()
godzilla.delete()
dummy.delete()
def test_post_invalid_permission_on_folder(self):
"""User try to move a favorite to of folder he or she doesn't own. Returns the form."""
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
dummy = DummyModel()
dummy.save()
favorite = Favorite.objects.create_favorite(dummy, godzilla)
folder = Folder(name="china", user=leviathan)
folder.save()
target_url = reverse('favorites:favorite_move',
kwargs={
'object_id': favorite.pk,
})
post_values = {'object_id': favorite.pk, 'folder_id': folder.pk}
response = self.client.post(target_url, post_values)
self.assertEquals(response.status_code, 200)
folder.delete()
favorite.delete()
godzilla.delete()
leviathan.delete()
dummy.delete()
def create_new_folder(user_id,father_id,name): root = MEDIA_ROOT user = User.objects.get(id=user_id) father = Folder.objects.get(id=father_id) directory = father.path +"/"+ name id_folder = 0 print directory if not os.path.exists(directory): try: folder = Folder() folder.name = name folder.path = directory folder.user = user folder.father = father.id folder.active = True folder.save() id_folder = folder.id os.makedirs(directory) except Exception, e: return id_folder else: return id_folder
def test_invalid_permission_on_folder(self):
"""User submits a form with a folder that is not his or her, renders the form."""
godzilla = self.user('godzilla')
leviathan = self.user('leviathan')
self.client.login(username='******', password='******')
folder = Folder(name='japan', user=leviathan)
folder.save()
dummy = DummyModel()
dummy.save()
target_url = reverse('favorites:favorite_add',
kwargs={
'app_label': DummyModel._meta.app_label,
'object_name': DummyModel._meta.module_name,
'object_id': dummy.pk
})
response = self.client.post(target_url, {'folder_id': folder.pk})
# form validation makes it impossible for a rogue user
# to a favorite that i do not own
self.assertEqual(response.status_code, 200)
godzilla.delete()
folder.delete()
dummy.delete()
leviathan.delete()
def new_folder(request):
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('existing_user'), {
'logged_in': False,
'form': forms.LoginForm(),
})
if request.method == 'POST':
form = forms.FolderForm(request.POST)
filterargs = {'author': request.user, 'name': request.POST['name']}
if Folder.objects.filter(**filterargs):
return render(request, 'secure_witness/new_folder.html', {
'folder_taken': True,
'user': request.user,
'form': form,
'logged_in': request.user.is_authenticated(),
})
if form.is_valid():
folder = Folder(
author = request.user,
name = request.POST['name'],
date_created = datetime.now(),
date_modified = datetime.now(),
location = request.POST['location'],
description = request.POST['description']
)
folder.save()
return HttpResponseRedirect(reverse('home'), {
'logged_in': request.user.is_authenticated(),
'form': forms.LoginForm(),
})
else:
form = forms.FolderForm()
return render(request, 'secure_witness/new_folder.html', {
'form': form,
'logged_in': request.user.is_authenticated(),
})
def jsonFolderCrud(request):
dictData = []
# GET * SELECT
if request.is_ajax() and request.method == 'GET':
action = request.GET.get('action', None)
if (action == "filter"):
LessonID = request.GET.get('LessonID', None)
#dictData = Folder.objects.get(LessonID=LessonID).graders.all().values() #OK
dictData = Folder.objects.filter(LessonID=LessonID).values()
jsonData = json.dumps(list(dictData))
#print jsonData
return HttpResponse(jsonData, content_type='application/json')
# POST INS.UPD.DEL
if request.is_ajax() and request.method == 'POST':
action = request.POST.get('action', None)
#INSERT COMMAND (need related LessonID ) | only add C type folders
if (action == "add"): # on LessonID
LessonID = request.POST.get('LessonID', None)
no = request.POST.get('no', None)
books = request.POST.get('books', None) #.title()
codeType = request.POST.get('codeType', None)
#status = request.POST.get('status', None)
print 'Data:', no, books, codeType
# Apaitoume oi fakeloi na exoun synexomeh arithmisi
# akoma kai gia diafortikous typous
# px fA/fANA. Ayto to allazoume efkola an theloume
# TO kanoume giati volevei sta reports
# alliws tha kanoume aali coding ...
#no = Lesson.objects.get(id=LessonID).getNextFolderNo(codeType)
try: #with transaction.atomic():
lesson = Lesson.objects.get(id=LessonID)
no = lesson.getNextFolderNo(
-1) # count F(AB) / even for F(ANA)
print 'Data(new):', no, books, codeType
record = Folder(LessonID_id=LessonID,
no=no,
books=books,
codeType=codeType)
record.save()
record.codeBarcode = '%04d-%010d' % (int(LessonID),
int(record.id))
record.save()
# Need to Update Lesson Data HERE aka mum Books, Folders etc.
if codeType == '0': # F(A)
print "F(A)"
#lesson.update(booksAB=booksAB+books, booksABFolders=booksABFolders+1)
lesson.booksAB = lesson.booksAB + int(books)
lesson.booksABFolders = lesson.booksABFolders + 1
lesson.save()
elif codeType == '1': # F(B)
#lesson.booksAB += books
#lesson.booksABFolders += 1
pass
elif codeType == '2': # F(ANA)
lesson.booksC = lesson.booksC + int(books)
lesson.booksCFolders = lesson.booksCFolders + 1
lesson.save()
msg = "Επιτυχής εισαγωγή εγγραφής!"
helperMessageLog(request, msg, tag='info')
#messages.info(request, msg, fail_silently=True)
except DatabaseError:
transaction.rollback()
msg = "Αδυναμία εισαγωγής εγγραφής!"
helperMessageLog(request, msg, tag='error')
#messages.error(request, msg, fail_silently=True)
#dictData = Lesson.objects.filter(id=record.id).values()
#print dictData
#jsonData = json.dumps(list(dictData))
jsonData = json.dumps({'msg': msg})
return HttpResponse(jsonData, content_type='application/json')
# UPDATE
if (action == "update"):
id = request.POST.get('id', None)
no = request.POST.get('no', None)
books = request.POST.get('books', None)
codeType = request.POST.get('codeType', None)
#lexType = request.POST.get('lexType', None)
#CodeStatus = request.POST.get('CodeStatus ', None)
#CodeLocation = request.POST.get('CodeLocation', None)
#print "FOLDER-UPDATE %s - %s - codeType:%s lexType:%s" %(no, books, codeType, lexType)
try: #with transaction.atomic():
record = Folder.objects.filter(id=id)
record.update(
no=no,
books=books,
codeType=codeType,
)
msg = "Επιτυχής τροποποίηση εγγραφής!"
helperMessageLog(request, msg, tag='info')
#messages.info(request, msg, fail_silently=True)
except DatabaseError:
transaction.rollback()
msg = "Αδυναμία τροποποίησης εγγραφής!"
helperMessageLog(request, msg, tag='error')
#messages.error(request, msg, fail_silently=True)
#Folder.objects.filter(id=id).update(isCoordinator = helperStr2Bool(isCoordinator), isgraderC = helperStr2Bool(isgraderC), status = status, )
# return Lesson record
#dictData = record.values()
#jsonData = json.dumps(list(dictData))
jsonData = json.dumps({'msg': msg})
#print jsonData
return HttpResponse(jsonData, content_type='application/json')
#DELETE COMMAND
if (action == "delete"):
id = request.POST.get('id', None)
try:
record = Folder.objects.get(id=id)
# update related lesson
lesson = Lesson.objects.get(id=record.LessonID.id)
print "codeType:%s" % (record.codeType)
print "lesson:%d" % (lesson.id)
if record.codeType == 0: # F(A)
print "delete codeType:%s" % (record.codeType)
#lesson.update(booksAB=booksAB+books, booksABFolders=booksABFolders+1)
lesson.booksAB = lesson.booksAB - int(record.books)
lesson.booksABFolders = lesson.booksABFolders - 1
lesson.save()
elif record.codeType == 1: # F(B)
pass
elif record.codeType == 2: # F(ANA)
print "delete codeType:%s" % (record.codeType)
lesson.booksC = lesson.booksC - int(record.books)
lesson.booksCFolders = lesson.booksCFolders - 1
lesson.save()
record.delete()
msg = "Επιτυχής διαγραφής Φακέλου (%s) !" % (record)
helperMessageLog(request, msg, tag='info')
#messages.info(request, msg, fail_silently=True)
except IntegrityError:
transaction.rollback()
msg = "Αδυναμία διαγραφής Φακέλου (%s) !" % (record)
helperMessageLog(request, msg, tag='error')
#messages.error(request, msg, fail_silently=True)
jsonData = json.dumps({'msg': msg})
return HttpResponse(jsonData, content_type='application/json')
#"Default SELECT(*) "
dictData = Folder.objects.all().values()
#print dictData
jsonData = json.dumps(list(dictData))
return HttpResponse(jsonData, content_type='application/json')
def jsonLessonCrud(request):
#Handle Mesages
#messages.success(request, 'All items on this page have free shipping.',fail_silently=False)
#messages.warning(request, 'All items on this page have free shipping.',fail_silently=True) #OK
# Display on GET
if request.is_ajax() and request.method == 'GET':
id = request.GET.get('id', None)
action = request.GET.get('action', None)
if (action == "filter"):
dictData = Lesson.objects.filter(id=id).values()
else:
dictData = Lesson.objects.all().values()
#print dictData
jsonData = json.dumps(list(dictData))
return HttpResponse(jsonData, content_type='application/json')
# CRUD on POST
if request.is_ajax() and request.method == 'POST':
action = request.POST.get('action', None)
#dictData = Lesson.objects.all().values()
#ADD
if (action == "add"):
#Fakeloi 1o 2o xeri (AB)
#booksAB = models.IntegerField(default=0, blank=False)
#booksABFolders = models.IntegerField(default=0, blank=False)
#booksC = request.POST.get('booksC', None)
#booksCFolders = request.POST.get('booksCFolders', None)
category = request.POST.get('category', None)
name = request.POST.get('name', None)
type = request.POST.get('type', None)
try:
record = Folder(category=category, name=name, type=type)
record.save()
msg = "Επιτυχής εισαγωγή Φακέλου (%s) !" % (record)
helperMessageLog(request, msg, tag='info')
except IntegrityError:
transaction.rollback()
msg = "Αδυναμία εισαγωγής Φακέλου (%s) !" % (record)
helperMessageLog(request, msg, tag='error')
#jsonData = json.dumps({'msg': msg})
# return record
dictData = Lesson.objects.filter(id=record.id).values()
jsonData = json.dumps(dictData)
return HttpResponse(jsonData, content_type='application/json')
# UPDATE
elif (action == "update"):
id = request.POST.get('id', None)
#Fakeloi 1o 2o xeri (AB)
#booksAB booksABFolders
booksC = request.POST.get('booksC', None)
booksCFolders = request.POST.get('booksCFolders', None)
category = request.POST.get('category', None)
name = request.POST.get('name', None)
type = request.POST.get('type', None)
try:
#'Αδυναμία εισαγωγής | τροποποίησης | διαγραφής | εγγραφής.'
record = Lesson.objects.filter(id=id)
record.update(
booksC=booksC,
booksCFolders=booksCFolders,
category=category,
name=name,
type=type,
)
msg = "Επιτυχής τροποποίηση Φακέλου (%s) !" % (record)
helperMessageLog(request, msg, tag='info')
except IntegrityError:
transaction.rollback()
msg = "Αδυναμία τροποποίησης Φακέλου (%s) !" % (record)
helperMessageLog(request, msg, tag='error')
# return Lesson record
dictData = record.values()
jsonData = json.dumps(list(dictData))
#print jsonData
return HttpResponse(jsonData, content_type='application/json')
#DELETE
if (action == "delete"):
id = request.POST.get('id', None)
record = Lesson.objects.filter(id=id)
try:
#'Αδυναμία εισαγωγής | τροποποίησης | διαγραφής | εγγραφής.'
record.delete()
msg = "Επιτυχής διαγραφή Φακέλου (%s) !" % (record)
helperMessageLog(request, msg, tag='info')
except IntegrityError:
transaction.rollback()
msg = "Αδυναμία διαγραφής Φακέλου (%s) !" % (record)
helperMessageLog(request, msg, tag='error')
return HttpResponse(result, content_type='application/json')
# else: No POST Default
# DEFAULT
else:
dictData = Lesson.objects.all().values()
jsonData = json.dumps(list(dictData))
#print jsonData
return HttpResponse(jsonData, content_type='application/json')
def copy_folder(request, folder_id):
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('existing_user'), {
'logged_in': False,
'form': forms.LoginForm(),
})
if request.method == 'POST':
form = forms.FolderForm(request.POST)
filterargs = {'author': request.user, 'name': request.POST['name']}
if Folder.objects.filter(**filterargs):
return render(request, 'secure_witness/copy_folder.html', {
'folder_taken': True,
'folder': Folder.objects.get(pk = folder_id),
'folder_id': folder_id,
'user': request.user,
'form': form,
'logged_in': request.user.is_authenticated(),
})
if form.is_valid():
original_folder = Folder.objects.get(pk = folder_id)
folder = Folder(
author = original_folder.author,
name = request.POST['name'],
date_created = original_folder.date_created,
date_modified = original_folder.date_modified,
location = request.POST['location'],
description = request.POST['description']
)
folder.save()
for original_bulletin in Bulletin.objects.filter(folder = original_folder):
bulletin = Bulletin(
author = original_bulletin.author,
name = original_bulletin.name,
folder = folder,
date_created = original_bulletin.date_created,
date_modified = original_bulletin.date_modified,
location = original_bulletin.location,
description = original_bulletin.description
)
bulletin.save()
for original_file in File.objects.filter(bulletin = original_bulletin):
newFile = File(
author = original_file.author,
bulletin = bulletin,
content = original_file.content,
name = original_file.name,
rand = original_file.rand,
check = original_file.check,
encryption_params = original_file.encryption_params,
date_created = original_file.date_created,
date_modified = original_file.date_modified
)
newFile.save()
return HttpResponseRedirect(reverse('home'), {
'logged_in': request.user.is_authenticated(),
'form': forms.LoginForm(),
})
else:
f = get_object_or_404(Folder, pk = folder_id)
form = forms.FolderForm(instance = f)
return render(request, 'secure_witness/copy_folder.html', {
'folder_id': folder_id,
'form': form,
'folder': Folder.objects.get(pk = folder_id),
'logged_in': request.user.is_authenticated(),
})
class DocumentsViewsTest(TestCase):
username = "******"
password = "******"
def setUp(self):
self.group, created = Group.objects.get_or_create(name='test')
self.user, created = DjangoUser.objects.get_or_create(username=self.username)
self.user.set_password(self.password)
self.user.save()
perspective, created = Perspective.objects.get_or_create(
name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.folder = Folder(name='test')
self.folder.set_default_user()
self.folder.save()
self.document = Document(title='test_document', folder=self.folder)
self.document.set_default_user()
self.document.save()
self.file = File(name='test_file', folder=self.folder)
self.file.set_default_user()
self.file.save()
self.link = WebLink(title='test', folder=self.folder, url='test')
self.link.set_default_user()
self.link.save()
######################################
# Testing views when user is logged in
######################################
def test_index_login(self):
"Test index page with login at /documents/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('document_index'))
self.assertEquals(response.status_code, 200)
def test_index_documents_login(self):
"Test index page with login at /documents/documents/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('index_documents'))
self.assertEquals(response.status_code, 200)
def test_index_files_login(self):
"Test index page with login at /documents/files/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('index_files'))
self.assertEquals(response.status_code, 200)
def test_index_weblinks_login(self):
"Test index page with login at /documents/weblinks/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('index_weblinks'))
self.assertEquals(response.status_code, 200)
# Folders
def test_folder_add(self):
"Test index page with login at /documents/folder/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_folder_add'))
self.assertEquals(response.status_code, 200)
# form
self.assertEqual(Folder.objects.count(), 1)
post_data = {'name': 'test'}
response = self.client.post(reverse('documents_folder_add'), post_data)
self.assertEquals(response.status_code, 302) # redirect somewhere
self.assertEquals(Folder.objects.count(), 2)
def test_folder_view_login(self):
"Test index page with login at /documents/folder/view/<folder_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_folder_view', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
def test_folder_edit_login(self):
"Test index page with login at /documents/folder/edit/<folder_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_folder_edit', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
def test_folder_delete_login(self):
"Test index page with login at /documents/folder/delete/<folder_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_folder_delete', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
# Documents
def test_document_add(self):
"Test index page with login at /documents/add"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_document_add'))
self.assertEquals(response.status_code, 200)
# form
self.assertEqual(Document.objects.count(), 1)
response = self.client.get(reverse('documents_document_add'))
post_data = {'title': 'test',
'folder': self.folder,
}
response = self.client.post(
reverse('documents_document_add'), post_data)
#self.assertEqual(Document.objects.count(), 2)
def test_document_add_typed(self):
"Test index page with login at /documents/add/folder/<folder_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_document_add_typed', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
def test_document_view_login(self):
"Test index page with login at /documents/view/<document_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_document_view', args=[self.document.id]))
self.assertEquals(response.status_code, 200)
def test_document_edit_login(self):
"Test index page with login at /documents/edit/<document_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_document_edit', args=[self.document.id]))
self.assertEquals(response.status_code, 200)
def test_document_delete_login(self):
"Test index page with login at /documents/delete/<document_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_document_delete', args=[self.document.id]))
self.assertEquals(response.status_code, 200)
# Files
def test_file_view_login(self):
"Test index page with login at /file/view/<file_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_file_view', args=[self.file.id]))
self.assertEquals(response.status_code, 200)
def test_file_edit_login(self):
"Test index page with login at /file/edit/<file_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_file_edit', args=[self.file.id]))
self.assertEquals(response.status_code, 200)
def test_file_delete_login(self):
"Test index page with login at /file/view/<file_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_file_delete', args=[self.file.id]))
self.assertEquals(response.status_code, 200)
# Web Links
def test_weblink_add_typed(self):
"Test index page with login at /documents/weblink/add/<folder_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_weblink_add_typed', args=[self.folder.id]))
self.assertEquals(response.status_code, 200)
def test_weblink_add(self):
"Test index page with login at /documents/weblink/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('documents_weblink_add'))
self.assertEquals(response.status_code, 200)
# form
self.assertEqual(WebLink.objects.count(), 1)
response = self.client.get(reverse('documents_weblink_add'))
post_data = {'title': 'test',
'folder': self.folder,
'url': 'test',
}
response = self.client.post(
reverse('documents_weblink_add'), post_data)
# self.assertEqual(WebLink.objects.count(), 2)
def test_weblink_view_login(self):
"Test index page with login at /documents/view/<weblink_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_weblink_view', args=[self.link.id]))
self.assertEquals(response.status_code, 200)
def test_weblink_edit_login(self):
"Test index page with login at /documents/edit/<weblink_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_weblink_edit', args=[self.link.id]))
self.assertEquals(response.status_code, 200)
def test_weblink_delete_login(self):
"Test index page with login at /documents/delete/<weblink_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('documents_weblink_delete', args=[self.link.id]))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_index(self):
"Test index page at /documents/"
response = self.client.get('/documents/')
# Redirects as unauthenticated
self.assertRedirects(response, reverse('user_login'))
def test_index_documents_out(self):
"Testing /documents/documents/"
response = self.client.get(reverse('index_documents'))
self.assertRedirects(response, reverse('user_login'))
def test_index_files_out(self):
"Testing /documents/files/"
response = self.client.get(reverse('index_files'))
self.assertRedirects(response, reverse('user_login'))
def test_index_weblinks_out(self):
"Testing /documents/weblinks/"
response = self.client.get(reverse('index_weblinks'))
self.assertRedirects(response, reverse('user_login'))
# Folders
def test_folder_add_out(self):
"Testing /documents/folder/add/"
response = self.client.get(reverse('documents_folder_add'))
self.assertRedirects(response, reverse('user_login'))
def test_folder_view_out(self):
"Testing /documents/folder/view/<folder_id>"
response = self.client.get(
reverse('documents_folder_view', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
def test_folder_edit_out(self):
"Testing /documents/folder/edit/<folder_id>"
response = self.client.get(
reverse('documents_folder_edit', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
def test_folder_delete_out(self):
"Testing /documents/folder/delete/<folder_id>"
response = self.client.get(
reverse('documents_folder_delete', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
# Documents
def test_document_add_out(self):
"Testing /documents/add"
response = self.client.get(reverse('documents_document_add'))
self.assertRedirects(response, reverse('user_login'))
def test_document_add_typed_out(self):
"Testing /documents/add/folder/<folder_id>"
response = self.client.get(
reverse('documents_document_add_typed', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
def test_document_view_out(self):
"Testing /documents/view/<document_id>"
response = self.client.get(
reverse('documents_document_view', args=[self.document.id]))
self.assertRedirects(response, reverse('user_login'))
def test_document_edit_out(self):
"Testing /documents/edit/<document_id>"
response = self.client.get(
reverse('documents_document_edit', args=[self.document.id]))
self.assertRedirects(response, reverse('user_login'))
def test_document_delete_out(self):
"Testing /documents/delete/<document_id>"
response = self.client.get(
reverse('documents_document_delete', args=[self.document.id]))
self.assertRedirects(response, reverse('user_login'))
# Files
def test_file_view_out(self):
"Testing /file/view/<file_id>"
response = self.client.get(
reverse('documents_file_view', args=[self.file.id]))
self.assertRedirects(response, reverse('user_login'))
def test_file_edit_out(self):
"Testing /file/edit/<file_id>"
response = self.client.get(
reverse('documents_file_edit', args=[self.file.id]))
self.assertRedirects(response, reverse('user_login'))
def test_file_delete_out(self):
"Testing /file/view/<file_id>"
response = self.client.get(
reverse('documents_file_delete', args=[self.file.id]))
self.assertRedirects(response, reverse('user_login'))
# Web Links
def test_weblink_add_typed_out(self):
"Testing /documents/weblink/add/<folder_id>"
response = self.client.get(
reverse('documents_weblink_add_typed', args=[self.folder.id]))
self.assertRedirects(response, reverse('user_login'))
def test_weblink_add_out(self):
"Testing /documents/weblink/add/"
response = self.client.get(reverse('documents_weblink_add'))
self.assertRedirects(response, reverse('user_login'))
def test_weblink_view_out(self):
"Testing /documents/view/<weblink_id>"
response = self.client.get(
reverse('documents_weblink_view', args=[self.link.id]))
self.assertRedirects(response, reverse('user_login'))
def test_weblink_edit_out(self):
"Testing /documents/edit/<weblink_id>"
response = self.client.get(
reverse('documents_weblink_edit', args=[self.link.id]))
self.assertRedirects(response, reverse('user_login'))
def test_weblink_delete_out(self):
"Testing /documents/delete/<weblink_id>"
response = self.client.get(
reverse('documents_weblink_delete', args=[self.link.id]))
self.assertRedirects(response, reverse('user_login'))
