webbrowser-app

Merge lp:~abreu-alexandre/webbrowser-app/fix-url-pattern-patching-overrides-and-google-patterns into lp:webbrowser-app

fix-url-pattern-patching-overrides-and-google-patterns
Merge into trunk

Proposed by Alexandre Abreu on 2014-03-06

Status:

Merged

Merged at revision:

471

Proposed branch:

lp:~abreu-alexandre/webbrowser-app/fix-url-pattern-patching-overrides-and-google-patterns

Merge into:

lp:webbrowser-app

Diff against target:

450 lines (+306/-46)

8 files modified

src/app/webcontainer/CMakeLists.txt (+1/-1)
src/app/webcontainer/WebApp.qml (+23/-5)
src/app/webcontainer/url-pattern-utils.cpp (+129/-0)
src/app/webcontainer/url-pattern-utils.h (+32/-0)
src/app/webcontainer/webapp-container.cpp (+11/-40)
tests/unittests/CMakeLists.txt (+1/-0)
tests/unittests/container-url-patterns/CMakeLists.txt (+10/-0)
tests/unittests/container-url-patterns/tst_ContainerUrlPatterns.cpp (+99/-0)

To merge this branch:

bzr merge lp:~abreu-alexandre/webbrowser-app/fix-url-pattern-patching-overrides-and-google-patterns

Undecided

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot	continuous-integration		Approve on 2014-03-20
Alberto Mardegan (community)		2014-03-07	Approve on 2014-03-10
David Barth		2014-03-07	Pending
Ubuntu Phablet Team		2014-03-06	Pending
Review via email: mp+209779@code.launchpad.net

Commit message

There are 2 ways for the webapp-container to receive a list of patterns to filter url browsing in a webapp container: through the manifest.json file that comes with a given (named) webapp, or through the command line.

At the moment, the 2 mechanisms are exclusive in the sense that from the webapp-container's perspective it only considers one or another when filtering navigation (the webapp manifest one being preferred) but they are NOT semantically equivalent. The list of url patterns in the manifest.json file is use as a mean to filter the urls that are being browsed to, but ALSO in the chromium & FF browsers to know if a webapp is to be installed/enabled when browsing in a given url.

For example, for Gmail, the hostname mail.google.com is used as a trigger to ask the user for an installation/enablement of a webapp in the browser. It is also implicitely used as a filter for browser once in the container.

The issue is that for applications like google services, the authentication mechanism is common. So when launched in the container, the user will be redirected to e.g. https://accounts.google.com or https://accounts.google.ca, etc.

So, the manifest.json cannot be modified to account for those, since we dont want to install a webapp from those URLs but we need a way to add extra navigation url patterns to allow google service webapps to be redirected to e.g. https://accounts.google.* etc.

We provide here 2 things:

- an way for the url patterns passed down from the command line to be also considered in the navigation filtering,
- a way to simplify url patterns for google apps

Description of the change

We provide here 2 things:

- an way for the url patterns passed down from the command line to be also considered in the navigation filtering,
- a way to simplify url patterns for google apps

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-03-06:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/webbrowser-app-ci/621/rebuild

review: Approve (continuous-integration)

lp:~abreu-alexandre/webbrowser-app/fix-url-pattern-patching-overrides-and-google-patterns updated on 2014-03-07

456. By Launchpad Translations on behalf of phablet-team on 2014-03-07: Launchpad automatic translations update.

Revision history for this message

Alberto Mardegan (mardy) wrote on 2014-03-07:

L9: semicolon :-p

L36, L45: you could avoid the ugly "action === WebView.IgnoreRequest" check if you return on line 36.

L90: what about google.co.uk and similar ones?

review: Needs Information

Revision history for this message

Alexandre Abreu (abreu-alexandre) wrote on 2014-03-07:

> L9: semicolon :-p
>

done

> L36, L45: you could avoid the ugly "action === WebView.IgnoreRequest" check if
> you return on line 36.
>

right, done

> L90: what about google.co.uk and similar ones?

those will have to be handled manually, which is IMO fine since they are a
substantially smaller subset. I dont want them explicitely listed
here, and I dont want to allow an extra '.' (or something like that)
in the TLD position since it is a mega-security issue.

Revision history for this message

