Esempio n. 1
0
    def test_set_expiry_header(self):
        """ if you register the image with @set_expiry_header=True, expect another header
        called 'Expires' 
        """

        class MyProduct:
            pass

        registerImage(MyProduct, "image.jpg", rel_path="tests", set_expiry_header=True)
        instance = MyProduct()
        img = getattr(instance, "image.jpg")

        REQUEST = self.app.REQUEST
        RESPONSE = REQUEST.RESPONSE
        bin_content = img.index_html(REQUEST, RESPONSE)

        self.assertEqual(
            RESPONSE.getHeader("last-modified"), rfc1123_date(os.stat(right_here("image.jpg"))[stat.ST_MTIME])
        )
        self.assertEqual(RESPONSE.getHeader("cache-control"), "public,max-age=3600")  # default
        self.assertEqual(RESPONSE.getHeader("content-type"), "image/jpeg")
        self.assertEqual(int(RESPONSE.getHeader("content-length")), os.stat(right_here("image.jpg"))[stat.ST_SIZE])

        self.assertEqual(RESPONSE.getHeader("expires"), rfc1123_date(time() + img.max_age))

        # expect a expires header for the infinitely cached alias
        img_infinite_name = instance.misc_infinite_aliases["image.jpg"]
        img_infinite = getattr(instance, img_infinite_name)
        bin_content = img_infinite.index_html(REQUEST, RESPONSE)
        self.assertEqual(RESPONSE.getHeader("expires"), rfc1123_date(time() + EXPIRY_INFINITY))
Esempio n. 2
0
    def test_basic_BetterImageFile(self):
        """ test the BetterImageFile class """

        class MyProduct:
            pass

        mtime = os.stat(right_here("image.jpg"))[stat.ST_MTIME]
        registerImage(MyProduct, right_here("image.jpg"), rel_path="tests")
        instance = MyProduct()

        img = getattr(instance, "image.jpg", None)
        self.assertNotEqual(img, None)

        # expect also that it creates a file called
        # image.<mttime of file>.jpg
        img_infinite = getattr(instance, "image.%s.jpg" % mtime, None)
        self.assertNotEqual(img_infinite, None)

        # expect this to be a BetterImageFile instance
        self.assertEqual(img.__class__, BetterImageFile)
        self.assertTrue(isinstance(img, BetterImageFile))

        # rendering it should return a big binary content load
        self.assertEqual(len(str(img)), os.stat(right_here("image.jpg"))[stat.ST_SIZE])
        self.assertEqual(len(str(img_infinite)), os.stat(right_here("image.jpg"))[stat.ST_SIZE])

        # there should now be a dict set in the instance called misc_infinite_aliases
        # which links 'image.jpg' to 'image.<mttime of file>.jpg'
        self.assertTrue(bool(getattr(instance, "misc_infinite_aliases")))
        aliases = instance.misc_infinite_aliases
        self.assertTrue(isinstance(aliases, dict))

        self.assertTrue("image.jpg" in aliases)

        self.assertEqual(aliases.get("image.jpg"), "image.%s.jpg" % mtime)

        # if we render it with img.index_html() expect certain headers to be set
        REQUEST = self.app.REQUEST
        RESPONSE = REQUEST.RESPONSE
        bin_content = img.index_html(REQUEST, RESPONSE)

        self.assertEqual(
            RESPONSE.getHeader("last-modified"), rfc1123_date(os.stat(right_here("image.jpg"))[stat.ST_MTIME])
        )
        self.assertEqual(RESPONSE.getHeader("cache-control"), "public,max-age=3600")  # default
        self.assertEqual(RESPONSE.getHeader("content-type"), "image/jpeg")
        self.assertEqual(int(RESPONSE.getHeader("content-length")), os.stat(right_here("image.jpg"))[stat.ST_SIZE])

        # if we render the infinitely cached one we can expect different headers
        bin_content = img_infinite.index_html(REQUEST, RESPONSE)

        self.assertEqual(
            RESPONSE.getHeader("last-modified"), rfc1123_date(os.stat(right_here("image.jpg"))[stat.ST_MTIME])
        )
        self.assertEqual(RESPONSE.getHeader("cache-control"), "public,max-age=%s" % EXPIRY_INFINITY)  #
        self.assertEqual(RESPONSE.getHeader("content-type"), "image/jpeg")
        self.assertEqual(int(RESPONSE.getHeader("content-length")), os.stat(right_here("image.jpg"))[stat.ST_SIZE])
