diff --git a/comic/admin.py b/comic/admin.py
index 59e1953..587b3ba 100644
--- a/comic/admin.py
+++ b/comic/admin.py
@@ -9,7 +9,7 @@ class SettingAdmin(admin.ModelAdmin):
 
 @admin.register(ComicBook)
 class ComicBookAdmin(admin.ModelAdmin):
-    list_display = ('file_name', 'last_read_page')
+    pass
 
 
 @admin.register(ComicPage)
diff --git a/comic/models.py b/comic/models.py
index a9ed5e7..0bf8d7b 100644
--- a/comic/models.py
+++ b/comic/models.py
@@ -1,5 +1,6 @@
 from django.db import models
 from django.utils.http import urlsafe_base64_encode, urlsafe_base64_decode
+from django.contrib.auth.models import User
 
 from comic import rarfile
 from comic.util import get_ordered_dir_list
@@ -17,11 +18,8 @@ class Setting(models.Model):
     def __unicode__(self):
         return self.__str__()
 
-
 class ComicBook(models.Model):
     file_name = models.CharField(max_length=100, unique=True)
-    last_read_page = models.IntegerField()
-    unread = models.BooleanField()
 
     def __str__(self):
         return self.file_name
@@ -132,9 +130,7 @@ class ComicBook(models.Model):
         except zipfile.BadZipfile:
             return False
 
-        book = ComicBook(file_name=comic_file_name,
-                         last_read_page=0,
-                         unread=True)
+        book = ComicBook(file_name=comic_file_name)
         book.save()
         i = 0
         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
 
     @staticmethod
-    def generate_directory(base_dir, comic_path):
+    def generate_directory(user, base_dir, comic_path):
         files = []
         for fn in get_ordered_dir_list(path.join(base_dir, comic_path)):
             df = ComicBook.DirFile()
@@ -198,8 +194,9 @@ class ComicBook(models.Model):
                 df.location = urlsafe_base64_encode(path.join(comic_path, fn))
                 try:
                     book = ComicBook.objects.get(file_name=fn)
-                    last_page = book.last_read_page
-                    if book.unread:
+                    status, _ = ComicStatus.objects.get_or_create(comic=book, user=user)
+                    last_page = status.last_read_page
+                    if status.unread:
                         df.label = '<span class="label label-default pull-right">Unread</span>'
                     elif (last_page + 1) == book.page_count:
                         df.label = '<span class="label label-success pull-right">Read</span>'
@@ -229,3 +226,9 @@ class ComicPage(models.Model):
     index = models.IntegerField()
     page_file_name = models.CharField(max_length=100, unique=False)
     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)
diff --git a/comic/tests.py b/comic/tests.py
index 7ce503c..6e45b44 100644
--- a/comic/tests.py
+++ b/comic/tests.py
@@ -1,3 +1,227 @@
 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.
+
+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')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/comic/views.py b/comic/views.py
index ecdda8b..d0a9cb7 100644
--- a/comic/views.py
+++ b/comic/views.py
@@ -4,7 +4,7 @@ from django.utils.http import urlsafe_base64_decode
 from django.shortcuts import render, redirect
 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 os import path
@@ -17,9 +17,10 @@ def comic_list(request, comic_path=''):
         return redirect('/comic/settings/')
     if not path.isdir(base_dir):
         return redirect('/comic/settings/')
+
     comic_path = urlsafe_base64_decode(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, {
         'file_list': files,
         'breadcrumbs': breadcrumbs,
@@ -57,9 +58,10 @@ def read_comic(request, comic_path, page):
         book = ComicBook.objects.get(file_name=comic_file_name)
     except ComicBook.DoesNotExist:
         book = ComicBook.process_comic_book(base_dir, decoded_path, comic_file_name)
-    book.unread = False
-    book.last_read_page = page
-    book.save()
+    status, _ = ComicStatus.objects.get_or_create(comic=book, user=request.user)
+    status.unread = False
+    status.last_read_page = page
+    status.save()
     context = RequestContext(request, {
         'book': book,
         'orig_file_name': book.page_name(page),
diff --git a/comic_auth/tests.py b/comic_auth/tests.py
index 4f3bc35..e69de29 100644
--- a/comic_auth/tests.py
+++ b/comic_auth/tests.py
@@ -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')
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-