Alberto Mardegan (mardy) wrote on 2014-03-07:

Looks good to me. Could you please tell me the steps to reproduce the existing bug, or should I simply limit myself to verify that Google+ (for example) works as a webapp after visiting the site with Firefox?

review: Needs Information

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-03-07:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/webbrowser-app-ci/622/rebuild

review: Approve (continuous-integration)

Revision history for this message

Alexandre Abreu (abreu-alexandre) wrote on 2014-03-10:

Testing:

- the non exclusive pattern filtering:

1. Make sure that you have a webapp installed. e.g. (Twitter).
Launch the webapp from the command line

./webapp-container --webapp='VHdpdHRlcg==' --enable-addressbar

You then should be allowed to only browse to twitter but not to any other website.
You have access to the address bar which then allows you to test browsing to various
websites. You can make sure that browsing to non twitter websites opens the url
in the default webbrowser e.g.

webapp-container --webapp='VHdpdHRlcg==' --enable-addressbar --webappUrlPatterns=https?://*.facebook.com/*

- The google pattern special case.

1. Make sure that the wrong patterns are not allowed, e.g. http://*.google.*/* (you should see a stdout message like "Ignoring empty or invalid webapp URL pattern: "https?://*.google.*/*""), or http://*.go?ogle.*/*,

2. Launch

webapp-container --webapp='VHdpdHRlcg==' --enable-addressbar --webappUrlPatterns=https?://www.google.*/*

Make sure you can browse to: https://www.google.it, https://www.google.fr, https://www.google.ca, etc.

but not to e.g. https://mail.google.com

Revision history for this message

Alberto Mardegan (mardy) wrote on 2014-03-10:

> Testing:
>
> - the non exclusive pattern filtering:
>
> 1. Make sure that you have a webapp installed. e.g. (Twitter).
> Launch the webapp from the command line
[...]

Tested, works fine (both with the --webappUrlPatterns parameter and without).

