ajurna/cbwebreader
1
0
Fork 0
mirror of https://github.com/ajurna/cbwebreader.git synced 2025-12-06 06:17:17 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

moved tests to correct file.

Browse Source 
added multi user support.
This commit is contained in:
Ajurna
2015-06-25 14:30:03 +01:00
parent 64a590f9ee
commit 80a8a74fde
5 changed files with 244 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
comic/admin.py
View File

@@ -9,7 +9,7 @@ class SettingAdmin(admin.ModelAdmin):
@admin.register(ComicBook) @admin.register(ComicBook)
class ComicBookAdmin(admin.ModelAdmin): class ComicBookAdmin(admin.ModelAdmin):
list_display = ('file_name', 'last_read_page') pass
@admin.register(ComicPage) @admin.register(ComicPage)

21
comic/models.py
View File

@@ -1,5 +1,6 @@
from django.db import models from django.db import models
from django.utils.http import urlsafe_base64_encode, urlsafe_base64_decode from django.utils.http import urlsafe_base64_encode, urlsafe_base64_decode
from django.contrib.auth.models import User
from comic import rarfile from comic import rarfile
from comic.util import get_ordered_dir_list from comic.util import get_ordered_dir_list
@@ -17,11 +18,8 @@ class Setting(models.Model):
def __unicode__(self): def __unicode__(self):
return self.__str__() return self.__str__()
class ComicBook(models.Model): class ComicBook(models.Model):
file_name = models.CharField(max_length=100, unique=True) file_name = models.CharField(max_length=100, unique=True)
last_read_page = models.IntegerField()
unread = models.BooleanField()
def __str__(self): def __str__(self):
return self.file_name return self.file_name
@@ -132,9 +130,7 @@ class ComicBook(models.Model):
except zipfile.BadZipfile: except zipfile.BadZipfile:
return False return False
book = ComicBook(file_name=comic_file_name, book = ComicBook(file_name=comic_file_name)
last_read_page=0,
unread=True)
book.save() book.save()
i = 0 i = 0
for f in sorted([str(x) for x in cbx.namelist()], key=str.lower): for f in sorted([str(x) for x in cbx.namelist()], key=str.lower):
@@ -183,7 +179,7 @@ class ComicBook(models.Model):
return self.name return self.name
@staticmethod @staticmethod
def generate_directory(base_dir, comic_path): def generate_directory(user, base_dir, comic_path):
files = [] files = []
for fn in get_ordered_dir_list(path.join(base_dir, comic_path)): for fn in get_ordered_dir_list(path.join(base_dir, comic_path)):
df = ComicBook.DirFile() df = ComicBook.DirFile()
@@ -198,8 +194,9 @@ class ComicBook(models.Model):
df.location = urlsafe_base64_encode(path.join(comic_path, fn)) df.location = urlsafe_base64_encode(path.join(comic_path, fn))
try: try:
book = ComicBook.objects.get(file_name=fn) book = ComicBook.objects.get(file_name=fn)
last_page = book.last_read_page status, _ = ComicStatus.objects.get_or_create(comic=book, user=user)
if book.unread: last_page = status.last_read_page
if status.unread:
df.label = '<span class="label label-default pull-right">Unread</span>' df.label = '<span class="label label-default pull-right">Unread</span>'
elif (last_page + 1) == book.page_count: elif (last_page + 1) == book.page_count:
df.label = '<span class="label label-success pull-right">Read</span>' df.label = '<span class="label label-success pull-right">Read</span>'
@@ -229,3 +226,9 @@ class ComicPage(models.Model):
index = models.IntegerField() index = models.IntegerField()
page_file_name = models.CharField(max_length=100, unique=False) page_file_name = models.CharField(max_length=100, unique=False)
content_type = models.CharField(max_length=30) content_type = models.CharField(max_length=30)
class ComicStatus(models.Model):
user = models.ForeignKey(User, unique=False, null=False)
comic = models.ForeignKey(ComicBook, unique=False, null=False)
last_read_page = models.IntegerField(default=0)
unread = models.BooleanField(default=True)

224
comic/tests.py
View File

