Python StaticContent.get_canonicalized_asset_path方法代码示例

# 需要导入模块: from xmodule.contentstore.content import StaticContent [as 别名]
# 或者: from xmodule.contentstore.content.StaticContent import get_canonicalized_asset_path [as 别名]
    def test_canonical_asset_path_with_new_style_assets(self, base_url, start, expected, mongo_calls):
        exts = ['.html', '.tm']
        prefix = 'split'
        encoded_base_url = quote_plus('//' + base_url)
        c4x = 'c4x/a/b/asset'
        asset_key = 'asset-v1:a+b+{}[email protected]+block'.format(prefix)
        encoded_asset_key = quote_plus('/asset-v1:a+b+{}[email protected][email protected]'.format(prefix))
        th_key = 'asset-v1:a+b+{}[email protected]+block'.format(prefix)
        th_ext = 'png-16x16.jpg'

        start = start.format(
            prfx=prefix,
            c4x=c4x,
            asset=asset_key,
            encoded_base_url=encoded_base_url,
            encoded_asset=encoded_asset_key,
            th_key=th_key,
            th_ext=th_ext
        )
        expected = expected.format(
            prfx=prefix,
            c4x=c4x,
            asset=asset_key,
            encoded_base_url=encoded_base_url,
            encoded_asset=encoded_asset_key,
            th_key=th_key,
            th_ext=th_ext
        )

        with check_mongo_calls(mongo_calls):
            asset_path = StaticContent.get_canonicalized_asset_path(self.courses[prefix].id, start, base_url, exts)
            self.assertEqual(asset_path, expected)

# 需要导入模块: from xmodule.contentstore.content import StaticContent [as 别名]
# 或者: from xmodule.contentstore.content.StaticContent import get_canonicalized_asset_path [as 别名]
    def test_canonical_asset_path_with_new_style_assets(self, base_url, start, expected, mongo_calls):
        exts = ['.html', '.tm']
        prefix = u'split'
        encoded_base_url = urlquote(u'//' + base_url)
        c4x = u'c4x/a/b/asset'
        base_asset_key = u'asset-v1:a+b+{}[email protected]+block'.format(prefix)
        adjusted_asset_key = base_asset_key
        encoded_asset_key = urlquote(u'/asset-v1:a+b+{}[email protected][email protected]'.format(prefix))
        encoded_base_asset_key = encoded_asset_key
        base_th_key = u'asset-v1:a+b+{}[email protected]+block'.format(prefix)
        adjusted_th_key = base_th_key
        th_ext = u'png-16x16.jpg'

        start = start.format(
            prfx=prefix,
            c4x=c4x,
            base_asset=base_asset_key,
            asset=adjusted_asset_key,
            encoded_base_url=encoded_base_url,
            encoded_asset=encoded_asset_key,
            base_th_key=base_th_key,
            th_key=adjusted_th_key,
            th_ext=th_ext
        )

        # Adjust for content digest.  This gets dicey quickly and we have to order our steps:
        # - replace format markets because they have curly braces
        # - encode Unicode characters to percent-encoded
        # - finally shove back in our regex patterns
        digest = CanonicalContentTest.get_content_digest_for_asset_path(prefix, start)
        if digest:
            adjusted_asset_key = u'assets/courseware/VMARK/HMARK/asset-v1:a+b+{}[email protected]+block'.format(prefix)
            adjusted_th_key = u'assets/courseware/VMARK/HMARK/asset-v1:a+b+{}[email protected]+block'.format(prefix)
            encoded_asset_key = u'/assets/courseware/VMARK/HMARK/asset-v1:a+b+{}[email protected][email protected]'.format(prefix)
            encoded_asset_key = urlquote(encoded_asset_key)

        expected = expected.format(
            prfx=prefix,
            c4x=c4x,
            base_asset=base_asset_key,
            asset=adjusted_asset_key,
            encoded_base_url=encoded_base_url,
            encoded_asset=encoded_asset_key,
            base_th_key=base_th_key,
            th_key=adjusted_th_key,
            th_ext=th_ext,
            encoded_base_asset=encoded_base_asset_key,
        )

        expected = encode_unicode_characters_in_url(expected)
        expected = expected.replace('VMARK', r'v[\d]')
        expected = expected.replace('HMARK', '[a-f0-9]{32}')
        expected = expected.replace('+', r'\+').replace('?', r'\?')

        with check_mongo_calls(mongo_calls):
            asset_path = StaticContent.get_canonicalized_asset_path(self.courses[prefix].id, start, base_url, exts)
            print expected
            print asset_path
            self.assertIsNotNone(re.match(expected, asset_path))

