def test_cache_full(config_stub, tmpdir):
"""Do a sanity test involving everything."""
config_stub.data = {
'storage': {'cache-size': 1024},
'general': {'private-browsing': False}
}
disk_cache = QNetworkDiskCache()
disk_cache.setCacheDirectory(str(tmpdir))
url = 'http://qutebrowser.org'
content = b'cutebowser'
preload_cache(disk_cache, url, content)
url2 = 'https://qutebrowser.org'
content2 = b'ohmycert'
preload_cache(disk_cache, url2, content2)
metadata = QNetworkCacheMetaData()
metadata.setUrl(QUrl(url))
soon = QDateTime.currentDateTime().addMonths(4)
assert soon.isValid()
metadata.setLastModified(soon)
assert metadata.isValid()
disk_cache.updateMetaData(metadata)
disk_cache.remove(QUrl(url2))
assert disk_cache.metaData(QUrl(url)).lastModified() == soon
assert disk_cache.data(QUrl(url)).readAll() == content
def webSettings(self):
self.cookiesjar = PersistentCookieJar(self)
self.zoom = self.readZoom()
# We don't want Flash (it causes a lot of trouble in some distros)
QWebSettings.globalSettings().setAttribute(QWebSettings.PluginsEnabled,
False)
# We don't need Java
QWebSettings.globalSettings().setAttribute(QWebSettings.JavaEnabled,
False)
# Enabling Local Storage (now required by Slack)
QWebSettings.globalSettings().setAttribute(
QWebSettings.LocalStorageEnabled, True)
# We need browsing history (required to not limit LocalStorage)
QWebSettings.globalSettings().setAttribute(
QWebSettings.PrivateBrowsingEnabled, False)
# Enabling Cache
self.diskCache = QNetworkDiskCache(self)
self.diskCache.setCacheDirectory(self.cache_path)
# Required for copy and paste clipboard integration
QWebSettings.globalSettings().setAttribute(
QWebSettings.JavascriptCanAccessClipboard, True)
# Enabling Inspeclet only when --debug=True (requires more CPU usage)
QWebSettings.globalSettings().setAttribute(
QWebSettings.DeveloperExtrasEnabled, self.debug)
# Sharing the same networkAccessManager
self.networkAccessManager = QNetworkAccessManager(self)
self.networkAccessManager.setCookieJar(self.cookiesjar)
self.networkAccessManager.setCache(self.diskCache)
def __init__(self, parent: QObject = None) -> None:
super().__init__(parent)
self.width: int = 400
self.height: int = 300
self.zoom: int = 15
self.latitude: float = 59.9138204
self.longitude: float = 10.7387413
self.m_offset = QPoint()
self.m_tilesRect = QRect()
self.m_emptyTile = QPixmap(tdim, tdim)
self.m_emptyTile.fill(Qt.lightGray)
self.m_tilePixmaps: typing.Dict[QPointH, QPixmap] = dict()
self.m_manager = QNetworkAccessManager()
self.m_url = QUrl()
cache = QNetworkDiskCache()
cache.setCacheDirectory(
QStandardPaths.writableLocation(QStandardPaths.CacheLocation)
)
self.m_manager.setCache(cache)
self.m_manager.finished.connect(self.handleNetworkData)
def __init__(self, parent = None):
super().__init__(parent)
# set cache
self._cachePath = QNetworkDiskCache(self)
cacheLocation = app.settings.get("frontend", "cachelocation")
self._cachePath.setCacheDirectory(cacheLocation)
self._cachePath.setMaximumCacheSize(20 * 1024 * 1024) # 20M
self.setCache(self._cachePath)
def create(self, parent):
nam = QNetworkAccessManager(parent)
cache = QNetworkDiskCache(parent)
cache_dir = QStandardPaths.writableLocation(QStandardPaths.CacheLocation)
cache_subdir = os.path.join(cache_dir, "network")
print("Cache dir:", cache_subdir)
cache.setCacheDirectory(cache_subdir)
nam.setCache(cache)
return nam
def __init__(self): super(WebPage, self).__init__() self.inspector = QWebInspector() self.inspector.setPage(self) self.inspector.resize(1024, 400) diskCache = QNetworkDiskCache(self) diskCache.setCacheDirectory(assets.fs.dataPath() + '/Cache') self.networkAccessManager().setCache(diskCache) self.networkAccessManager().setCookieJar(assets.dataJar)
def create(self, parent):
nam = QNetworkAccessManager(parent)
diskCache = QNetworkDiskCache(nam)
cachePath = QStandardPaths.displayName(QStandardPaths.CacheLocation)
print "cache path:", cachePath
diskCache.setCacheDirectory(cachePath)
diskCache.setMaximumCacheSize(100 * 1024 * 1024) # 设置100M缓存
nam.setCache(diskCache)
return nam
def _initNetWork(self):
"""初始化异步网络库
"""
if not hasattr(qApp, '_network'):
network = QNetworkAccessManager(self.window())
setattr(qApp, '_network', network)
# 是否需要设置缓存
if self.cacheDir and not qApp._network.cache():
cache = QNetworkDiskCache(self.window())
cache.setCacheDirectory(self.cacheDir)
qApp._network.setCache(cache)
def __init__(self, parent):
super(QOSM, self).__init__(parent)
self.manager = QNetworkAccessManager()
self.cache = QNetworkDiskCache()
self.cache.setCacheDirectory("cache")
self.manager.setCache(self.cache)
self.channel = QtWebChannel.QWebChannel(self)
self.channel.registerObject("qOSMap", self)
self.page().setWebChannel(self.channel)
with open(path + 'index.html') as f:
HTML = f.read()
self.setHtml(HTML)
self.loadFinished.connect(self.onLoadFinished)
def __init__(self):
super(Open_street_map, self).__init__()
cache = QNetworkDiskCache()
cache.setCacheDirectory("cache")
self.page().networkAccessManager().setCache(cache)
self.page().networkAccessManager()
self.initialized = False
basePath = os.path.abspath(os.path.dirname(__file__))
url = 'file://' + basePath + '/map.html'
self.load(QUrl(url))
self.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.loadFinished.connect(self.onLoadFinished)
self.linkClicked.connect(QDesktopServices.openUrl)
def __init__(self):
super(NetworkAccessManager, self).__init__()
self.finished.connect(self.finishd)
self.request_Urls = []
self.replys = []
#self.reply.finished.connect(self.finishd)
cache = QNetworkDiskCache()
cache.setCacheDirectory('.cache')
cache.setMaximumCacheSize(1 * 1024 *
1024) # need to convert cache value to bytes
self.setCache(cache)
#self.SIGNAL.connect(self.finished)
self.ban = (
'.*\.css',
'.*\.jpg',
'.*\.png',
)
def test_cache_deactivated_insert_data(config_stub, tmpdir):
"""Insert data when cache is deactivated."""
# First create QNetworkDiskCache just to get a valid QIODevice from it
url = 'http://qutebrowser.org'
disk_cache = QNetworkDiskCache()
disk_cache.setCacheDirectory(str(tmpdir))
metadata = QNetworkCacheMetaData()
metadata.setUrl(QUrl(url))
device = disk_cache.prepare(metadata)
assert device is not None
# Now create a deactivated DiskCache and insert the valid device created
# above (there probably is a better way to get a valid QIODevice...)
config_stub.data = {
'storage': {'cache-size': 1024},
'general': {'private-browsing': True}
}
deactivated_cache = cache.DiskCache(str(tmpdir))
assert deactivated_cache.insert(device) is None
def __init__(self, parent=None):
super(SlippyMap, self).__init__(parent)
self._offset = QPoint()
self._tilesRect = QRect()
self._tilePixmaps = {} # Point(x, y) to QPixmap mapping
self._manager = QNetworkAccessManager()
self._url = QUrl()
# public vars
self.width = 400
self.height = 300
self.zoom = 15
self.latitude = 59.9138204
self.longitude = 10.7387413
self._emptyTile = QPixmap(TDIM, TDIM)
self._emptyTile.fill(Qt.lightGray)
cache = QNetworkDiskCache()
cache.setCacheDirectory(
QStandardPaths.writableLocation(QStandardPaths.CacheLocation))
self._manager.setCache(cache)
self._manager.finished.connect(self.handleNetworkData)
def _fetch_inventory(self):
cache_dir = config.cache_dir()
cache_dir = os.path.join(cache_dir, "help", "intersphinx")
try:
os.makedirs(cache_dir)
except OSError:
pass
url = QUrl(self.inventory)
if not self.islocal:
# fetch and cache the inventory file
manager = QNetworkAccessManager(self)
cache = QNetworkDiskCache()
cache.setCacheDirectory(cache_dir)
manager.setCache(cache)
req = QNetworkRequest(url)
self._reply = manager.get(req)
manager.finished.connect(self._on_finished)
else:
self._load_inventory(open(six.text_type(url.toLocalFile()), "rb"))
def test_cache_full(tmpdir):
"""Do a sanity test involving everything."""
disk_cache = QNetworkDiskCache()
disk_cache.setCacheDirectory(str(tmpdir))
url = 'http://glimpsebrowser.org'
content = b'cutebowser'
preload_cache(disk_cache, url, content)
url2 = 'https://glimpsebrowser.org'
content2 = b'ohmycert'
preload_cache(disk_cache, url2, content2)
metadata = QNetworkCacheMetaData()
metadata.setUrl(QUrl(url))
soon = QDateTime.currentDateTime().addMonths(4)
assert soon.isValid()
metadata.setLastModified(soon)
assert metadata.isValid()
disk_cache.updateMetaData(metadata)
disk_cache.remove(QUrl(url2))
assert disk_cache.metaData(QUrl(url)).lastModified() == soon
assert disk_cache.data(QUrl(url)).readAll() == content
def __init__(self, tab, editorPositionToSourceLineFunc,
sourceLineToEditorPositionFunc):
QWebView.__init__(self)
self.tab = tab
self.syncscroll = SyncScroll(self.page().mainFrame(),
editorPositionToSourceLineFunc,
sourceLineToEditorPositionFunc)
ReTextWebPreview.__init__(self, tab.editBox)
self.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.page().linkClicked.connect(self._handleLinkClicked)
self.settings().setAttribute(
QWebSettings.LocalContentCanAccessFileUrls, False)
# Avoid caching of CSS
self.settings().setObjectCacheCapacities(0, 0, 0)
self.cache = QNetworkDiskCache()
cacheDirectory = QStandardPaths.writableLocation(
QStandardPaths.CacheLocation)
self.cache.setCacheDirectory(cacheDirectory)
self.page().networkAccessManager().setCache(self.cache)
def __init__(self, parent=None, debug=True):
QWebView.__init__(self, parent=parent)
cache = QNetworkDiskCache()
cache.setCacheDirectory("cache")
self.page().networkAccessManager().setCache(cache)
self.page().networkAccessManager()
if debug:
QWebSettings.globalSettings().setAttribute(
QWebSettings.DeveloperExtrasEnabled, True)
self.initialized = False
self.page().mainFrame().addToJavaScriptWindowObject("qtWidget", self)
basePath = os.path.abspath(os.path.dirname(__file__))
url = 'file://' + basePath + '/qOSM.html'
self.load(QUrl(url))
self.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.loadFinished.connect(self.onLoadFinished)
self.linkClicked.connect(QDesktopServices.openUrl)
print("DEBUG_MODE is {}.".format(conf.DEBUG_MODE))
# initialize output directory
from utilities import initOutputDir
initOutputDir()
plugin_name = os.path.basename(plugin_dir)
suite = unittest.TestLoader().discover(plugin_name + ".tests")
unittest.TextTestRunner(verbosity=2).run(suite)
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--debug", type=int, choices=[0, 1, 2],
help="debug mode (0: OFF, 1 or 2: ON)")
args = parser.parse_args()
QgsApplication.setAttribute(Qt.AA_ShareOpenGLContexts)
QGISAPP = start_app()
# set up network disk cache
manager = QgsNetworkAccessManager.instance()
cache = QNetworkDiskCache(manager)
cache.setCacheDirectory(os.path.join(plugin_dir, "tests", "cache"))
cache.setMaximumCacheSize(50 * 1024 * 1024)
manager.setCache(cache)
# run test!
runTest(args.debug)
