qgstestutils.cpp

Go to the documentation of this file.

/***************************************************************************
                                  qgstestutils.cpp
                              --------------------
    begin                : January 2018
    copyright            : (C) 2018 by Nyall Dawson
    email                : nyall.dawson@gmail.com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgstestutils.h"
 
#include <atomic>
 
#include "qgsconnectionpool.h"
#include "qgsprovidermetadata.h"
#include "qgsproviderregistry.h"
#include "qgsprovidersublayerdetails.h"
#include "qgsvectordataprovider.h"
#include "qgsvectorlayer.h"
 
#include <QCryptographicHash>
#include <QDeadlineTimer>
#include <QString>
#include <QThread>
#include <QtConcurrentMap>
 
using namespace Qt::StringLiterals;

 
static void getFeaturesForProvider( const QPair< std::shared_ptr< QgsAbstractFeatureSource >, QgsFeatureRequest > &pair )
{
  QgsFeatureIterator it = pair.first->getFeatures( pair.second );
  QgsFeature f;
  while ( it.nextFeature( f ) )
  {
  }
}
 
bool QgsTestUtils::testProviderIteratorThreadSafety( QgsVectorDataProvider *provider, const QgsFeatureRequest &request )
{
  constexpr int JOBS_TO_RUN = 100;
  QList< QPair< std::shared_ptr< QgsAbstractFeatureSource >, QgsFeatureRequest > > jobs;
  jobs.reserve( JOBS_TO_RUN );
  for ( int i = 0; i < JOBS_TO_RUN; ++i )
  {
    jobs.append( qMakePair( std::shared_ptr< QgsAbstractFeatureSource >( provider->featureSource() ), request ) );
  }
 
  //freaking hammer the provider with a ton of concurrent requests.
  //thread unsafe providers... you better be ready!!!!
  QtConcurrent::blockingMap( jobs, getFeaturesForProvider );
 
  return true;
}
 
bool QgsTestUtils::compareDomElements( const QDomElement &element1, const QDomElement &element2 )
{
  QString tag1 = element1.tagName();
  tag1.replace( QRegularExpression( ".*:" ), QString() );
  QString tag2 = element2.tagName();
  tag2.replace( QRegularExpression( ".*:" ), QString() );
  if ( tag1 != tag2 )
  {
    qDebug( "Different tag names: %s, %s", tag1.toLatin1().data(), tag2.toLatin1().data() );
    return false;
  }
 
  if ( element1.hasAttributes() != element2.hasAttributes() )
  {
    qDebug( "Different hasAttributes: %s, %s", tag1.toLatin1().data(), tag2.toLatin1().data() );
    return false;
  }
 
  if ( element1.hasAttributes() )
  {
    const QDomNamedNodeMap attrs1 = element1.attributes();
    const QDomNamedNodeMap attrs2 = element2.attributes();
 
    if ( attrs1.size() != attrs2.size() )
    {
      qDebug( "Different attributes size: %s, %s", tag1.toLatin1().data(), tag2.toLatin1().data() );
      return false;
    }
 
    for ( int i = 0; i < attrs1.size(); ++i )
    {
      const QDomNode node1 = attrs1.item( i );
      const QDomAttr attr1 = node1.toAttr();
 
      if ( !element2.hasAttribute( attr1.name() ) )
      {
        qDebug( "Element2 has not attribute: %s, %s, %s", tag1.toLatin1().data(), tag2.toLatin1().data(), attr1.name().toLatin1().data() );
        return false;
      }
 
      if ( element2.attribute( attr1.name() ) != attr1.value() )
      {
        qDebug( "Element2 attribute has not the same value: %s, %s, %s", tag1.toLatin1().data(), tag2.toLatin1().data(), attr1.name().toLatin1().data() );
        return false;
      }
    }
  }
 
  if ( element1.hasChildNodes() != element2.hasChildNodes() )
  {
    qDebug( "Different childNodes: %s, %s", tag1.toLatin1().data(), tag2.toLatin1().data() );
    return false;
  }
 
  if ( element1.hasChildNodes() )
  {
    const QDomNodeList nodes1 = element1.childNodes();
    const QDomNodeList nodes2 = element2.childNodes();
 
    if ( nodes1.size() != nodes2.size() )
    {
      qDebug( "Different childNodes size: %s, %s", tag1.toLatin1().data(), tag2.toLatin1().data() );
      return false;
    }
 
    for ( int i = 0; i < nodes1.size(); ++i )
    {
      const QDomNode node1 = nodes1.at( i );
      const QDomNode node2 = nodes2.at( i );
      if ( node1.isElement() && node2.isElement() )
      {
        QDomElement elt1 = node1.toElement();
        QDomElement elt2 = node2.toElement();
 
        if ( !compareDomElements( elt1, elt2 ) )
          return false;
      }
      else if ( node1.isText() && node2.isText() )
      {
        const QDomText txt1 = node1.toText();
        const QDomText txt2 = node2.toText();
 
        if ( txt1.data() != txt2.data() )
        {
          qDebug( "Different text data: %s %s", tag1.toLatin1().data(), txt1.data().toLatin1().data() );
          qDebug( "Different text data: %s %s", tag2.toLatin1().data(), txt2.data().toLatin1().data() );
          return false;
        }
      }
    }
  }
 
  if ( element1.text() != element2.text() )
  {
    qDebug( "Different text: %s %s", tag1.toLatin1().data(), element1.text().toLatin1().data() );
    qDebug( "Different text: %s %s", tag2.toLatin1().data(), element2.text().toLatin1().data() );
    return false;
  }
 
  return true;
}
 
QString QgsTestUtils::sanitizeFakeHttpEndpoint( const QString &urlString )
{
  QString modifiedUrlString = urlString;
 
  // For REST API using URL subpaths, normalize the subpaths
  const int afterEndpointStartPos = static_cast<int>( modifiedUrlString.indexOf( "fake_qgis_http_endpoint" ) + strlen( "fake_qgis_http_endpoint" ) );
  QString afterEndpointStart = modifiedUrlString.mid( afterEndpointStartPos );
  afterEndpointStart.replace( "/"_L1, "_"_L1 );
  modifiedUrlString = modifiedUrlString.mid( 0, afterEndpointStartPos ) + afterEndpointStart;
 
  const qsizetype posQuotationMark = modifiedUrlString.indexOf( '?' );
  QString args = modifiedUrlString.mid( posQuotationMark );
  if ( modifiedUrlString.size() > 256 )
  {
    args.replace( '/', '_' );
    args = QCryptographicHash::hash( args.toUtf8(), QCryptographicHash::Md5 ).toHex();
  }
  else
  {
    args.replace( '?', '_' );
    args.replace( '&', '_' );
    args.replace( '<', '_' );
    args.replace( '>', '_' );
    args.replace( '\"', '_' );
    args.replace( '\'', '_' );
    args.replace( ' ', '_' );
    args.replace( ':', '_' );
    args.replace( '/', '_' );
    args.replace( '\n', '_' );
  }
  return modifiedUrlString.mid( 0, posQuotationMark ) + args;
}
 
// anonymous namespace to avoid potential symbol collisions
namespace
{

  class LayerOpenWorker : public QThread
  {
    public:
      LayerOpenWorker( const QString &uri, const QString &providerKey, std::atomic<bool> &stop )
        : mUri( uri )
        , mProviderKey( providerKey )
        , mStop( stop )
      {}
 
      void run() override
      {
        while ( !mStop )
        {
          mLoops++;
          const QgsVectorLayer layer( mUri, u"concurrent_access_worker"_s, mProviderKey );
          if ( !layer.isValid() )
            continue;
          mValidOpens++;
          QgsFeature f;
          layer.getFeatures().nextFeature( f );
        }
      }
 
      int loops() const { return mLoops; }
      int validOpens() const { return mValidOpens; }
 
    private:
      QString mUri;
      QString mProviderKey;
      std::atomic<bool> &mStop;
      int mLoops = 0;
      int mValidOpens = 0;
  };

  class SublayerQueryWorker : public QThread
  {
    public:
      SublayerQueryWorker( QgsProviderMetadata *metadata, const QString &uri, int expectedSublayerCount, std::atomic<bool> &stop )
        : mMetadata( metadata )
        , mUri( uri )
        , mExpectedSublayerCount( expectedSublayerCount )
        , mStop( stop )
      {}
 
      void run() override
      {
        while ( !mStop )
        {
          mLoops++;
          if ( mMetadata->querySublayers( mUri ).size() == mExpectedSublayerCount )
            mConsistentQueries++;
        }
      }
 
      int loops() const { return mLoops; }
      int consistentQueries() const { return mConsistentQueries; }
 
    private:
      QgsProviderMetadata *mMetadata = nullptr;
      QString mUri;
      int mExpectedSublayerCount = 0;
      std::atomic<bool> &mStop;
      int mLoops = 0;
      int mConsistentQueries = 0;
  };
 
} // namespace
 
bool QgsTestUtils::testConcurrentLayerAccess( const QString &uri, const QString &providerKey, int runTimeMs, int timeoutMs )
{
  constexpr int LAYER_WORKER_COUNT = 6;
 
  QgsProviderMetadata *metadata = QgsProviderRegistry::instance()->providerMetadata( providerKey );
  if ( !metadata )
  {
    qDebug( "testConcurrentLayerAccess: no provider metadata found for %s", providerKey.toLatin1().constData() );
    return false;
  }
 
  // single-threaded baseline results: concurrent access must give the same
  // answers
  const bool expectValidLayer = QgsVectorLayer( uri, u"concurrent_access_baseline"_s, providerKey ).isValid();
  const int expectedSublayerCount = static_cast<int>( metadata->querySublayers( uri ).size() );
 
  std::atomic<bool> stop( false );
  std::vector<std::unique_ptr<QThread>> threads;
 
  std::vector<LayerOpenWorker *> layerWorkers;
  for ( int i = 0; i < LAYER_WORKER_COUNT; i++ )
  {
    layerWorkers.push_back( new LayerOpenWorker( uri, providerKey, stop ) );
    threads.emplace_back( layerWorkers.back() );
  }
 
  SublayerQueryWorker *sublayerWorker = new SublayerQueryWorker( metadata, uri, expectedSublayerCount, stop );
  threads.emplace_back( sublayerWorker );
 
  for ( auto &thread : threads )
    thread->start();
 
  // let all threads contend for a fixed time window, then ask them to stop
  QThread::msleep( static_cast<unsigned long>( runTimeMs ) );
  stop = true;
 
  // Use a single shared deadline across all threads: if a deadlock occurs, some
  // threads will never return from wait(). A per-thread timeout would reset the
  // clock for each thread, allowing an arbitrarily long hang to go undetected.
  QDeadlineTimer deadline( timeoutMs );
  bool allFinished = true;
  for ( auto &thread : threads )
    allFinished = thread->wait( deadline ) && allFinished;
 
  if ( !allFinished )
  {
    // deliberately leak the thread objects: some threads are deadlocked and
    // destroying a still-running QThread is a fatal error which would mask
    // the failure report
    for ( auto &thread : threads )
      ( void ) thread.release();
    qDebug(
      "testConcurrentLayerAccess: deadlock detected, not all threads "
      "accessing %s finished in time",
      uri.toLatin1().constData()
    );
    return false;
  }
 
  bool ok = true;
  for ( const LayerOpenWorker *worker : layerWorkers )
  {
    if ( worker->loops() == 0 )
    {
      qDebug(
        "testConcurrentLayerAccess: a layer open worker did not complete "
        "a single loop"
      );
      ok = false;
    }
    if ( expectValidLayer && worker->validOpens() != worker->loops() )
    {
      qDebug(
        "testConcurrentLayerAccess: only %d of %d concurrent layer opens "
        "gave a valid layer",
        worker->validOpens(),
        worker->loops()
      );
      ok = false;
    }
  }
  if ( sublayerWorker->consistentQueries() != sublayerWorker->loops() )
  {
    qDebug(
      "testConcurrentLayerAccess: only %d of %d concurrent sublayer "
      "queries returned the expected %d sublayers",
      sublayerWorker->consistentQueries(),
      sublayerWorker->loops(),
      expectedSublayerCount
    );
    ok = false;
  }
  return ok;
}