Esempio n. 3
0
    def test_registering_with_slimming_and_images_in_css(self):
        try:
            from slimmer import js_slimmer, css_slimmer
        except ImportError:
            # not possible to test this
            return

        class MyProduct:
            pass

        instance = MyProduct()

        # it will only fix images that have otherwise been registered
        registerImage(MyProduct, right_here("image.jpg"), rel_path="tests")

        registerCSSFile(
            MyProduct,
            "containsimages.css",
            rel_path="tests",
            set_expiry_header=True,
            slim_if_possible=True,
            replace_images_with_aliases=True,
        )
        static = getattr(instance, "containsimages.css")

        # Not the same...
        self.assertNotEqual(str(static), css_slimmer(open(right_here("containsimages.css")).read()))
        # unless you remove all '.\d+.'
        self.assertEqual(
            re.sub("\.\d{10,11}\.", ".", str(static)), css_slimmer(open(right_here("containsimages.css")).read())
        )

        # because we haven't registered large.jpg it won't be aliased
        self.assertTrue("large.jpg" in str(static))
        self.assertTrue("image.jpg" not in str(static))

        self.assertEqual(
            sorted(["containsimages.css-slimmed.css-aliased.css", "containsimages.css-slimmed.css"]),
            sorted(os.listdir(_get_autogenerated_dir())),
        )

        # if you don it again it should just overwrite the old one
        registerCSSFile(
            MyProduct,
            "containsimages.css",
            rel_path="tests",
            set_expiry_header=True,
            slim_if_possible=True,
            replace_images_with_aliases=True,
        )

        self.assertEqual(
            sorted(["containsimages.css-slimmed.css-aliased.css", "containsimages.css-slimmed.css"]),
            sorted(os.listdir(_get_autogenerated_dir())),
        )
Esempio n. 4
0
    def test_large_BetterImageFile(self):
        """ test the BetterImageFile() class but with larger images """

        class MyProduct:
            pass

        registerImage(MyProduct, "large.jpg", rel_path="tests", set_expiry_header=True)
        instance = MyProduct()
        img = getattr(instance, "large.jpg")

        REQUEST = self.app.REQUEST
        RESPONSE = REQUEST.RESPONSE
        bin_content = img.index_html(REQUEST, RESPONSE)

        # make sure it's an iterator we received
        self.assertTrue(isinstance(bin_content, open))

        _content = bin_content.read()
        self.assertEqual(len(_content), os.stat(right_here("large.jpg"))[stat.ST_SIZE])
Esempio n. 5
0
def initialize(context):
    """ Initialize product """
    try:
        context.registerClass(
            Homesite.Homepage,
            constructors=(Homesite.manage_addHomepageForm, Homesite.manage_addHomepage),
            icon="www/homepage_icon.gif",
        )

        context.registerClass(
            News.NewsContainer,
            constructors=(News.manage_addNewsContainerForm, News.manage_addNewsContainer),
            icon="www/newscontainer_icon.gif",
        )

        context.registerClass(
            News.NewsItem,
            constructors=(News.manage_addNewsItemForm, News.manage_addNewsItem, News.manage_suggestNewsItemId),
            icon="www/newsitem_icon.gif",
        )

        context.registerClass(
            Files.FilesContainer,
            constructors=(Files.manage_addFilesContainerForm, Files.manage_addFilesContainer),
            icon="www/filescontainer_icon.gif",
        )

        context.registerClass(
            Files.File, constructors=(Files.manage_addFileForm, Files.manage_addFile), icon="www/file_icon.gif"
        )

        context.registerClass(
            Blogs.BlogContainer,
            constructors=(Blogs.manage_addBlogContainerForm, Blogs.manage_addBlogContainer),
            icon="www/blogcontainer_icon.gif",
        )

        context.registerClass(
            Blogs.BlogItem,
            constructors=(Blogs.manage_addBlogItemForm, Blogs.manage_addBlogItem, Blogs.manage_suggestBlogItemId),
            icon="www/blogitem_icon.png",
        )

        context.registerClass(
            Module.Module,
            constructors=(Module.manage_addModuleForm, Module.manage_addModule),
            icon="www/module_icon.gif",
        )

        context.registerClass(
            UserFolder.FriedCMSUserFolder,
            constructors=(UserFolder.manage_addUserFolder,),
            icon="www/userfolder_icon.gif",
        )

        context.registerClass(
            Page.Page, constructors=(Page.manage_addPageForm, Page.manage_addPage), icon="www/page_icon.gif"
        )

        context.registerClass(
            FAQ.FAQContainer,
            constructors=(FAQ.manage_addFAQContainerForm, FAQ.manage_addFAQContainer),
            icon="www/faqcontainer_icon.gif",
        )

        context.registerClass(FAQ.FAQ, constructors=(FAQ.manage_addFAQForm, FAQ.manage_addFAQ), icon="www/faq_icon.gif")

        product = OFS.misc_.misc_.FriedCMS

        registerImages(product, IMAGES, globals(), rel_path="images")
        registerJSFiles(product, JS_FILES, globals())
        registerCSSFiles(product, CSS_FILES, globals())

        icons = uniqify(ICON_ASSOCIATIONS.values())
        for icon in icons:
            registerImage(product, icon, epath="icons", Globals=globals())

    except:
        import sys, traceback, string

        type, val, tb = sys.exc_info()
        sys.stderr.write(string.join(traceback.format_exception(type, val, tb), ""))
        del type, val, tb