@@ -1,3 +1,227 @@
from django.test import TestCase from django.test import TestCase
from django.contrib.auth.models import User
from django.utils.http import urlsafe_base64_encode
from comic.models import ComicBook, ComicPage, Setting, ComicStatus
from os import path
import os
# Create your tests here. # Create your tests here.
class ComicBookTests(TestCase):
def setUp(self):
user = User(username='test')
user.save()
ComicBook.process_comic_book(os.getcwd(), path.join('comic', 'test', 'test1.rar'), 'test1.rar')
book = ComicBook.process_comic_book(os.getcwd(), path.join('comic', 'test', 'test2.rar'), 'test2.rar')
status = ComicStatus(user=user,
comic=book,
last_read_page=2,
unread=False)
status.save()
ComicBook.process_comic_book(os.getcwd(), path.join('comic', 'test', 'test4.rar'), 'test4.rar')
Setting(name='BASE_DIR', value=os.getcwd()).save()
def test_comic_processing(self):
book = ComicBook.objects.get(file_name='test1.rar')
self.assertEqual(book.file_name, 'test1.rar')
page0 = ComicPage.objects.get(Comic=book, index=0)
self.assertEqual(page0.page_file_name, 'img1.jpg')
self.assertEqual(page0.content_type, 'image/jpeg')
page1 = ComicPage.objects.get(Comic=book, index=1)
self.assertEqual(page1.page_file_name, 'img2.png')
self.assertEqual(page1.content_type, 'image/png')
page2 = ComicPage.objects.get(Comic=book, index=2)
self.assertEqual(page2.page_file_name, 'img3.gif')
self.assertEqual(page2.content_type, 'image/gif')
page3 = ComicPage.objects.get(Comic=book, index=3)
self.assertEqual(page3.page_file_name, 'img4.bmp')
self.assertEqual(page3.content_type, 'image/bmp')
self.assertEqual(ComicPage.objects.filter(Comic=book).count(), 4)
def test_page_count(self):
book = ComicBook.objects.get(file_name='test1.rar')
self.assertEqual(book.page_count, 4)
def test_is_last_page(self):
book = ComicBook.objects.get(file_name='test1.rar')
self.assertEqual(book.is_last_page(3), True)
self.assertEqual(book.is_last_page(2), False)
def test_get_image(self):
book = ComicBook.objects.get(file_name='test1.rar')
comic_path = path.join(os.getcwd(), 'comic', 'test', 'test1.rar')
img, content_type = book.get_image(comic_path, 0)
self.assertEqual(content_type, 'image/jpeg')
self.assertEqual(img.read(), 'img1.jpg')
def test_nav_first_page_with_folder_above(self):
book = ComicBook.objects.get(file_name='test1.rar')
comic_path = path.join('comic', 'test', 'test1.rar')
encoded_path = urlsafe_base64_encode(comic_path)
prev_path_encoded = urlsafe_base64_encode(path.join('comic', 'test'))
nav = book.nav(encoded_path, 0)
self.assertEqual(nav.next_index, 1)
self.assertEqual(nav.next_path, encoded_path)
self.assertEqual(nav.prev_index, -1)
self.assertEqual(nav.prev_path, prev_path_encoded)
self.assertEqual(nav.cur_index, 0)
self.assertEqual(nav.cur_path, encoded_path)
self.assertEqual(nav.q_prev_to_directory, True)
self.assertEqual(nav.q_next_to_directory, False)
def test_nav_first_page_with_comic_above(self):
book = ComicBook.objects.get(file_name='test2.rar')
comic_path = path.join('comic', 'test', 'test2.rar')
encoded_path = urlsafe_base64_encode(comic_path)
prev_path_encoded = urlsafe_base64_encode(path.join('comic', 'test', 'test1.rar'))
nav = book.nav(encoded_path, 0)
self.assertEqual(nav.next_index, 1)
self.assertEqual(nav.next_path, encoded_path)
self.assertEqual(nav.prev_index, 3)
self.assertEqual(nav.prev_path, prev_path_encoded)
self.assertEqual(nav.cur_index, 0)
self.assertEqual(nav.cur_path, encoded_path)
self.assertEqual(nav.q_prev_to_directory, False)
self.assertEqual(nav.q_next_to_directory, False)
def test_nav_last_page_with_comic_below(self):
book = ComicBook.objects.get(file_name='test2.rar')
comic_path = path.join('comic', 'test', 'test2.rar')
encoded_path = urlsafe_base64_encode(comic_path)
next_path_encoded = urlsafe_base64_encode(path.join('comic', 'test', 'test3.rar'))
nav = book.nav(encoded_path, 3)
self.assertEqual(nav.next_index, 0)
self.assertEqual(nav.next_path, next_path_encoded)
self.assertEqual(nav.prev_index, 2)
self.assertEqual(nav.prev_path, encoded_path)
self.assertEqual(nav.cur_index, 3)
self.assertEqual(nav.cur_path, encoded_path)
self.assertEqual(nav.q_prev_to_directory, False)
self.assertEqual(nav.q_next_to_directory, False)
def test_nav_last_page_with_nothing_below(self):
book = ComicBook.objects.get(file_name='test4.rar')
comic_path = path.join('comic', 'test', 'test4.rar')
encoded_path = urlsafe_base64_encode(comic_path)
next_path_encoded = urlsafe_base64_encode(path.join('comic', 'test'))
nav = book.nav(encoded_path, 3)
self.assertEqual(nav.next_index, -1)
self.assertEqual(nav.next_path, next_path_encoded)
self.assertEqual(nav.prev_index, 2)
self.assertEqual(nav.prev_path, encoded_path)
self.assertEqual(nav.cur_index, 3)
self.assertEqual(nav.cur_path, encoded_path)
self.assertEqual(nav.q_prev_to_directory, False)
self.assertEqual(nav.q_next_to_directory, True)
def test_nav_in_comic(self):
book = ComicBook.objects.get(file_name='test1.rar')
comic_path = path.join('comic', 'test', 'test1.rar')
encoded_path = urlsafe_base64_encode(comic_path)
nav = book.nav(encoded_path, 1)
self.assertEqual(nav.next_index, 2)
self.assertEqual(nav.next_path, encoded_path)
self.assertEqual(nav.prev_index, 0)
self.assertEqual(nav.prev_path, encoded_path)
self.assertEqual(nav.cur_index, 1)
self.assertEqual(nav.cur_path, encoded_path)
self.assertEqual(nav.q_prev_to_directory, False)
self.assertEqual(nav.q_next_to_directory, False)
def test_generate_directory(self):
base_dir = Setting.objects.get(name='BASE_DIR').value
user = User.objects.get(username='test')
folders = ComicBook.generate_directory(user, base_dir, path.join('comic', 'test'))
dir1 = folders[0]
self.assertEqual(dir1.name, 'test_folder')
self.assertTrue(dir1.isdir)
self.assertEqual(dir1.icon, 'glyphicon-folder-open')
self.assertFalse(dir1.iscb)
location = urlsafe_base64_encode(path.join('comic', 'test', 'test_folder'))
self.assertEqual(dir1.location, location)
self.assertEqual(dir1.label, '')
self.assertEqual(dir1.cur_page, 0)
dir2 = folders[1]
self.assertEqual(dir2.name, 'test1.rar')
self.assertFalse(dir2.isdir)
self.assertEqual(dir2.icon, 'glyphicon-book')
self.assertTrue(dir2.iscb)
location = urlsafe_base64_encode(path.join('comic', 'test', 'test1.rar'))
self.assertEqual(dir2.location, location)
self.assertEqual(dir2.label, '<span class="label label-default pull-right">Unread</span>')
self.assertEqual(dir2.cur_page, 0)
dir3 = folders[2]
self.assertEqual(dir3.name, 'test2.rar')
self.assertFalse(dir3.isdir)
self.assertEqual(dir3.icon, 'glyphicon-book')
self.assertTrue(dir3.iscb)
location = urlsafe_base64_encode(path.join('comic', 'test', 'test2.rar'))
self.assertEqual(dir3.location, location)
self.assertEqual(dir3.label, '<span class="label label-primary pull-right">3/4</span>')
self.assertEqual(dir3.cur_page, 2)
dir3 = folders[3]
self.assertEqual(dir3.name, 'test3.rar')
self.assertFalse(dir3.isdir)
self.assertEqual(dir3.icon, 'glyphicon-book')
self.assertTrue(dir3.iscb)
location = urlsafe_base64_encode(path.join('comic', 'test', 'test3.rar'))
self.assertEqual(dir3.location, location)
self.assertEqual(dir3.label, '<span class="label label-danger pull-right">Unprocessed</span>')
self.assertEqual(dir3.cur_page, 0)
def test_pages(self):
book = ComicBook.objects.get(file_name='test1.rar')
pages = book.pages
self.assertEqual(pages[0].page_file_name, 'img1.jpg')
self.assertEqual(pages[0].index, 0)
self.assertEqual(pages[1].page_file_name, 'img2.png')
self.assertEqual(pages[1].index, 1)
self.assertEqual(pages[2].page_file_name, 'img3.gif')
self.assertEqual(pages[2].index, 2)
self.assertEqual(pages[3].page_file_name, 'img4.bmp')
self.assertEqual(pages[3].index, 3)
def test_page_name(self):
book = ComicBook.objects.get(file_name='test1.rar')
self.assertEqual(book.page_name(0), 'img1.jpg')