# 需要导入模块: from xmodule.contentstore.content import StaticContent [as 别名]
# 或者: from xmodule.contentstore.content.StaticContent import get_canonicalized_asset_path [as 别名]
    def replace_static_url(original, prefix, quote, rest):
        """
        Replace a single matched url.
        """
        original_uri = "".join([prefix, rest])
        # Don't mess with things that end in '?raw'
        if rest.endswith('?raw'):
            static_paths_out.append((original_uri, original_uri))
            return original

        # In debug mode, if we can find the url as is,
        if settings.DEBUG and finders.find(rest, True):
            static_paths_out.append((original_uri, original_uri))
            return original

        # if we're running with a MongoBacked store course_namespace is not None, then use studio style urls
        elif (not static_asset_path) and course_id:
            # first look in the static file pipeline and see if we are trying to reference
            # a piece of static content which is in the edx-platform repo (e.g. JS associated with an xmodule)

            exists_in_staticfiles_storage = False
            try:
                exists_in_staticfiles_storage = staticfiles_storage.exists(rest)
            except Exception as err:
                log.warning("staticfiles_storage couldn't find path {0}: {1}".format(
                    rest, str(err)))

            if exists_in_staticfiles_storage:
                url = staticfiles_storage.url(rest)
            else:
                # if not, then assume it's courseware specific content and then look in the
                # Mongo-backed database
                # Import is placed here to avoid model import at project startup.
                from static_replace.models import AssetBaseUrlConfig, AssetExcludedExtensionsConfig
                base_url = AssetBaseUrlConfig.get_base_url()
                excluded_exts = AssetExcludedExtensionsConfig.get_excluded_extensions()
                url = StaticContent.get_canonicalized_asset_path(course_id, rest, base_url, excluded_exts)

                if AssetLocator.CANONICAL_NAMESPACE in url:
                    url = url.replace('[email protected]', 'block/', 1)

        # Otherwise, look the file up in staticfiles_storage, and append the data directory if needed
        else:
            course_path = "/".join((static_asset_path or data_directory, rest))

            try:
                if staticfiles_storage.exists(rest):
                    url = staticfiles_storage.url(rest)
                else:
                    url = staticfiles_storage.url(course_path)
            # And if that fails, assume that it's course content, and add manually data directory
            except Exception as err:
                log.warning("staticfiles_storage couldn't find path {0}: {1}".format(
                    rest, str(err)))
                url = "".join([prefix, course_path])

        static_paths_out.append((original_uri, url))
        return "".join([quote, url, quote])

# 需要导入模块: from xmodule.contentstore.content import StaticContent [as 别名]
# 或者: from xmodule.contentstore.content.StaticContent import get_canonicalized_asset_path [as 别名]
    def test_canonical_asset_path_with_c4x_style_assets(self, base_url, start, expected, mongo_calls):
        exts = ['.html', '.tm']
        prefix = 'old'
        base_c4x_block = 'c4x/a/b/asset'
        adjusted_c4x_block = base_c4x_block
        encoded_c4x_block = urlquote('/' + base_c4x_block + '/')
        encoded_base_url = urlquote('//' + base_url)
        encoded_base_c4x_block = encoded_c4x_block

        start = start.format(
            prfx=prefix,
            encoded_base_url=encoded_base_url,
            c4x=base_c4x_block,
            encoded_c4x=encoded_c4x_block
        )

        # Adjust for content digest.  This gets dicey quickly and we have to order our steps:
        # - replace format markets because they have curly braces
        # - encode Unicode characters to percent-encoded
        # - finally shove back in our regex patterns
        digest = CanonicalContentTest.get_content_digest_for_asset_path(prefix, start)
        if digest:
            adjusted_c4x_block = 'assets/courseware/VMARK/HMARK/c4x/a/b/asset'
            encoded_c4x_block = urlquote('/' + adjusted_c4x_block + '/')

        expected = expected.format(
            prfx=prefix,
            encoded_base_url=encoded_base_url,
            base_c4x=base_c4x_block,
            c4x=adjusted_c4x_block,
            encoded_c4x=encoded_c4x_block,
            encoded_base_c4x=encoded_base_c4x_block,
        )

        expected = encode_unicode_characters_in_url(expected)
        expected = expected.replace('VMARK', r'v[\d]')
        expected = expected.replace('HMARK', '[a-f0-9]{32}')
        expected = expected.replace('+', r'\+').replace('?', r'\?')

        with check_mongo_calls(mongo_calls):
            asset_path = StaticContent.get_canonicalized_asset_path(self.courses[prefix].id, start, base_url, exts)
            print expected
            print asset_path
            self.assertIsNotNone(re.match(expected, asset_path))

# 需要导入模块: from xmodule.contentstore.content import StaticContent [as 别名]
# 或者: from xmodule.contentstore.content.StaticContent import get_canonicalized_asset_path [as 别名]
    def test_canonical_asset_path_with_c4x_style_assets(self, base_url, start, expected, mongo_calls):
        prefix = 'old'
        c4x_block = 'c4x/a/b/asset'
        encoded_c4x_block = quote_plus('/' + c4x_block + '/')
        encoded_base_url = quote_plus('//' + base_url)

        start = start.format(
            prefix=prefix,
            encoded_base_url=encoded_base_url,
            c4x=c4x_block,
            encoded_c4x=encoded_c4x_block
        )
        expected = expected.format(
            prefix=prefix,
            encoded_base_url=encoded_base_url,
            c4x=c4x_block,
            encoded_c4x=encoded_c4x_block
        )

        with check_mongo_calls(mongo_calls):
            asset_path = StaticContent.get_canonicalized_asset_path(self.courses[prefix].id, start, base_url)
            self.assertEqual(asset_path, expected)