> - The google pattern special case.
>
> 1. Make sure that the wrong patterns are not allowed, e.g. http://*.google.*/*
> (you should see a stdout message like "Ignoring empty or invalid webapp URL
> pattern: "https?://*.google.*/*""), or http://*.go?ogle.*/*,

Tested, works fine.

> 2. Launch
>
> webapp-container --webapp='VHdpdHRlcg==' --enable-addressbar
> --webappUrlPatterns=https?://www.google.*/*
>
> Make sure you can browse to: https://www.google.it, https://www.google.fr,
> https://www.google.ca, etc.
>
> but not to e.g. https://mail.google.com

I can visit all of the sites, including mail.google.com and apple.com. I don't see the message about the URL pattern being invalid, so I wonder why it lets me visit those...

Revision history for this message

Alexandre Abreu (abreu-alexandre) wrote on 2014-03-10:

> > but not to e.g. https://mail.google.com
>
> I can visit all of the sites, including mail.google.com and apple.com. I don't
> see the message about the URL pattern being invalid, so I wonder why it lets
> me visit those...

you need https://code.launchpad.net/~abreu-alexandre/webbrowser-app/fix-broken-webapp-patterns

Revision history for this message

Alberto Mardegan (mardy) wrote on 2014-03-10:

> you need https://code.launchpad.net/~abreu-alexandre/webbrowser-app/fix-
> broken-webapp-patterns

Indeed. With that branch, everything works fine.

review: Approve

lp:~abreu-alexandre/webbrowser-app/fix-url-pattern-patching-overrides-and-google-patterns updated on 2014-03-12

457. By Launchpad Translations on behalf of phablet-team on 2014-03-11: Launchpad automatic translations update.
458. By Launchpad Translations on behalf of phablet-team on 2014-03-12: Launchpad automatic translations update.

Revision history for this message

Olivier Tilloy (osomon) wrote on 2014-03-13:

How about adding some unit tests for isValidGoogleUrlPattern()?

Revision history for this message

Alexandre Abreu (abreu-alexandre) wrote on 2014-03-13:

> How about adding some unit tests for isValidGoogleUrlPattern()?

yup, its in the works already, ...

lp:~abreu-alexandre/webbrowser-app/fix-url-pattern-patching-overrides-and-google-patterns updated on 2014-03-19

459. By Timo Jyrinki on 2014-03-13

Apply the revert that is in archives now, and rebuild against Qt 5.2.1

460. By PS Jenkins bot on 2014-03-13

Releasing 0.23+14.04.20140313-0ubuntu1

461. By Olivier Tilloy on 2014-03-17

Do not register private types in the public plugin.
Register them in the webbrowser application scope instead.

I have made sure that private types that were previously public are currently not being used by any application in the store, so this refactoring is safe.

462. By Leo Arias on 2014-03-17

Updated the copyright header on all the python files.

463. By Adnane Belmadiaf on 2014-03-17

Fix to open URL that start with / (local files)

464. By Olivier Tilloy on 2014-03-17

Refactor the test HTTP server to use a random port at startup.

465. By PS Jenkins bot on 2014-03-17

Releasing 0.23+14.04.20140317-0ubuntu1

466. By Colin Watson on 2014-03-17

Add multiarch annotations.

467. By PS Jenkins bot on 2014-03-17

Releasing 0.23+14.04.20140317.1-0ubuntu1

468. By Olivier Tilloy on 2014-03-19

Use the renderer only once when rendering a thumbnail.
This seems to fix the crash that was happening at destruction time. Fixes: 1294219

469. By PS Jenkins bot on 2014-03-19

Releasing 0.23+14.04.20140319-0ubuntu1

Revision history for this message

Alexandre Abreu (abreu-alexandre) wrote on 2014-03-20:

Updated w/ some unit tests

lp:~abreu-alexandre/webbrowser-app/fix-url-pattern-patching-overrides-and-google-patterns updated on 2014-03-20

470. By Alexandre Abreu on 2014-03-20: Merge trunk

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-03-20:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/webbrowser-app-ci/655/rebuild

review: Approve (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Alexandre Abreu

Ubuntu Phablet Team

to status/vote changes:

Rachel Liu

 === modified file 'src/app/webcontainer/CMakeLists.txt'
 --- src/app/webcontainer/CMakeLists.txt	2014-03-14 14:51:22 +0000
 +++ src/app/webcontainer/CMakeLists.txt	2014-03-20 18:17:38 +0000
@@ -10,6 +10,7 @@
  set(WEBAPP_CONTAINER_SRC
      webapp-container.cpp
++    url-pattern-utils.cpp
+ )
  add_executable(${WEBAPP_CONTAINER} ${WEBAPP_CONTAINER_SRC})
@@ -25,4 +26,3 @@
  install(FILES ${QML_FILES} DESTINATION ${CMAKE_INSTALL_DATADIR}/webbrowser-app/webcontainer)
  install(DIRECTORY actions DESTINATION ${CMAKE_INSTALL_DATADIR}/webbrowser-app/webcontainer
          FILES_MATCHING PATTERN *.qml)
--
 === modified file 'src/app/webcontainer/WebApp.qml'
 --- src/app/webcontainer/WebApp.qml	2014-03-12 11:40:03 +0000
 +++ src/app/webcontainer/WebApp.qml	2014-03-20 18:17:38 +0000
@@ -84,23 +84,40 @@
+                 }
+             }
++            function haveValidUrlPatterns() {
++                return webappUrlPatterns && webappUrlPatterns.length !== 0
++            }
++
              function navigationRequestedDelegate(request) {
                  if (!request.isMainFrame) {
                      request.action = WebView.AcceptRequest
                      return
+                 }
--                var action = WebView.AcceptRequest
++                // Pass-through if we are not running as a named webapp (--webapp='Gmail')
++                // or if we dont have a list of url patterns specified to filter the
++                // browsing actions
++                if ( ! haveValidUrlPatterns() && ! isRunningAsANamedWebapp()) {
++                    request.action = WebView.AcceptRequest
++                    return
++                }
++
++                var action = WebView.IgnoreRequest
                  var url = request.url.toString()
                  // The list of url patterns defined by the webapp takes precedence over command line
                  if (isRunningAsANamedWebapp()) {
                      if (unityWebapps.model.exists(unityWebapps.name) &&
--                        !unityWebapps.model.doesUrlMatchesWebapp(unityWebapps.name, url)) {
--                        action = WebView.IgnoreRequest
++                        unityWebapps.model.doesUrlMatchesWebapp(unityWebapps.name, url)) {
++                        request.action = WebView.AcceptRequest
++                        return;
+                     }
--                } else if (webappUrlPatterns && webappUrlPatterns.length !== 0) {
--                    action = WebView.IgnoreRequest
++                }
++
++                // We still take the possible additional patterns specified in the command line
++                // (the in the case of finer grained ones specifically for the container and not
++                // as an 'install source' for the webapp).
++                if (webappUrlPatterns && webappUrlPatterns.length !== 0) {
                      for (var i = 0; i < webappUrlPatterns.length; ++i) {
                          var pattern = webappUrlPatterns[i]
                          if (url.match(pattern)) {
@@ -112,6 +129,7 @@
                  request.action = action
                  if (action === WebView.IgnoreRequest) {
++                    console.debug('Opening: ' + url + ' in the browser window.')
                      Qt.openUrlExternally(url)
+                 }
+             }
 === added file 'src/app/webcontainer/url-pattern-utils.cpp'
 --- src/app/webcontainer/url-pattern-utils.cpp	1970-01-01 00:00:00 +0000
 +++ src/app/webcontainer/url-pattern-utils.cpp	2014-03-20 18:17:38 +0000
@@ -0,0 +1,129 @@
++/*
++ * Copyright 2014 Canonical Ltd.
++ *
++ * This file is part of webbrowser-app.
++ *
++ * webbrowser-app 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; version 3.
++ *
++ * webbrowser-app is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "url-pattern-utils.h"
++
++#include <QtCore/QRegularExpression>
++
++
++/**
++ * Tests for the validity of a given webapp url pattern. It follows
++ *  the following grammar:
++ *
++ * <url-pattern> := <scheme>://<host><path>
++ * <scheme> := 'http' | 'https'
++ * <host> := '*' <any char except '/' and '.'>+ <hostpart> <hostpart>+
++ * <hostpart> := '.' <any char except '/', '*', '?' and '.'>+
++ * <path> := '/' <any chars>
++ *
++ * @param pattern pattern that is to be tested for validity
++ * @return true if the url is valid, false otherwise
++ */
++static bool isValidWebappUrlPattern(const QString& pattern)
++{
++    static QRegularExpression grammar("^http(s|s\\?)?://[^\\.]+\\.[^\\.\\*\\?]+\\.[^\\.\\*\\?]+(\\.[^\\.\\*\\?/]+)*/.*$");
++    return grammar.match(pattern).hasMatch();
++}
++
++/**
++ * A Google related webapp is treated very specifically. The issue
++ * with those Google service related webapps is that the all rely
++ * on a common authentication mechanism and one endup being redirected
++ * to the auth urls automatically when needed.
++ * Most of the redirections can be match against discrete url patterns
++ * but there is always a country dependant step in the auth patterns, e.g.
++ * https://accounts.google.com/* or https://accounts.google.ca/* etc.
++ *
++ * Since by default we dont allow a wildcard in the TLD position, the only
++ * solution then is to manually enter the list of top level country related
++ * domains.
++ * In this context, we isolate the Google case, with a more restricted set of patterns
++ * that should adhere to the following grammar:
++ *
++ * <url-pattern> := <scheme>://<host><path>
++ * <scheme> := 'http' | 'https'
++ * <host> := <any char except '/', '*', '?' and '.'>+ '.google' <hostpart>
++ * <hostpart> := '.' <any char except '/', '?' and '.'>+
++ * <path> := '/' <any chars>
++ *
++ * So for example we allow 'https://accounts.google.* /' but not 'https://*.google.* /'
++ * (the spaces are there to avoid the confusion w/ a end of comment token.
++ *
++ * IMPORTAN NOTE: the '*' wildcard in the TLD position is not a REAL wildcard in the
++ * sense that it corresponds to [^\\./], so it wont match ('google.com.evildomain') as usual.
++ *
++ * @param pattern pattern that is to be tested for validity
++ * @return true if the url is valid, false otherwise
++ */
++static bool isValidGoogleUrlPattern(const QString& pattern)
++{
++    static QRegularExpression grammar("^http(s|s\\?)?://[^\\.\\?\\*]+\\.google\\.[^\\.\\?]+/.*$");
++    return grammar.match(pattern).hasMatch();
++}
++
++
++QString UrlPatternUtils::transformWebappSearchPatternToSafePattern(const QString& pattern)
++{
++    QString transformedPattern;
++
++    if (isValidWebappUrlPattern(pattern)) {
++
++        QRegularExpression urlRe("(.+://)([^/]+)(.+)");
++        QRegularExpressionMatch match = urlRe.match(pattern);
++
++        if (match.hasMatch())
++        {
++            // We make a distinction between the wildcard found in the
++            //  hostname part and the one found later. The former being more
++            //  restricted and should not be replaced by the same regexp pattern
++            //  as the latter.
++            // A less restrictive hostname pattern might lead to the following
++            //  situation where e.g.
++            // http://bady.guy.com/phishing.ebay.com/
++            // matches
++            // https?://*.ebay.com/*
++            QString scheme = match.captured(1);
++            QString hostname = match.captured(2).replace("*", "[^\\./]*");
++            QString tail = match.captured(3).replace("*", "[^\\s]*");
++
++            // reconstruct
++            transformedPattern = QString("%1%2%3").arg(scheme).arg(hostname).arg(tail);
++        }
++    } else if (isValidGoogleUrlPattern(pattern)) {
++
++        QRegularExpression urlRe("(.+://)([^\\./]+\\.google\\.)([^/]+)(.+)");
++        QRegularExpressionMatch match = urlRe.match(pattern);
++
++        if (match.hasMatch())
++        {
++            QString scheme = match.captured(1);
++            QString hostname = match.captured(2);
++            QString tld = match.captured(3).replace("*", "[^\\./]*");
++            QString tail = match.captured(4).replace("*", "[^\\s]*");
++
++            // reconstruct
++            transformedPattern = QString("%1%2%3%4")
++                                    .arg(scheme)
++                                    .arg(hostname)
++                                    .arg(tld)
++                                    .arg(tail);
++        }
++    }
++
++    return transformedPattern;
++}
 === added file 'src/app/webcontainer/url-pattern-utils.h'
 --- src/app/webcontainer/url-pattern-utils.h	1970-01-01 00:00:00 +0000
 +++ src/app/webcontainer/url-pattern-utils.h	2014-03-20 18:17:38 +0000
@@ -0,0 +1,32 @@
++/*
++ * Copyright 2014 Canonical Ltd.
++ *
++ * This file is part of webbrowser-app.
++ *
++ * webbrowser-app 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; version 3.
++ *
++ * webbrowser-app is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef URLPATTERNUTILS_H
++#define URLPATTERNUTILS_H
++
++#include <QtCore/QString>
++
++
++namespace UrlPatternUtils {
++
++QString transformWebappSearchPatternToSafePattern(const QString&);
++
++}
++
++
++#endif // URLPATTERNUTILS_H
 === modified file 'src/app/webcontainer/webapp-container.cpp'
 --- src/app/webcontainer/webapp-container.cpp	2014-03-06 13:32:21 +0000
 +++ src/app/webcontainer/webapp-container.cpp	2014-03-20 18:17:38 +0000
@@ -19,6 +19,8 @@
  #include "config.h"
  #include "webapp-container.h"
++#include "url-pattern-utils.h"
++
  // Qt
  #include <QtCore/QCoreApplication>
  #include <QtCore/QDebug>
@@ -105,25 +107,6 @@
      return QString();
+ }
--/**
-- * Tests for the validity of a given webapp url pattern. It follows
-- *  the following grammar:
-- *
-- * <url-pattern> := <scheme>://<host><path>
-- * <scheme> := 'http' | 'https'
-- * <host> := '*' <any char except '/' and '.'>+ <hostpart> <hostpart>+
-- * <hostpart> := '.' <any char except '/', '*', '?' and '.'>+
-- * <path> := '/' <any chars>
-- *
-- * @param pattern pattern that is to be tested for validity
-- * @return true if the url is valid, false otherwise
-- */
--static bool isValidWebappUrlPattern(const QString& pattern)
--{
--    static QRegularExpression grammar("^http(s|s\\?)?://[^\\.]+\\.[^\\.\\*\\?]+\\.[^\\.\\*\\?]+(\\.[^\\.\\*\\?/]+)*/.*$");
--    return grammar.match(pattern).hasMatch();
--}
--
  QStringList WebappContainer::webappUrlPatterns() const
+ {
@@ -135,27 +118,15 @@
                  QStringList includePatterns = tail.split(",");
                  Q_FOREACH(const QString& includePattern, includePatterns) {
                      QString pattern = includePattern.trimmed();
--                    if (!pattern.isEmpty() && isValidWebappUrlPattern(pattern)) {
--                        QRegularExpression urlRe("(.+://)([^/]+)(.+)");
--                        QRegularExpressionMatch match = urlRe.match(pattern);
--                        if (match.hasMatch())
--                        {
--                            // We make a distinction between the wildcard found in the
--                            //  hostname part and the one found later. The former being more
--                            //  restricted and should not be replaced by the same regexp pattern
--                            //  as the latter.
--                            // A less restrictive hostname pattern might lead to the following
--                            //  situation where e.g.
--                            // http://bady.guy.com/phishing.ebay.com/
--                            // matches
--                            // https?://*.ebay.com/*
--                            QString scheme = match.captured(1);
--                            QString hostname = match.captured(2).replace("*", "[^\\./]*");
--                            QString tail = match.captured(3).replace("*", "[^\\s]*");
--
--                            // reconstruct
--                            patterns.append(QString("%1%2%3").arg(scheme).arg(hostname).arg(tail));
--                        }
++
++                    if (pattern.isEmpty())
++                        continue;
++
++                    QString safePattern =
++                            UrlPatternUtils::transformWebappSearchPatternToSafePattern(pattern);
++
++                    if ( ! safePattern.isEmpty()) {
++                        patterns.append(safePattern);
                      } else {
                          qDebug() << "Ignoring empty or invalid webapp URL pattern:" << pattern;
+                     }
 === modified file 'tests/unittests/CMakeLists.txt'
 --- tests/unittests/CMakeLists.txt	2013-11-12 22:18:49 +0000
 +++ tests/unittests/CMakeLists.txt	2014-03-20 18:17:38 +0000
@@ -8,3 +8,4 @@
  add_subdirectory(history-domainlist-chronological-model)
  add_subdirectory(tabs-model)
  add_subdirectory(bookmarks-model)
++add_subdirectory(container-url-patterns)
 === added directory 'tests/unittests/container-url-patterns'
 === added file 'tests/unittests/container-url-patterns/CMakeLists.txt'
 --- tests/unittests/container-url-patterns/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ tests/unittests/container-url-patterns/CMakeLists.txt	2014-03-20 18:17:38 +0000
@@ -0,0 +1,10 @@
++set(TEST tst_ContainerUrlPatterns)
++set(SOURCES
++    ${webapp-container_SOURCE_DIR}/url-pattern-utils.cpp
++    tst_ContainerUrlPatterns.cpp
++)
++add_executable(${TEST} ${SOURCES})
++include_directories(${webapp-container_SOURCE_DIR})
++qt5_use_modules(${TEST} Core Quick Test)
++add_test(${TEST} ${CMAKE_CURRENT_BINARY_DIR}/${TEST} -xunitxml -o ${TEST}.xml)
++set_tests_properties(${TEST} PROPERTIES ENVIRONMENT "QT_QPA_PLATFORM=minimal")
 === added file 'tests/unittests/container-url-patterns/tst_ContainerUrlPatterns.cpp'
 --- tests/unittests/container-url-patterns/tst_ContainerUrlPatterns.cpp	1970-01-01 00:00:00 +0000
 +++ tests/unittests/container-url-patterns/tst_ContainerUrlPatterns.cpp	2014-03-20 18:17:38 +0000
@@ -0,0 +1,99 @@
++/*
++ * Copyright 2014 Canonical Ltd.
++ *
++ * This file is part of webbrowser-app.
++ *
++ * webbrowser-app 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; version 3.
++ *
++ * webbrowser-app is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++// Qt
++#include <QtCore/QString>
++#include <QtTest/QtTest>
++
++// local
++#include "url-pattern-utils.h"
++
++class ContainerUrlPatternsTests : public QObject
++{
++    Q_OBJECT
++
++private Q_SLOTS:
++
++    void transformedUrlPatterns_data()
++    {
++        QTest::addColumn<QString>("pattern");
++        QTest::addColumn<QString>("transformedPattern");
++
++        // regular patterns
++
++        QTest::newRow("Valid pattern")
++                << "https?://*.mydomain.com/*"
++                << "https?://[^\\./]*.mydomain.com/[^\\s]*";
++
++#define WEBAPP_INVALID_URL_PATTERN_TEST(id,invalid_url_pattern) \
++        QTest::newRow("Invalid pattern " #id) \
++                << invalid_url_pattern \
++                << QString()
++
++        WEBAPP_INVALID_URL_PATTERN_TEST(1, "http");
++        WEBAPP_INVALID_URL_PATTERN_TEST(2, "://");
++        WEBAPP_INVALID_URL_PATTERN_TEST(3, "file://");
++        WEBAPP_INVALID_URL_PATTERN_TEST(4, "https?://");
++        WEBAPP_INVALID_URL_PATTERN_TEST(5, "https?://*");
++        WEBAPP_INVALID_URL_PATTERN_TEST(6, "https?://foo.*");
++        WEBAPP_INVALID_URL_PATTERN_TEST(7, "https?://foo.ba*r.com");
++        WEBAPP_INVALID_URL_PATTERN_TEST(8, "https?://foo.*.com/");
++        WEBAPP_INVALID_URL_PATTERN_TEST(9, "https?://foo.bar.*/");
++        WEBAPP_INVALID_URL_PATTERN_TEST(10, "https?://*.bar.*");
++        WEBAPP_INVALID_URL_PATTERN_TEST(11, "https?://*.bar.*/");
++        WEBAPP_INVALID_URL_PATTERN_TEST(12, "https?://*.bar.*/");
++        WEBAPP_INVALID_URL_PATTERN_TEST(13, "httpsfoo?://*.bar.com/");
++        WEBAPP_INVALID_URL_PATTERN_TEST(14, "httppoo://*.bar.com/");
++
++#undef WEBAPP_INVALID_URL_PATTERN_TEST
++
++        // Google patterns
++
++        QTest::newRow("Valid Google pattern")
++                << "https?://mail.google.*/*"
++                << "https?://mail.google.[^\\./]*/[^\\s]*";
++
++        QTest::newRow("Valid non Google pattern")
++                << "https://*.google.com/*"
++                << "https://[^\\./]*.google.com/[^\\s]*";
++
++#define WEBAPP_INVALID_GOOGLE_URL_PATTERN_TEST(id,invalid_google_url_pattern) \
++        QTest::newRow("Invalid Google App pattern " #id) \
++                << invalid_google_url_pattern \
++                << QString()
++
++        WEBAPP_INVALID_GOOGLE_URL_PATTERN_TEST(1, "https://*.google.*/*");
++        WEBAPP_INVALID_GOOGLE_URL_PATTERN_TEST(2, "https://service.gooo*gle.com/*");
++        WEBAPP_INVALID_GOOGLE_URL_PATTERN_TEST(3, "https://service.gooo?gle.com/*");
++        WEBAPP_INVALID_GOOGLE_URL_PATTERN_TEST(4, "https://service.goo*gle.com/*");
++        WEBAPP_INVALID_GOOGLE_URL_PATTERN_TEST(5, "https://serv?ice.goo*gle.com/*");
++        WEBAPP_INVALID_GOOGLE_URL_PATTERN_TEST(6, "https://se*rv?ice.goo*gle.com/*");
++        WEBAPP_INVALID_GOOGLE_URL_PATTERN_TEST(7, "https://se*rvice.goo*gle.com/*");
++        WEBAPP_INVALID_GOOGLE_URL_PATTERN_TEST(8, "https://se*rvice.goo*gle.*/*");
++    }
++
++    void transformedUrlPatterns()
++    {
++        QFETCH(QString, pattern);
++        QFETCH(QString, transformedPattern);
++        QCOMPARE(UrlPatternUtils::transformWebappSearchPatternToSafePattern(pattern), transformedPattern);
++    }
++};
++
++QTEST_MAIN(ContainerUrlPatternsTests)
++#include "tst_ContainerUrlPatterns.moc"