12
comic/views.py
View File

@@ -4,7 +4,7 @@ from django.utils.http import urlsafe_base64_decode
from django.shortcuts import render, redirect from django.shortcuts import render, redirect
from django.contrib.auth.decorators import login_required from django.contrib.auth.decorators import login_required
from comic.models import Setting, ComicBook from comic.models import Setting, ComicBook, ComicStatus
from util import generate_breadcrumbs from util import generate_breadcrumbs
from os import path from os import path
@@ -17,9 +17,10 @@ def comic_list(request, comic_path=''):
return redirect('/comic/settings/') return redirect('/comic/settings/')
if not path.isdir(base_dir): if not path.isdir(base_dir):
return redirect('/comic/settings/') return redirect('/comic/settings/')
comic_path = urlsafe_base64_decode(comic_path) comic_path = urlsafe_base64_decode(comic_path)
breadcrumbs = generate_breadcrumbs(comic_path) breadcrumbs = generate_breadcrumbs(comic_path)
files = ComicBook.generate_directory(base_dir, comic_path) files = ComicBook.generate_directory(request.user, base_dir, comic_path)
context = RequestContext(request, { context = RequestContext(request, {
'file_list': files, 'file_list': files,
'breadcrumbs': breadcrumbs, 'breadcrumbs': breadcrumbs,
@@ -57,9 +58,10 @@ def read_comic(request, comic_path, page):
book = ComicBook.objects.get(file_name=comic_file_name) book = ComicBook.objects.get(file_name=comic_file_name)
except ComicBook.DoesNotExist: except ComicBook.DoesNotExist:
book = ComicBook.process_comic_book(base_dir, decoded_path, comic_file_name) book = ComicBook.process_comic_book(base_dir, decoded_path, comic_file_name)
book.unread = False status, _ = ComicStatus.objects.get_or_create(comic=book, user=request.user)
book.last_read_page = page status.unread = False
book.save() status.last_read_page = page
status.save()
context = RequestContext(request, { context = RequestContext(request, {
'book': book, 'book': book,
'orig_file_name': book.page_name(page), 'orig_file_name': book.page_name(page),

230
comic_auth/tests.py
View File

@@ -1,230 +0,0 @@
from django.test import TestCase
from django.utils.http import urlsafe_base64_decode, urlsafe_base64_encode
from comic.models import ComicBook, ComicPage, Setting
from os import path
import os
# Create your tests here.
class ComicBookTests(TestCase):
def setUp(self):
ComicBook.process_comic_book(os.getcwd(), path.join('comic', 'test', 'test1.rar'), 'test1.rar')
book = ComicBook.process_comic_book(os.getcwd(), path.join('comic', 'test', 'test2.rar'), 'test2.rar')
book.last_read_page = 2
book.unread = False
book.save()
ComicBook.process_comic_book(os.getcwd(), path.join('comic', 'test', 'test4.rar'), 'test4.rar')
Setting(name='BASE_DIR', value=os.getcwd()).save()
def test_comic_processing(self):
book = ComicBook.objects.get(file_name='test1.rar')
self.assertEqual(book.file_name, 'test1.rar')
page0 = ComicPage.objects.get(Comic=book, index=0)
self.assertEqual(page0.page_file_name, 'img1.jpg')
self.assertEqual(page0.content_type, 'image/jpeg')
page1 = ComicPage.objects.get(Comic=book, index=1)
self.assertEqual(page1.page_file_name, 'img2.png')
self.assertEqual(page1.content_type, 'image/png')
page2 = ComicPage.objects.get(Comic=book, index=2)
self.assertEqual(page2.page_file_name, 'img3.gif')
self.assertEqual(page2.content_type, 'image/gif')
page3 = ComicPage.objects.get(Comic=book, index=3)
self.assertEqual(page3.page_file_name, 'img4.bmp')
self.assertEqual(page3.content_type, 'image/bmp')
self.assertEqual(ComicPage.objects.filter(Comic=book).count(), 4)
def test_page_count(self):
book = ComicBook.objects.get(file_name='test1.rar')
self.assertEqual(book.page_count, 4)
def test_is_last_page(self):
book = ComicBook.objects.get(file_name='test1.rar')
self.assertEqual(book.is_last_page(3), True)
self.assertEqual(book.is_last_page(2), False)
def test_get_image(self):
book = ComicBook.objects.get(file_name='test1.rar')
comic_path = path.join(os.getcwd(), 'comic', 'test', 'test1.rar')
img, content_type = book.get_image(comic_path, 0)
self.assertEqual(content_type, 'image/jpeg')
self.assertEqual(img.read(), 'img1.jpg')
def test_nav_first_page_with_folder_above(self):
book = ComicBook.objects.get(file_name='test1.rar')
comic_path = path.join('comic', 'test', 'test1.rar')
encoded_path = urlsafe_base64_encode(comic_path)
prev_path_encoded = urlsafe_base64_encode(path.join('comic','test'))
nav = book.nav(encoded_path, 0)
self.assertEqual(nav.next_index, 1)
self.assertEqual(nav.next_path, encoded_path)
self.assertEqual(nav.prev_index, -1)
self.assertEqual(nav.prev_path, prev_path_encoded)
self.assertEqual(nav.cur_index, 0)
self.assertEqual(nav.cur_path, encoded_path)
self.assertEqual(nav.q_prev_to_directory, True)
self.assertEqual(nav.q_next_to_directory, False)
def test_nav_first_page_with_comic_above(self):
book = ComicBook.objects.get(file_name='test2.rar')
comic_path = path.join('comic', 'test', 'test2.rar')
encoded_path = urlsafe_base64_encode(comic_path)
prev_path_encoded = urlsafe_base64_encode(path.join('comic', 'test', 'test1.rar'))
nav = book.nav(encoded_path, 0)
self.assertEqual(nav.next_index, 1)
self.assertEqual(nav.next_path, encoded_path)
self.assertEqual(nav.prev_index, 3)
self.assertEqual(nav.prev_path, prev_path_encoded)
self.assertEqual(nav.cur_index, 0)
self.assertEqual(nav.cur_path, encoded_path)
self.assertEqual(nav.q_prev_to_directory, False)
self.assertEqual(nav.q_next_to_directory, False)
def test_nav_last_page_with_comic_below(self):
book = ComicBook.objects.get(file_name='test2.rar')
comic_path = path.join('comic', 'test', 'test2.rar')
encoded_path = urlsafe_base64_encode(comic_path)
next_path_encoded = urlsafe_base64_encode(path.join('comic', 'test', 'test3.rar'))
nav = book.nav(encoded_path, 3)
self.assertEqual(nav.next_index, 0)
self.assertEqual(nav.next_path, next_path_encoded)
self.assertEqual(nav.prev_index, 2)
self.assertEqual(nav.prev_path, encoded_path)
self.assertEqual(nav.cur_index, 3)
self.assertEqual(nav.cur_path, encoded_path)
self.assertEqual(nav.q_prev_to_directory, False)
self.assertEqual(nav.q_next_to_directory, False)
def test_nav_last_page_with_nothing_below(self):
book = ComicBook.objects.get(file_name='test4.rar')
comic_path = path.join('comic', 'test', 'test4.rar')
encoded_path = urlsafe_base64_encode(comic_path)
next_path_encoded = urlsafe_base64_encode(path.join('comic', 'test'))
nav = book.nav(encoded_path, 3)
self.assertEqual(nav.next_index, -1)
self.assertEqual(nav.next_path, next_path_encoded)
self.assertEqual(nav.prev_index, 2)
self.assertEqual(nav.prev_path, encoded_path)
self.assertEqual(nav.cur_index, 3)
self.assertEqual(nav.cur_path, encoded_path)
self.assertEqual(nav.q_prev_to_directory, False)
self.assertEqual(nav.q_next_to_directory, True)
def test_nav_in_comic(self):
book = ComicBook.objects.get(file_name='test1.rar')
comic_path = path.join('comic', 'test', 'test1.rar')
encoded_path = urlsafe_base64_encode(comic_path)
nav = book.nav(encoded_path, 1)
self.assertEqual(nav.next_index, 2)
self.assertEqual(nav.next_path, encoded_path)
self.assertEqual(nav.prev_index, 0)
self.assertEqual(nav.prev_path, encoded_path)
self.assertEqual(nav.cur_index, 1)
self.assertEqual(nav.cur_path, encoded_path)
self.assertEqual(nav.q_prev_to_directory, False)
self.assertEqual(nav.q_next_to_directory, False)
def test_generate_directory(self):
#self.name = ''
#self.isdir = False
#self.icon = ''
#self.iscb = False
#self.location = ''
#self.label = ''
#self.cur_page = 0
base_dir = Setting.objects.get(name='BASE_DIR').value
folders = ComicBook.generate_directory(base_dir, path.join('comic', 'test'))
#should be 4 items in list.
dir1 = folders[0]
self.assertEqual(dir1.name, 'test_folder')
self.assertTrue(dir1.isdir)
self.assertEqual(dir1.icon, 'glyphicon-folder-open')
self.assertFalse(dir1.iscb)
location = urlsafe_base64_encode(path.join('comic', 'test', 'test_folder'))
self.assertEqual(dir1.location, location)
self.assertEqual(dir1.label, '')
self.assertEqual(dir1.cur_page, 0)
dir2 = folders[1]
self.assertEqual(dir2.name, 'test1.rar')
self.assertFalse(dir2.isdir)
self.assertEqual(dir2.icon, 'glyphicon-book')
self.assertTrue(dir2.iscb)
location = urlsafe_base64_encode(path.join('comic', 'test', 'test1.rar'))
self.assertEqual(dir2.location, location)
self.assertEqual(dir2.label, '<span class="label label-default pull-right">Unread</span>')
self.assertEqual(dir2.cur_page, 0)
dir3 = folders[2]
self.assertEqual(dir3.name, 'test2.rar')
self.assertFalse(dir3.isdir)
self.assertEqual(dir3.icon, 'glyphicon-book')
self.assertTrue(dir3.iscb)
location = urlsafe_base64_encode(path.join('comic', 'test', 'test2.rar'))
self.assertEqual(dir3.location, location)
self.assertEqual(dir3.label, '<span class="label label-primary pull-right">3/4</span>')
self.assertEqual(dir3.cur_page, 2)
dir3 = folders[3]
self.assertEqual(dir3.name, 'test3.rar')
self.assertFalse(dir3.isdir)
self.assertEqual(dir3.icon, 'glyphicon-book')
self.assertTrue(dir3.iscb)
location = urlsafe_base64_encode(path.join('comic', 'test', 'test3.rar'))
self.assertEqual(dir3.location, location)
self.assertEqual(dir3.label, '<span class="label label-danger pull-right">Unprocessed</span>')
self.assertEqual(dir3.cur_page, 0)
def test_pages(self):
book = ComicBook.objects.get(file_name='test1.rar')
pages = book.pages
self.assertEqual(pages[0].page_file_name, 'img1.jpg')
self.assertEqual(pages[0].index, 0)
self.assertEqual(pages[1].page_file_name, 'img2.png')
self.assertEqual(pages[1].index, 1)
self.assertEqual(pages[2].page_file_name, 'img3.gif')
self.assertEqual(pages[2].index, 2)
self.assertEqual(pages[3].page_file_name, 'img4.bmp')
self.assertEqual(pages[3].index, 3)
def test_page_name(self):
book = ComicBook.objects.get(file_name='test1.rar')
self.assertEqual(book.page_name(0), 'img1.jpg')